Stop Losing Your Best Colleagues Forever: dot-skill Is Here

What if your best engineer quit tomorrow—and took every decision framework, every unwritten rule, every "why we do it this way" with them?

Here's the brutal truth: it happens every single day. Companies hemorrhage institutional knowledge like a leaky pipe. That senior backend engineer who debugged your most arcane production issues? Gone. The mentor who knew which APIs to avoid, which vendors to trust, which corners never to cut? Retired. The teammate who held six months of context about why your architecture evolved the way it did? Transferred to another team, another city, another life.

You're left with documentation that nobody reads, handoff meetings where half the details evaporate, and a Slack history that buries critical decisions under 10,000 GIFs and lunch polls.

But what if you could bottle that person? Not a chatbot that parrots their LinkedIn bio. Something that actually thinks like them. That pushes back with their skepticism. That references their mental models. That speaks in their voice, with their edge cases, their blind spots, their genius.

That's exactly what dot-skill does. And it's about to change how engineering teams preserve what actually matters.

What Is dot-skill?

dot-skill (evolved from the original colleague-skill) is an open-source AI skill generation framework that transforms raw communication data—chat logs, emails, documents, interview transcripts—into interactive, installable AI personas. Created by @titanwings and powered by Shanghai AI Lab · AI Safety Center, this project has already crossed 15,000 GitHub stars and shows no signs of slowing.

The core philosophy is radical in its simplicity: flesh is weak, but patterns are eternal. Every person you interact with regularly exhibits reproducible cognitive patterns—how they evaluate tradeoffs, how they phrase pushback, what they prioritize when stakes are high. dot-skill extracts these patterns and encodes them as structured, versioned AI Skills that plug directly into your agent workflow.

Originally scoped to colleagues (hence colleague-skill), the framework has exploded into three character families: professional colleagues, intimate relationships, and public figures/celebrities. Each family uses specialized prompt pipelines, source-collection strategies, and generation templates tuned to the unique dynamics of that relationship type.

What makes dot-skill genuinely different from generic "AI clone" tools is its two-layer architecture: a Persona base that captures attitude, voice, and decision posture, plus family-specific capability modules that encode domain knowledge, workflows, and interaction patterns. The result isn't a shallow mimic—it's a functional cognitive replica that operates within the original's frame.

Key Features That Make Engineers Obsessive

Let's dissect what makes dot-skill technically compelling for developers who've seen dozens of "AI memory" projects come and go.

🧬 Three Character Families with Specialized Pipelines

The colleague family implements a Work Skill + Persona two-layer architecture. The Persona layer captures six dimensions: hard rules, identity, expression patterns, decision heuristics, interpersonal dynamics, and a living Correction layer. The Work Skill module encodes scope boundaries, preferred workflows, output standards, and experience-based knowledge. This isn't generic—it's designed for Feishu, DingTalk, and Slack auto-collection, with API integrations that pull real message history.

The relationship family prioritizes emotional fidelity: expression DNA, emotional triggers, conflict patterns, repair patterns. A photo-sharing feature is incoming, meaning these Skills won't just text back—they'll share slices of their day visually.

The celebrity family ships with a complete six-dimension research toolchain: works → interviews → decisions → expression DNA → external evaluations → timeline. This isn't tone mimicry; it's mental model reproduction.

🔬 Incremental Evolution & Version Control

Skills aren't static artifacts. Append new source files, and dot-skill auto-analyzes deltas, merging into relevant sections without overwriting existing conclusions. Conversation corrections write immediately to the Correction layer. Every update auto-archives, with full rollback capability via version_manager.py.

🌐 Cross-Host Compatibility

Generated Skills install across four agent hosts: Claude Code (native slash commands), Hermes (one-command install), OpenClaw (full compatibility), and Codex (invoke by skill name). The framework detects your host's skills directory automatically.

Real-World Use Cases Where dot-skill Shines

Scenario 1: The Departure Tsunami

Your company's senior architect announces they're leaving for a startup. Three years of microservice boundary decisions, performance optimization war stories, and "we tried that in 2023 and it failed because..." knowledge—poof. With dot-skill, you auto-collect their Feishu history, design docs, and review comments. Two hours later, you have /sarah-chen-work available in Claude Code. New engineers can ask why the payment service uses event sourcing, and get Sarah's actual reasoning—not a Confluence page last updated in 2024.

Scenario 2: The Distributed Team Timezone Hell

Your Tokyo-based SRE lead is brilliant but sleeps during your SF team's peak incident hours. Distill their incident response patterns into a Skill, and your on-call engineer gets their diagnostic approach at 3 AM without waking anyone. The Skill asks the same clarifying questions, suggests the same log queries, maintains the same skepticism about "quick fixes."

Scenario 3: The Relationship You Can't Let Go

This one hits different. Long-distance relationships strain. Friendships fade. dot-skill's relationship family lets you preserve the texture of how someone shows up for you—their hesitation patterns, their way of being serious when it matters, their specific brand of affection. It's not replacement; it's continuity during absence.

Scenario 4: Learning From Giants You'll Never Meet

