# yourself-skill: Distilling Your Own Chat History Into a Claude Code Persona

> yourself-skill turns exported chat logs, journals and photos into a two-part Claude Code skill: a self-memory file and a five-layer persona. It is a personal-archaeology tool with a thin parser layer and a real dependency on data you have to export yourself.

**notdog1998/yourself-skill** — 与其蒸馏别人，不如蒸馏自己。欢迎加入数字永生！Inspired by colleague-skill（同事skill）。

- Repository: https://github.com/notdog1998/yourself-skill
- Stars: 3,422 · Forks: 276
- Language: Python
- License: MIT
- Published: 2026-09-23 · Updated: 2026-09-23 · Language: en
- Canonical page: https://hysenlabs.com/projects/notdog1998-yourself-skill

## What yourself-skill actually solves, and for whom

There is a genre of Claude Code skill that distills another person: a colleague, an ex-partner. yourself-skill inverts the target. The README's own framing is that the person most worth distilling is you, because you are the one who has been talking to you for twenty-four hours a day. The deliverable is not a chatbot with your name on it but a structured artifact you can inspect: Part A holds personal history, values, habits, important memories and relationships; Part B holds a five-layer personality model that runs from hard rules down through identity, speech style, emotional patterns and interpersonal behaviour.

The intended user is someone with a pile of their own text already sitting in an export file. The README lists WeChat exports via WeChatMsg, 留痕 or PyWxDump, QQ exports in txt or mht, social media screenshots, Markdown or TXT journals, JPEG or PNG photos with EXIF data, and plain pasted text. It ranks these implicitly: chat logs plus journals beat dictation alone. If you have none of those, the tool still runs, because every intake field can be skipped, but the output is a description of you rather than a distillation of you.

The secondary use is stranger and more interesting. The generated skill ships in three modes. The full skill thinks and talks like you. The -self mode is an archive you query about your own past. The -persona mode strips memory and leaves only temperament and phrasing. That middle mode is the one with a non-obvious use: asking a copy of yourself why you keep procrastinating, and getting an answer assembled from your own recorded decisions rather than from generic advice.

## How the two-part structure and message flow work

The mechanism is a prompt pipeline, not a model. Seven templates live in prompts/: intake.md handles conversational data entry, self_analyzer.md and persona_analyzer.md extract memory and personality, self_builder.md and persona_builder.md render the two output files, merger.md handles incremental additions, and correction_handler.md processes user corrections. Python tools in tools/ sit underneath: wechat_parser.py, qq_parser.py, social_parser.py and photo_analyzer.py read the raw sources, while skill_writer.py and version_manager.py write and archive the generated skill.

The runtime flow is stated explicitly in the README: a message arrives, the Persona layer decides how you would respond, the Self Memory layer supplies personal background and values, and the output is phrased your way. That ordering matters. Persona is the gate, memory is the context. A question that never triggers a persona response still gets your biography attached to it.

The persona itself is five stacked layers: hard rules, then identity, then speech style, then emotional pattern, then interpersonal behaviour. Hard rules sit at the top, which suggests they are meant to override the softer layers below when they conflict. The README does not document how conflicts between layers are resolved in practice, and that is the weakest part of the specification. Tags feed into this: personality tags like 话痨, 嘴硬心软, 社恐, 深夜emo型, plus life-habit tags, all sixteen MBTI types and all twelve zodiac signs. The persona_analyzer prompt reportedly contains a tag translation table, which is where free-text self-description becomes something the builder can consume.

Generation writes into selves/, which the repository gitignores. That is a deliberate choice: your distilled self is not meant to be committed alongside the tool.

## Installing yourself-skill into Claude Code

The README opens the install section with a warning that Claude Code looks for skills in .claude/skills/ relative to the git repository root, so the clone has to happen in the right place. There are two supported locations. The project-local install keeps the skill scoped to one repository; the global install under ~/.claude/skills makes it available everywhere.

