Guide · Agent skill
How to use the Compound Learning Documenter agent skill (ce-compound)
Updated · written with AI from the project's own documentation and checked against our catalogue data
The Compound Learning Documenter (ce-compound) is an agent skill that turns a hard-won fix into a short written learning inside your repository. It is for developers and teams who want the reasoning behind a non-obvious solution to survive after the session ends. After this guide you will know what the skill does, how to install it from the ZIP, how to trigger it with plain requests, and what to check before letting it write files.
Compound Learning DocumenterEveryInc/compound-engineering-plugin · MIT Download the skill Quick start
- 1Download and unzip. Download the ce-compound ZIP from this page and unzip it.
- 2Place the folder. Move the skill folder into ~/.claude/skills/ for personal use, or into .claude/skills/ in your project.
- 3Or upload in the Claude apps. Go to Settings → Capabilities → Skills and upload the skill.
- 4Finish a fix. After verified work on a tricky problem, ask the agent to document the lesson.
- 5Review the result. Check whether the agent wrote a learning under <root>/solutions/ or wrote nothing and explained why.
- 6Commit deliberately. Review the new document before committing it, since it lives in the repository.
What an agent skill is and what ce-compound makes the agent do
An agent skill is a folder containing a SKILL.md instruction file and supporting references that an AI agent loads when a task matches the skill's description. This one is named ce-compound.
After a developer has solved a tricky problem, the skill makes the agent decide whether the reasoning behind the fix would be lost if only the final code and tests remained. If it would, the agent writes a short, grounded learning document under a solutions folder in the repository so the next person or agent can find it. If the lesson is already obvious from the code or existing docs, the agent writes nothing and explains why.
- Writes one learning per run, under <root>/solutions/ (root defaults to docs unless docs_root is set in .compound-engineering/config.yaml).
- Checks the document against the current tree so claims are grounded.
- Skips routine fixes such as typo corrections, where the code and tests already explain the lesson.
Install ce-compound from the ZIP
Download the ZIP for skills/ce-compound from this page, then unzip it. For a personal install, place the skill folder in ~/.claude/skills/. For a single project, place it in that project's .claude/skills/ folder.
In the Claude apps, you can instead upload the skill under Settings → Capabilities → Skills.
- Personal install: ~/.claude/skills/
- Project install: .claude/skills/ inside your project
- Claude apps: Settings → Capabilities → Skills, then upload
Trigger the skill with a natural request
You do not need a special command. Ask the agent in plain language right after a fix, for example that it should record the lesson so the next person does not repeat the mistake. The skill's description tells the agent when it applies: verified work that produced non-obvious reasoning absent from the final code, tests, or existing docs.
You can also invoke it directly and add brief context. Optional flags are mode:non-interactive and depth:lightweight or depth:full. Tokens starting with mode: or depth: are treated as flags, not as context.
- Example request: "We just fixed the cache invalidation bug. Document the lesson so we don't rediscover it."
- Direct form: /ce-compound [brief context]
- Non-interactive form: /ce-compound mode:non-interactive depth:lightweight [context]
/ce-compound [brief context]
/ce-compound mode:non-interactive depth:lightweight [context]
/ce-compound mode:non-interactive depth:full [context]What the skill needs and what it touches
The skill lists no required tools or dependencies. It runs no scripts and does not use the network. Its work happens through the agent reading your repository and writing documents.
Writes are limited. The orchestrator writes the one learning under <root>/solutions/, and may create CONCEPTS.md during vocabulary capture. In interactive Full mode, it may also add a small discoverability line to a project instruction file, but only after you consent. An instruction file is edited, never created.
- Requires: nothing listed
- Runs scripts: no
- Uses network: no
Review the safety notes before enabling writes
Documents are written into the repository and may be committed. If session content could contain secrets, do not run this skill on that work until you have checked what would be recorded.
In interactive mode the skill can add lines to project instruction files and rule files after you consent. If you do not want the agent writing files without review, keep the skill out of that workflow or review each change. Non-interactive mode asks no questions, so review its output afterwards.
- Do not use on sensitive projects where session content may include secrets.
- Expect that files written into the repo can be committed.
- Routine fixes are intentionally skipped; that is expected behaviour.
Tips for getting useful learnings
Run the skill once per problem. A session that solved several issues should produce several sequential runs, not one combined document, so each learning stays specific.
If the skill reports that nothing qualifies, read the reason. It usually means the lesson is already visible in the code, tests, or existing docs.
- Give a short context hint so the agent knows which problem to document.
- Ask for an update when an existing learning has become wrong; the skill updates it rather than creating a duplicate.
- Use the completion report to confirm whether a document was written or skipped.
What people use it for
- Recording why a race condition fix needed a specific ordering, so nobody removes it later.
- Capturing a debugging session's non-obvious root cause for a team that keeps hitting the same pitfall.
- Updating an existing learning that has become misleading after the codebase changed.
- Keeping lessons from agent-assisted sessions available to the next agent that opens the repo.
Frequently asked questions
Is the ce-compound skill free to use?
The source lists the licence as MIT. It does not mention pricing, so check the repository for any cost details before relying on it.
What does ce-compound require to run?
The skill lists no required dependencies. It runs no scripts and uses no network access, so it works through the agent reading and writing files in your repo.
Where do I install the ce-compound skill?
Unzip the downloaded ZIP into ~/.claude/skills/ for personal use or into a project's .claude/skills/ folder. In the Claude apps you can upload it under Settings → Capabilities → Skills.
Where does ce-compound save its documents?
It writes under <root>/solutions/. The root is docs by default, or the docs_root value in .compound-engineering/config.yaml if set.
Why did the skill write nothing?
The skill only writes when the reasoning behind a fix would be lost if only the final code and tests remained. If the lesson is obvious from the code or existing docs, it writes nothing and explains why.
Can I use ce-compound on a sensitive project?
The source warns against it where session content might contain secrets, because documents are written into the repo and may be committed. Review the content first or avoid it for those projects.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use ce-compound if you want non-obvious debugging lessons kept in your repo and found by the next person or agent, and if you are comfortable reviewing the documents it writes. Skip it for routine fixes, for repos where agents must not write files without review, and for sensitive projects where session content could hold secrets.
Download the skill