Want to know how Andrej Karpathy would evaluate your Agent architecture? The celebrity family's research toolchain processes interviews, commits, essays, and talks into a Skill that reasons with his actual frameworks. Not quotes—models of thinking.

Step-by-Step Installation & Setup Guide

The 2026 way: let your agent install itself. Open Claude Code, Hermes, OpenClaw, or Codex and paste exactly this:

Install the dot-skill skill for me: https://github.com/titanwings/colleague-skill

Your agent detects the host, clones to the correct skills directory, and registers /dot-skill as an entrypoint. Done.

Manual installation paths (if you prefer control):

# Clone to your host's skills directory
git clone https://github.com/titanwings/colleague-skill ~/.claude/skills/dot-skill

Feishu auto-collection setup (most powerful for colleague distillation):

1. Create a Feishu App and bot in your organization's developer console
2. Add the bot to relevant group chats where your target colleague participates
3. Configure credentials in dot-skill's environment (see INSTALL.md for detailed credential handling)
4. Run python3 tools/feishu_auto_collector.py --user "Colleague Name" to pull message history, docs, and spreadsheets

For WeChat history (common for relationship family):

# Export using WeChatMsg, PyWxDump, or 留痕 first
# Then point dot-skill at the SQLite database
python3 tools/wechat_parser.py --db-path ~/exports/wechat_export.db

Post-install verification:

# List all generated skills across families
python3 tools/skill_writer.py --action list

# Check version history for any skill
python3 tools/version_manager.py --action history --skill sarah-chen

REAL Code Examples From the Repository

Let's examine actual tooling from the dot-skill repository, with detailed explanations of how each component functions.

Example 1: Celebrity Research Toolchain (Subtitle to Skill Pipeline)

The celebrity family's research pipeline is where dot-skill's technical sophistication becomes undeniable. Here's the actual workflow:

# Step 1: Download video subtitles from any platform
# This uses yt-dlp or similar under the hood, extracting .srt files
bash tools/research/download_subtitles.sh "https://youtube.com/watch?v=example" "./tmp/subtitles"

# Step 2: Convert raw SRT (with timestamps, line breaks, speaker labels) 
# into clean paragraph-style transcript suitable for analysis
python3 tools/research/srt_to_transcript.py "./tmp/subtitles/example.srt"

# Step 3: Merge all research materials into the six-dimension structure
# This analyzes works, interviews, decisions, expression DNA, 
# external evaluations, and timeline into unified SKILL.md
python3 tools/research/merge_research.py "./skills/celebrity/karpathy"

# Step 4: Quality check validates coverage, coherence, and 
# flags potential hallucinations or gaps in source grounding
python3 tools/research/quality_check.py "./skills/celebrity/karpathy/SKILL.md"

What's happening under the hood: The merge_research.py tool doesn't simply concatenate sources. It runs a multi-pass analysis where first-person materials (books, blogs, long interviews) are weighted highest for mental model extraction, while third-party commentary is flagged as "attribution needed." The quality checker specifically validates that no conclusion appears without source anchoring—a critical safeguard against the "confident hallucination" problem that plagues naive RAG implementations.

Example 2: Skill Invocation & Layered Access

Once generated, Skills expose granular access patterns. From the repository's usage documentation:

# Launch the creation wizard—picks family, gathers sources, generates Skill
/dot-skill

# Full invocation: persona + work capabilities combined
/sarah-chen-backend

# Work-only mode: technical decisions, code review, architecture guidance
# Use this when you need their expertise without personality overhead
/sarah-chen-backend-work

# Persona-only mode: voice, attitude, interpersonal style
# Useful for roleplay, drafting communications in their style, 
# or understanding how they'd frame an argument
/sarah-chen-backend-persona

The architectural insight: This three-tier invocation isn't convenience—it's cognitive load management. Full mode requires the LLM to simultaneously simulate personality and retrieve technical knowledge, which can produce richer but occasionally less precise outputs. Work-only mode strips personality computation, yielding faster, more deterministic technical responses. Persona-only mode isolates the social simulation layer for scenarios where relationship dynamics matter more than domain expertise.

Example 3: Incremental Update with Conversation Correction

One of dot-skill's most powerful features is live refinement. Here's how the correction system works in practice:

# During any Skill conversation, you can issue corrections
# The system captures these and writes to the Correction layer

# Example interaction:
# User: "Actually, Sarah would never suggest Redis for this. 
#        She had a bad experience with cache invalidation in 2024 
#        and always pushes for DynamoDB TTL patterns now."
# 
# The correction_handler.md prompt processes this, extracts:
#   - Trigger: caching layer selection
#   - Original pattern (inferred): default to Redis
#   - Corrected pattern: prefer DynamoDB TTL, with Redis skepticism
#   - Source: user correction with 2024 context
# 
# This writes to: skills/colleague/sarah-chen/persona.md Correction layer
# Takes effect immediately, persists across sessions

Why this matters: Most "memory" systems append raw conversation logs. dot-skill's correction system restructures knowledge—it identifies what pattern was wrong, what replaces it, and under what conditions the correction applies. This is closer to human learning than simple retrieval augmentation.