```bash
mkdir -p .claude/skills
git clone https://github.com/notdog1998/yourself-skill .claude/skills/create-yourself
```

Run that from the root of a git repository. Afterwards you should see a create-yourself directory inside .claude/skills containing SKILL.md, prompts/, tools/ and the rest of the tree. The global variant is a single command against your home directory:

```bash
git clone https://github.com/notdog1998/yourself-skill ~/.claude/skills/create-yourself
```

Python dependencies are optional and listed in requirements.txt. The README gives one line for them.

```bash
pip install -r requirements.txt
```

That pulls requests, Pillow and pypinyin, which map to the social parser, the photo analyzer and Chinese romanisation for slug generation. The README marks this step optional, which implies the skill can run on pasted text alone without the parsers. The badge on the README claims Python 3.9+.

First real use is a slash command inside Claude Code. Typing /create-yourself starts a prompt sequence covering your codename, basic information, a self-portrait, and then data sources. Every field can be skipped. When it finishes, the generated skill is invoked by its slug, and three management commands are documented alongside it: /list-selves, /yourself-rollback {slug} {version}, and /delete-yourself {slug}. The README also documents two sub-modes per self, /{slug}-self and /{slug}-persona.

## The parsers are the fragile part

Everything downstream of the parsers is prompt work, and prompt work degrades gracefully. The parsers do not. wechat_parser.py is written against the export formats produced by WeChatMsg, 留痕 and PyWxDump, three separate third-party projects that the README explicitly says are not bundled. Those formats are not stable public contracts. WeChatMsg and PyWxDump are Windows tools working against a moving target, and 留痕 covers macOS. If any of them changes its output shape, the parser breaks and the failure surfaces as an empty or malformed extraction rather than an error you can act on.

The README does not document a schema for accepted chat exports, does not list supported export versions, and does not describe what the parser does with a file it cannot parse. That silence is the practical risk. A user who exports from a tool version newer than the parser expects has no documented way to tell whether the extraction was complete or partial.

There is a second boundary worth naming. The tool is built around Chinese-language personal data. The tag system, the example outputs and the prompts are Chinese. pypinyin in requirements.txt exists to romanise slugs. An English-language user can run it, but the tag vocabulary and the persona examples are not written for them, and the README does not claim otherwise.

Finally, the README's own caution is worth taking literally: this is a tool for observing yourself, not an escape from reality, and the skill only represents the version of you that existed when it was distilled. The correction layer exists precisely because the artifact goes stale.

## Corrections, versioning and what rollback does not cover

Two evolution paths are documented. Appending memory means feeding more chat logs, journals or photos, which triggers incremental analysis and a merge into the matching part. Conversational correction means telling the skill "I would not say that," which writes into a Correction layer and takes effect immediately. The correction path is the more interesting one because it is a feedback loop on style rather than on facts, and it is the only mechanism that fixes phrasing without a re-run.

Version management archives each update and supports rollback through /yourself-rollback {slug} {version}. The version_manager.py tool handles the archiving. What the README does not document is rollback granularity: whether a version captures the whole self directory, only the two generated files, or the correction layer separately. Nor does it say whether a rollback is itself archived, which determines whether you can undo an undo. Anyone relying on this for long-lived selves should test rollback deliberately on a throwaway slug before trusting it.

Corrections also raise a question the README leaves open. If the Correction layer sits alongside Persona rather than inside it, then a correction can contradict the five-layer model without changing it. The README does not state where the Correction layer sits in the precedence order relative to hard rules. That is a real gap, not a nitpick, because hard rules are described as the top layer.

## How this differs from colleague-skill and ex-partner-skill

yourself-skill credits two predecessors. colleague-skill by titanwings originated the two-layer architecture of distilling a person into an AI skill. ex-partner-skill by therealXiaomanChu moved that architecture into an intimate-relationship setting. yourself-skill keeps the architecture and rotates the subject inward.

