create-colleague

Overview of create-colleague skill

What the create-colleague skill does

The create-colleague skill turns a real coworker’s artifacts into a reusable AI skill. Its core job is not generic biography writing; it is to distill how someone works, communicates, and makes decisions so you can recreate a usable collaborator profile from docs, chats, screenshots, emails, and workplace platforms like Feishu and DingTalk.

Who should install create-colleague

This is best for Skill Authoring users who want to preserve operational know-how after a teammate leaves, transfers, or hands off work. It is especially relevant if your team already has scattered evidence across workplace tools and wants something more structured than “write me a prompt that sounds like this person.”

What makes it different from a normal prompt

A plain prompt can imitate tone. The create-colleague skill aims to produce two distinct outputs: a work skill for task execution and a persona layer for communication style. The repo also includes ingestion paths for Feishu, DingTalk, email, and file-based inputs, which makes it more practical than manually pasting random snippets into chat.

What users care about before installing

Most adoption decisions come down to four questions: whether your source material is supported, whether install is tied to a specific agent environment, whether the generated output is editable after first pass, and whether the result can evolve over time. On those points, create-colleague is strongest in Claude Code-style skill workflows, supports both automated and manual collection paths, and explicitly includes update/evolution flows for corrections and new files.

Best-fit and misfit use cases

Use create-colleague when you have evidence of how a person actually worked: message history, docs, emails, screenshots, or written descriptions. Skip it if you only want a fictional persona, a lightweight one-off style mimic, or a generic team role template. This skill is about grounded distillation, not roleplay from thin input.

How to Use create-colleague skill

Install create-colleague in the right skill directory

The repo’s own install guidance is clone-based, not npx-based. For Claude Code, install it as create-colleague under either the project or global skills directory:

# project-local
mkdir -p .claude/skills
git clone https://github.com/titanwings/colleague-skill .claude/skills/create-colleague

# or global
git clone https://github.com/titanwings/colleague-skill ~/.claude/skills/create-colleague

For OpenClaw:

git clone https://github.com/titanwings/colleague-skill ~/.openclaw/workspace/skills/create-colleague

This matters because the skill trigger and generated output paths assume a named installed skill directory.

Install dependencies before testing collectors

The practical create-colleague install path depends on which sources you want to use. Base requirement is Python 3.9+. Optional packages unlock better ingestion:

pip3 install pypinyin
pip3 install playwright
playwright install chromium
npm install -g feishu-mcp
pip3 install python-docx openpyxl

If you skip these, the skill can still work with manual uploads and text input, but some automated collection and file conversion paths will not.

Start the skill with the actual trigger

In supported agent environments, invoke it with /create-colleague. The repo also documents natural-language triggers such as asking to create a colleague skill, plus update flows like /update-colleague {slug} and /list-colleagues. If your test plan is “install and then see if it wakes up correctly,” this trigger behavior is the first thing to verify.

Know what input create-colleague needs

The best outputs come from combining two input classes:

1. structured basics about the person
2. evidence of how they work

The workflow asks for basics like name, role, level, company context, personality hints, and your subjective impression. Then it ingests materials such as Feishu messages, DingTalk docs, exported JSON, emails, screenshots, PDFs, markdown, or pasted text. If you only provide demographic info without work artifacts, expect shallow output.

Turn a rough request into a strong create-colleague prompt

A weak request is: “Make a skill for Alice.”

A stronger create-colleague usage prompt is:

• who the person is
• what kind of work they did
• which materials you have
• what you need the generated skill to be good at
• where the signal is strongest
• what should not be inferred

Example:

/create-colleague

Name: Alice
Role: Staff backend engineer
Company context: B2B SaaS, billing platform
What I need: a skill that reproduces her incident response style, API review standards, and communication tone with PMs
Sources: 2 Feishu doc links, 1 exported message JSON, 6 screenshots of architecture notes, 3 handoff emails
Important: prioritize technical judgment and escalation habits over personality mimicry
Do not infer management style from jokes or casual chat

This kind of prompt reduces overfitting to surface tone and improves the work/persona split.

Choose the right collection path

The repo offers multiple source pipelines, and the right one affects effort and reliability:

• tools/feishu_auto_collector.py: best when you have Feishu app credentials
• tools/feishu_browser.py: useful for internal docs behind browser login
• tools/feishu_mcp_client.py: for Feishu doc access via token-based flow
• tools/dingtalk_auto_collector.py: DingTalk collection path
• tools/email_parser.py: .eml or .mbox
• tools/feishu_parser.py: exported Feishu JSON parsing

If your team cannot grant app credentials, browser or manual file routes may be the realistic starting point.

Read these files first

If you want to judge fit quickly, read in this order:

1. SKILL.md for trigger logic, allowed tools, and workflow
2. INSTALL.md for actual environment setup and dependency choices
3. README_EN.md for supported sources and user-facing framing
4. docs/PRD.md for the intended output model and evolution flow
5. prompts/ files if you plan to modify analysis behavior

This path gives faster decision-quality than browsing the repo tree randomly.

Understand the generated output structure

The repo’s product design separates output into:

• a Work Skill
• a Persona
• a combined SKILL.md-style result for direct use

That split is important for adoption. If you mainly want “how they solve work,” you can keep persona influence lighter. If you want more authentic communication, you can strengthen persona evidence. The skill is more useful than a single blended prompt because it treats capability and style as different signals.

Expect create-colleague to be iterative

