Illustrative diagram · the meta-skill is the box that contains and connects an ecosystem of skills; each skill has a level and rarity, and the collection accumulates XP.
🧬 What is a meta-skill
So far, you’ve built skills that do things. One meta-skill is different: it doesn’t perform a domain task—it governs how other skills come about, gain weight, and connect. Taproot is exactly that: a CLAUDE.md that teaches the agent to improve over time.
🎮 The agent becomes a character
Taproot gives your agent RPG attributes — and this isn't decoration; it's incentive mechanics:
- •Name and class — an identity that persists across sessions.
- •Level and XP — measurable progress that grows as skills are created and used.
- •Skills tree — an interconnected ecosystem you open in your browser.
💡 Why CLAUDE.md, not SKILL.md
A common skill (SKILL.md) is discovered and triggered by context. A meta-skill lives in the CLAUDE.md — the file that is always in the agent’s context for that project. It’s the right place for rules that should govern all behavior, not just one task. That’s why it “governs” instead of “executes.”
Doesn’t execute tasks.
Always in context.
Level, XP, class.
Visible in the browser.
⚡ Benefit 1: auto-generated skills
The first benefit is at the heart of the concept: self-generating skills. When the agent encounters the same error twice, it creates a permanent fix. When it notices a recurring pattern, it formalizes it as a reusable skill. Skills earn XP, have rarity levels (from Common to Legendary), and branch out into a connected ecosystem.
Error caught twice → permanent fix
The first time, it’s an accident. The second time, the agent recognizes it as a pattern and creates a permanent rule to never make that mistake again.
Recurring pattern → formalized skill
Something you do repeatedly becomes a skill with a name, description, and triggers—part of your toolkit.
XP creates weights that incentivize the loop
XP scores generate weights that encourage the skill-building cycle — the system is designed to feed itself.
| Rarity | What it usually means |
|---|---|
| Common | Small fix, used early and often. |
| Uncommon / Rare | A domain pattern that proved useful across several cases. |
| Legendary | Core skill, widely used and connected to several others. |
💡 The golden rule: "twice"
The threshold of “hitting the same error twice” is deliberate. Once may be noise; twice is a signal. Use this same trigger in your meta-skill—it prevents creating a skill for everything (noise) and ensures that anything turned into a skill is genuinely recurring.
📐 Benefit 2: plans before building
The second benefit combats the most common agent habit: jumping into coding based on false assumptions. Taproot runs a gap analysis on its own assumptions and proposes a build plan before writing a single line of code. It asks what it doesn’t know instead of guessing.
✓ Agent that plans
- ✓Does a gap analysis of its own assumptions.
- ✓Propose a build plan before coding.
- ✓Asks explicitly about what it doesn't know.
- ✓You fix the direction in the plan, at a low cost.
✗ Agent that guesses
- ✗Assumes requirements and starts writing code.
- ✗Only discovers the gaps when the build breaks.
- ✗You fix the direction in the finished code, at a high cost.
- ✗Rework becomes the norm.
🔎 Gap analysis in practice
The agent lists what it needs to know, marks what it already knows, identifies what’s missing, and turns the gaps into specific questions. Only then does it propose a plan. It’s the same principle as “measure twice, cut once”—applied to software.
Listed, not hidden.
They become questions.
Before the code.
Cheap, within budget.
🌳 Benefit 3: a tree you can see
The third benefit is what grabs your attention: a skills tree you can actually see. Open the generated HTML and follow the agent’s growth—a profile card, an arsenal of skills, and a network graph showing how the skills connect. Levels, XP, class progression, all visual.
Illustrative recreation of the Skill Tree page (not a real screenshot):
💡 Why making progress visible matters
When you see When you can see what the agent knows—and what’s missing—you make better decisions: where to invest, which skill is still weak, and which ones connect. Visibility changes behavior. It’s the same reason we have dashboards instead of raw logs.
Name, class, level.
Skills by rarity.
How they connect.
XP and progression.
📥 How to Use: From CLAUDE.md to the Tree
The adoption process is surprisingly short for something so powerful. Get the CLAUDE.md from the repository, drop it in the project root, open Claude Code, do a ~30-second onboarding, build something, and open the tree.
Drop the CLAUDE.md in the root
The file goes in your project’s root directory. From then on, it’s always in the agent’s context for that repository.
Open Claude Code and complete the onboarding
~30 seconds: the agent gets a name, class, and initial state. You don't need to configure anything manually.
Build something → open the skill tree
Work as usual. The agent captures patterns and earns XP. Open the visualization page and watch the tree grow.
# Coloque o CLAUDE.md na raiz e abra o Claude Code. # Depois, dispare o onboarding: "Inicie o onboarding do Taproot: me dê nome e classe ao agente, crie o estado inicial e me explique como ganho XP." # Trabalhe normalmente. Quando quiser ver a evolução: "Abra/atualize a árvore de skills (skill tree)."
🧩 Extras included
The repository also includes the Skill Tree preview page and one optional multi-agent orchestration add-on — what naturally connects to the next module’s topic (memory between agents).
🔮 The Vision for the Future
It’s worth looking at where the idea could go—not because all of this exists already, but because thinking about the vision helps you design your own meta-skill with room to grow. The proposal points in four directions.
🛒 Skills marketplace
Share and sell individual skills generated by the agent. Import/export with a single file: “this is the skill my agent created after hitting the same error 3 times.”
👤 Community profiles
Everyone gets a showcase featuring their agent’s character, arsenal, and stats. Browse other people’s agents and build on what the community learns.
⚔️ Agent comparison
Overlay skill trees side by side. Compare your agent's growth with others, in RPG-style stat cards.
🧬 Skill fusion
When two skills frequently trigger together, they merge into a composite skill. The agent doesn’t just collect skills—it synthesizes them.
💡 What to bring to your meta-skill
Even without a marketplace, three ideas are applicable today: (1) give the agent a persistent identity, (2) encourage the creation of skills with some kind of scoring, and (3) make progress visible. Start small; the big vision provides direction.
🏋️ Hands-on exercises
Define the "twice" rule
Write, in one sentence, the rule that will trigger skill creation in your agent. Also define what counts as the "same error" in your domain.
Design the XP scheme
Define how much XP each action earns (creating a skill, using an existing skill, fixing an error) and the level thresholds. List 3 rarities and the criteria for each.
Create a runnable meta-skill CLAUDE.md
Write a CLAUDE.md the minimum needed to give the agent an identity and the skill creation rule. Skeleton:
Save as CLAUDE.md at the root of a test project, open Claude Code and build anything. Then ask "open the skill tree".
📌 Module summary
Next module:
6.3 — 🧠 Multi-Agent Memory + /sessionend