Your Team’s AI Knowledge Walks Out the Door Every Time Someone Leaves. Here’s the Engineering Fix.

The “colleague.skill” wake-up call and what it reveals about enterprise AI blind spots

A few weeks ago, a GitHub project called “colleague.skill” went viral. The premise: a company fed a departing employee’s chat logs and documents into an AI, training a digital clone that could make their slides and answer questions in their voice. The debate it triggered wasn’t just about ethics — it surfaced a far more practical problem that every engineering leader already feels but struggles to name.

Your team has been using AI for months. The senior engineer who left last quarter had 200+ battle-tested prompts, 40+ branching workflow chains, and a mental library of context snippets she fed into every call. Where are they now? Not in Confluence. Not in the repo. They left with her personal account. And you didn’t even know what you lost.

This isn’t a knowledge management failure. It’s an architecture failure.

AI Output Doesn’t Look Like Documents Anymore

Traditional knowledge management captures files. Specs go in the drive, code goes in the repo, designs go on the server. When someone leaves, you revoke access and the artifacts stay.

AI-era output is different. What makes a senior engineer 3x faster with AI isn’t what they produce — it’s how they ask. The same task, the same model: one person gets production-quality output, another gets garbage. The difference is invisible and it’s leaving the building.

These “assets” fall into three categories:

Session patterns. Not chat logs themselves, but the proven context combinations and step-by-step guidance strategies. Given the same requirements breakdown, the senior knows what context to prep, what role to assign, how to chunk the prompt. The junior pastes a one-liner and gets output three levels worse.

Skill chains. Not single prompts, but conditional branching workflows refined over six months of iteration. Stable, tested, and completely invisible to the organization.

Memory snippets. “Our codebase convention is X.” “Watch out for Y in the legacy system.” “This client project uses naming pattern Z.” The senior feeds these into every AI call. The newcomer doesn’t even know they exist — and tries three times before guessing which version to trust.

The common thread: none of this lives in the company knowledge base. It lives in personal accounts, platform config UIs, and human brains. Researchers have a term for this: “blind-spot assets” — they exist, they generate value daily, but the organization doesn’t hold them.

Capture First, Then Distill

If your API calls scatter across dozens of personal accounts, there’s nothing to distill. The data isn’t yours.

Step one is unglamorous but non-negotiable: converge all calls through a single organizational exit point. Deploy a Local Proxy or Sidecar at the edge — no business code changes required. Every request gets intercepted, identity tagged, department attached. The call path shifts from individual → model platform to individual → org proxy → model platform.

From that moment, every AI dollar has an owner. Not “Li’s Claude allowance” — it’s “the R&D team’s Claude spend.”

But this just connects the pipe. The water’s flowing, but you don’t know if it’s mud or gold yet.

Make It Visible, Then Filter

Once calls are centralized, the runtime layer does two things simultaneously: forward requests, and capture context on the side. Session structures, skill execution paths, memory extraction traces — collected as structured data while the request passes through, not retroactively from logs.

For the first time, managers can answer questions they could only guess at before: Whose prompt quality is highest? Where is the API budget actually going? Which call chains are worth reusing?

The black box becomes observable. But you still can’t talk about “reuse” yet — staring at thousands of raw call records, you can’t pick anything out either.

The Refinery: Don’t Hoard Logs, Sift for Gold

Raw data enters a refinement module. The design principle: don’t save everything. Filter and process. Automatically strip PII and sensitive fields, discard irrelevant noise, preserve high-value call patterns, produce structured asset fragments.

Retention policy is admin-configurable: selective high-value capture by default, with the option to increase depth for key roles. The core logic: money spent on AI shouldn’t only produce this month’s output. It should also produce reusable knowledge units.

The Catalog: From Scattered Fragments to Searchable Assets

Refined assets enter a catalog with multi-axis tagging — by capability type, source department, applicable scenario. Anyone on the team can search and discover a prompt template for requirements analysis.

But discoverable doesn’t mean open access. The catalog enforces visibility scoping and share approvals. A prompt workflow refined by one department requires admin approval before neighboring teams can use it.

This directly addresses the most sensitive question from the “colleague.skill” debate: what gets captured are call patterns and business logic, not entire personal conversations. The refinery strips identity at the processing stage; the catalog adds an approval layer at the distribution stage. What gets preserved is “how it’s done,” not “who said what.”

Distillation: Turn the Recipe into a Ready Meal

The final step: distill high-frequency sessions and skill fragments into reproducible capability packages.

A team’s six-month-refined prompt chain gets solidified as a preset policy. Newcomers don’t start from scratch — there’s a verified path already in the call workflow. Not “go ask Bob for his prompts,” but “there’s a configured path in the policy library.”

Those context snippets seniors trigger constantly — “our code convention,” “legacy system caveats” — get purified and stored in a Memory pool. When juniors prompt AI in similar scenarios, these snippets auto-match. They don’t need to fill in gaps with information they don’t know exists.

From “Bob knows how to prompt” to “the policy library has a verified path.” This is fundamentally different from “write docs → dump in wiki → nobody reads.” It works at the point where calls happen.

Foundation First, Distillation Second

Put the entire pipeline together: ingress convergence → runtime capture → Asset Refinery → Catalog indexing → distillation reuse. Each step depends on the previous one.

If the ingress isn’t unified, the data isn’t in your hands — distillation is impossible. If the Refinery hasn’t done its filtering and tagging, distilling from raw logs produces garbage. If the Catalog doesn’t have access controls, sharing becomes chaos.

Your company already has 50 people using AI today. Don’t converge now, and after one turnover cycle six months later, what’s left is a pile of billing history nobody can interpret. The goal is to build the pipeline now — the foundation in place, the assets accumulate on their own. Every dollar spent on AI becomes not just this month’s output, but capability that stays in the organization.

If you’re exploring ways to make your team’s AI spend leave behind more than just this month’s output, https://aikeylabs.com/zh/i/md10 is a good place to start. For enterprise deployments: aikeyfounder@gmail.com.