A good create-colleague guide mindset is to treat the first run as draft generation. The skill supports “evolution mode” when you add files, correct claims, or refine behavior after review. This is a better fit for real workplace distillation than trying to nail a perfect one-shot prompt on day one.

Practical tips that improve output quality

High-signal inputs are:

• decision-heavy conversations, not only social chat
• docs with explicit standards, tradeoffs, or review comments
• examples across multiple tasks, not one isolated artifact
• your own corrections about what the person would never do

Lower-signal inputs are:

• only screenshots without context
• only flattering descriptions
• only formal docs with no evidence of decision style
• mixed materials from multiple people without labeling

Where outputs are written and why that matters

The install docs note that generated colleague skills are written under ./colleagues/ by default in Claude Code-oriented use. That matters operationally: before rollout, decide whether generated skills belong in your repo, a shared internal workspace, or a personal environment. Teams often underestimate the maintenance side of generated skills.

create-colleague skill FAQ

Is create-colleague for Skill Authoring beginners?

Yes, if you can already install a repo-based skill and provide source materials. The workflow is guided, but it is not a one-click consumer app. You will get better results if you are comfortable choosing data sources and reviewing generated output critically.

Is create-colleague better than an ordinary prompt?

Usually yes when the real problem is preserving a teammate’s working patterns, not just mimicking their voice. The extra value comes from structured intake, supported collectors, split work/persona generation, and an explicit update path. If all you need is “write in a direct style,” a normal prompt may be enough.

What kinds of source material work best?

The best mix is task-bearing material: message threads about decisions, review comments, internal docs, process notes, handoff emails, and examples of tradeoff reasoning. Personality-only data is not enough if you expect the generated skill to perform work credibly.

Does create-colleague require Feishu or DingTalk?

No. Those are important collection options, not hard requirements. You can also use PDFs, markdown, screenshots, emails, pasted text, and exported files. That makes the skill usable outside a strict Feishu-only workflow.

When should I not install create-colleague?

Do not choose it if you need a simple style preset, a fictional character, or a guaranteed accurate simulation of a person from sparse evidence. Also skip it if your environment cannot run the required skill tooling or if your data access model prevents exporting or collecting the necessary materials.

Can I update a generated colleague after the first version?

Yes. The repo explicitly supports appending files, correcting wrong inferences, and evolving an existing generated colleague. That is one of the strongest reasons to prefer create-colleague over a static handcrafted prompt.

How to Improve create-colleague skill

Give create-colleague evidence, not just adjectives

The fastest way to improve create-colleague results is to replace labels like “very rigorous” or “a bit sharp” with proof:

• review comments they repeatedly make
• examples of acceptable vs rejected work
• docs showing their default structure
• escalation messages during incidents
• phrases they use when uncertain

Evidence makes the generated work skill more actionable and the persona less caricatured.

Separate skill signals from personality signals

Users often mix “what they know” with “how they sound.” Better results come from marking inputs explicitly:

• work inputs: specs, code review notes, runbooks, architecture comments
• persona inputs: chat tone, conflict style, humor, ways of disagreeing

This helps the skill keep the work/persona outputs distinct instead of producing a vague imitation.

Label source reliability

Not all inputs should be weighted equally. Tell the skill which materials are canonical, recent, or noisy. For example:

• “These review comments reflect current standards”
• “These 2022 chats are outdated”
• “This screenshot is second-hand and may be inaccurate”

That reduces bad inference and helps create-colleague prioritize better evidence.

Correct the first draft with specific patches

When the first output is wrong, avoid saying only “this feels off.” Better corrections look like:

• “He prefers rollback first, not hotfix-in-place”
• “She is concise with peers but much more explanatory with junior engineers”
• “Do not make him sound sarcastic in formal docs”
• “Her strongest skill is requirements clarification, not system design”

Specific patches are easier to merge into the next version than vague dissatisfaction.

Use prompt files if you plan to customize behavior

The prompts/ directory is worth reading if you want to change how the skill analyzes or merges evidence. Files such as intake.md, work_analyzer.md, persona_analyzer.md, work_builder.md, persona_builder.md, merger.md, and correction_handler.md show where output quality is actually shaped. This is the right place to inspect if the default balance between work and persona does not fit your use case.

Watch for common failure modes

The main quality risks are:

• over-indexing on tone and under-building actual work capability
• inferring too much from sparse or biased materials
• blending multiple coworkers into one profile
• treating old artifacts as current behavior
• mistaking company process for personal style

These are not abstract AI issues; they are the practical reasons a generated colleague feels fake or unhelpful.

Improve create-colleague by narrowing the job to be done

If your first run feels broad, narrow the target. Ask for a colleague skill optimized for one domain first, such as incident response, architecture review, customer escalation, or PM communication. A narrower initial target often produces a more believable and useful result than trying to recreate an entire human at once.

Build a review loop before team rollout

If the generated skill will be used by others, review it with someone who worked closely with the original person. Ask them to validate:

• what the skill should definitely do
• what it should never claim
• which situations require escalation
• whether the communication style is accurate enough to be useful

This is the safest way to improve create-colleague for Skill Authoring in real team settings.

Keep the installation path maintainable

To improve long-term use, standardize where generated colleagues live, how updates are versioned, and which optional collectors your team officially supports. A skill that works only on one maintainer’s laptop is harder to trust than one with a clear install and update policy.

The simplest path to better create-colleague usage

If you want one practical rule: provide fewer but better artifacts, clearly labeled, then iterate with targeted corrections. That is the highest-leverage way to improve both the generated output and your overall create-colleague usage experience.