Example 4: Version Management for Living Skills

# Auto-archive triggers on every update, but you can manually manage

# Roll back to previous version after a bad source contamination
python3 tools/version_manager.py --action rollback \
  --skill sarah-chen \
  --version 2026.04.15-3

# Compare two versions to see what changed
python3 tools/version_manager.py --action diff \
  --skill sarah-chen \
  --v1 2026.04.15-2 \
  --v2 2026.04.15-3

# List all archived versions with source change summaries
python3 tools/version_manager.py --action history --skill sarah-chen

The safety model: Skills evolve as you feed new material, but bad sources happen—a contaminated chat export, a misattributed document. Version management treats Skills as versioned artifacts with full audit trails, not black boxes that mysteriously drift.

Advanced Usage & Best Practices

Source Quality Hierarchy (Non-Negotiable)

For colleague Skills, prioritize in this exact order: their own long-form writing (design docs, detailed review comments) > decision-making replies in threads > casual group chat. Casual chat is seductively voluminous but cognitively noisy. One architecture decision document outweighs 500 lunch arrangements.

Conflict Coverage for Relationship Skills

The relationship family performs best with source material spanning both harmony and friction. A Skill trained only on pleasant interactions will flatten into politeness. You need the repair patterns—how they apologize, how they return from distance, how they show up after conflict—to capture authentic presence.

Celebrity: Avoid Interpretation Layering

Never feed dot-skill only second-hand analyses of a public figure. The research toolchain specifically downweights third-party commentary. You want their direct words, their actual decisions, their unfiltered expressions. Commentary about them creates a simulacrum—an AI that sounds like critics describing someone, not someone thinking.

Multi-Host Deployment Strategy

Generate Skills in your primary host, then use tools/install_*_skill.py to replicate across environments. The Skill files are host-agnostic; only the entrypoint registration differs. This lets you use Claude Code for generation (best prompt engineering), Hermes for quick mobile access, and Codex for IDE-integrated coding assistance.

Comparison With Alternatives

The pattern is clear: dot-skill occupies a unique intersection of structured extraction, living evolution, and technical depth that neither generic RAG systems nor consumer character platforms attempt.

FAQ: What Developers Actually Ask

Q: Is this just a fancy RAG wrapper? A: No. RAG retrieves relevant chunks; dot-skill extracts cognitive patterns and encodes them as executable Persona + Work modules. The difference is structural understanding versus surface retrieval.

Q: Can I use this with my company's proprietary Slack/Teams data? A: Yes, but verify your compliance posture. dot-skill processes data locally; nothing phones home. However, your organization's data policies govern whether employee communication can be used for model training—even local, non-fine-tuned extraction.

Q: How much source material do I need? A: Minimum viable: ~10,000 words of quality source for colleague/celebrity, ~5,000 for relationship. More is better, but quality dominates quantity. One detailed design doc beats 100 "LGTM" comments.

Q: Does it work with non-English sources? A: Yes. The repository includes documentation in Chinese, Spanish, German, Japanese, Russian, Portuguese, and Korean. The extraction pipeline is language-agnostic.

Q: Can I commercialize generated Skills? A: MIT license covers the framework. Generated Skills contain your source material—commercial use depends on your rights to that source. The community gallery drives traffic to individual repos with no platform middleman.

Q: What's the difference between this and fine-tuning a model? A: dot-skill doesn't modify model weights. It generates structured prompts and knowledge modules that guide a base model's behavior. This means instant updates, version control, and no training infrastructure—at the cost of requiring the base model's reasoning capability.

Q: How do I know the Skill is accurate, not hallucinated? A: The quality_check.py tool validates source anchoring. Additionally, Work Skill outputs can be verified against actual code/commits. The Correction layer lets you fix drift immediately. But ultimately: trust but verify, same as human advice.

Conclusion: The Knowledge Preservation Revolution Starts Now

We've accepted catastrophic knowledge loss as inevitable. The senior engineer leaves, the context scatters, the team relearns painful lessons. We've built rituals—exit interviews, documentation sprints, handoff meetings—that paper over the fundamental problem: human memory is lossy, and organizations are made of humans.

dot-skill proposes something radical and something obvious: if we can extract the patterns of how someone thinks, we can preserve their functional contribution without preserving their physical presence. Not immortality—instrumentality. The distilled engineer doesn't replace the human; they extend the human's reach across time and space.

The framework is rough in places. It's "still a demo version," as the maintainers candidly note. But the 15,000 stars, the active community gallery with 100+ skills, the multi-language documentation, and the relentless shipping pace suggest this isn't a novelty—it's a new category.

Your best colleague is leaving. Your mentor is retiring. Your own patterns are evolving faster than you can document them. The question isn't whether you'll lose this knowledge. The question is whether you'll capture it while you can.

Install dot-skill now. Start with one person whose thinking you can't afford to lose. Run /dot-skill, feed it source material, and watch something impossible happen: they stay.

The flesh is weak. The skill is forever. 🧬