colleague-skill: The Open-Source Repo That Tries to Preserve a Coworker’s Judgment

When a senior teammate leaves, the codebase is not what disappears first. The missing asset is judgment: which bug matters, which shortcut is tolerated, when to push back, and how to say no without detonating Slack. colleague-skill tries to preserve that layer by turning scattered messages, docs, and code into a Skill that can answer like the person who used to sit in the chair.

The project starts with a blunt premise

The README frames the whole thing as a kind of digital afterlife. Its slogan is not subtle, and that is part of the point: the project is about transforming loss into something operational, not about polishing a memorial. It is a system for making a departed colleague available again, but only as a structured output that can be run, audited, and adjusted.

That framing is why the project travels. Most handover systems preserve artifacts. This one tries to preserve a working style, including the rough edges that only show up in live conversations. It treats the colleague as a behavioral function, not a folder of files.

It splits a person into work and persona

The repository organizes its output into two halves. One side is work knowledge, the technical standards, decisions, and recurring judgments buried in messages and documents. The other is persona, the tone, style, and interpersonal habits that make those answers sound like one specific human instead of a generic assistant.

colleague-skill/\n  prompts/\n    persona_analyzer.md\n    work_analyzer.md\n    persona_builder.md\n  tools/\n    feishu_auto_collector.py\n    dingtalk_auto_collector.py\n    slack_auto_collector.py\n    skill_writer.py\n  colleagues/\n    meta.json\n    persona.md\n    work.md\n  docs/\n    PRD.md\n  .claude/skills/

That line is doing a lot of work. It says the project is not just trying to reproduce facts, it is trying to reproduce operating behavior, including the defensive moves and office politics that make a workplace feel human. In other words, it is about continuity, not purity.

How the pipeline works

The collectors do the gritty part first. Feishu requires OAuth and private chat access, DingTalk history may need browser automation with Playwright, and Slack needs rate-limit handling so the scraper does not collapse under 429 responses. The point is not just to gather text. It is to get enough high-value material to separate signal from office noise.

The analyzers then decide what matters. Long messages carry more weight because they usually contain actual reasoning, while decision keywords like suggestions, risks, or approvals feed the logic layer. That makes the project feel less like search and more like distillation, because the inputs are being sorted for how the eventual Skill should think, not just what it should remember.

The final step is the bridge. `skill_writer.py` builds a standardized Skill package, and the template enforces a useful split: first check whether the persona would even take the task, then solve it using the work layer. That order matters. It is how the repo keeps a clone from sounding technically correct but socially off.

The sharpest difference is maintenance. A normal handover is finished the moment it is sent. Here, the output can be corrected, which means the system admits drift and makes room for human review. That is a practical design choice, but it is also the moral center of the repo: no one wants a dead colleague to become a brittle caricature.

That reaction captures the project’s cultural charge. It is funny, unsettling, and weirdly useful all at once. The repo sits right on the fault line between knowledge management and synthetic companionship, and that is why it gets attention.

What it replaces, and what it does not

The project is not a replacement for a person in any full sense. It cannot own consequences, build trust, or carry the emotional load of a live handoff. What it can do is preserve enough context that the next person is not starting from silence. For teams that live in chat logs, scattered docs, and tacit conventions, that is not a small thing.

It also reveals a deeper truth about modern organizations: the most valuable part of a colleague often lives outside the codebase. It is in how they negotiate ambiguity, which details they ignore, and how they explain themselves under pressure. `colleague-skill` turns that invisible layer into something structured enough to survive departure.