The difference is not cosmetic. When you distill a colleague, your source material is bounded by a professional context and your own observations of them. When you distill an ex-partner, you have their messages but not their interior. When you distill yourself, you have both the messages and the interior, which is why the intake flow asks for a self-portrait in addition to raw logs. That extra input is the structural distinction between this project and its two ancestors.

It also changes the failure mode. A colleague skill that gets the person wrong is an inaccurate tool. A self skill that gets you wrong is a mirror you disagree with, and the README anticipates this by framing the output as a checkpoint rather than a definition. The management commands reflect the same stance: you can correct it, roll it back, or delete it.

If your actual goal is a general-purpose personal assistant rather than a persona replica, none of these three is the right shape. They all assume you want the model to sound like a specific human.

## Licence, maintenance and upgrade cost

The project is MIT licensed, copyright Notdog. That permits commercial use, modification and redistribution provided the licence and copyright notice are retained. It also means the maintainer offers no warranty. Since the generated selves live in a gitignored directory, they are your data and not part of the licensed distribution; the licence covers the prompts and Python tools, not your exported chat history.

The repository is not archived. Its last push was on 2026-04-01. There are no retrieved releases, so there is no versioned changelog to read and no tagged upgrade path. Upgrading means pulling from master again. Because the install is a git clone into .claude/skills/create-yourself or ~/.claude/skills/create-yourself, an upgrade is a git pull in that directory, and any local edits to the prompts will conflict. If you have customised prompts, that is the cost you carry.

The generated selves are the other upgrade surface. A pull that changes persona_builder.md does not retroactively regenerate existing selves, and the README does not describe a migration path for selves built under older prompt templates. In practice that means regenerating from source data, which costs you the time of re-running intake and re-applying any corrections you made conversationally. Budget for that before you accumulate several selves.

One more boundary: the parsers adapt to third-party export formats, and those third-party tools are Windows-centric except for 留痕 on macOS. The README does not claim Linux support for any of the three.

## Conclusion

Adopt yourself-skill if you already have a WeChat, QQ or journal export and you want a Claude Code skill that answers in your own phrasing rather than a generic assistant voice. Do not adopt it if your only input is a paragraph of self-description and you expect the output to feel like you; the README states plainly that raw material quality determines fidelity, and chat logs plus journals beat dictation. Before committing, verify three things on your own machine: that Claude Code resolves the skill from .claude/skills/create-yourself at the git repository root, that your export format matches what wechat_parser.py or qq_parser.py expects, and that /yourself-rollback works against a version you deliberately created. The repository's last push was on 2026-04-01, so treat the parser layer as frozen and test it against your export before you build a habit around it.

## FAQ

### What data sources can yourself-skill read?

WeChat exports from WeChatMsg, 留痕 or PyWxDump, QQ exports in txt or mht, social media screenshots, Markdown or TXT journals, JPEG or PNG photos with EXIF, and plain pasted text. The README states that chat logs plus journals produce a closer replica than dictation alone.

### What are the two parts of a generated yourself-skill?

Part A is Self Memory, covering personal history, core values, habits, important memories, relationships and growth. Part B is Persona, a five-layer structure running from hard rules through identity, speech style, emotional patterns and interpersonal behaviour.

### Can I correct yourself-skill if it says something I would not say?

Yes. The README documents a conversational correction path: telling the skill "我不会这样说" writes into a Correction layer that takes effect immediately. Each update is also archived, and /yourself-rollback {slug} {version} returns to an earlier version.

### Where does yourself-skill store the selves it generates?

Generated selves are written into the selves/ directory, which the repository gitignores. The README's project structure lists it alongside prompts/, tools/ and docs/PRD.md, so your distilled self is kept out of version control with the tool itself.

## Sources

- [Issues](https://github.com/notdog1998/yourself-skill/issues)
- [License: MIT](https://github.com/notdog1998/yourself-skill/blob/master/LICENSE)
- [notdog1998/yourself-skill on GitHub](https://github.com/notdog1998/yourself-skill)
- [README](https://github.com/notdog1998/yourself-skill/blob/master/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/notdog1998-yourself-skill