The Compounding Skill Library

From One Skill to a Library

The previous three lessons made a single skill phenomenal: it remembers (the recall loop), it grows (the correction-to-rule loop), and it ships safely (the sanitization gate). This capstone is about what happens when you have not one such skill but dozens — a library.

A library is not just a folder of skills. Done well, it is an authority moat: a curated fleet of trusted, composable capabilities that makes you faster than anyone working from scratch, and that nobody can replicate quickly because the value is in the curation, not the count. Done badly, it is a liability — duplicate triggers firing the wrong skill, stale skills giving bad advice, bloat slowing every session. The difference between the two is discipline.

The Compounding Flywheel

The flywheel has four stages and it feeds itself. You author one phenomenal skill — TDD-built, with a recall loop and a sanitization gate. The next skill reuses its parts: that gate becomes a template, that verification pattern becomes a default, that recall step becomes a one-line addition. Because you are composing proven pieces instead of inventing from scratch, each new skill costs less than the last. And a deep library of trusted skills becomes a moat — leverage that took you a hundred sessions to build and would take a competitor the same hundred to copy.

The mechanism is composition. The sanitization gate you wrote in lesson 669 is not a one-off; it is a part you drop into every outward-facing skill. The recall loop from lesson 667 is a part. The correction-capture step from lesson 668 is a part. By the tenth skill, writing a good verification gate is automatic, because you have written nine and kept the best version. The discipline compounds exactly the way it does for a craftsman: the tools you build let you build better tools.

The Trap: A Flywheel Can Spin Backward

The same flywheel that compounds value can compound liability. Add mediocre skills and every stage works against you:

• Duplicate triggers fire the wrong skill, so the operator stops trusting that the right one runs.
• Stale skills give advice that was true six months ago and is now wrong, quietly poisoning sessions.
• Bloat means every session loads more skill metadata, slowing the model's selection and burning tokens.

A library of fifty skills where ten are mediocre is worse than a library of ten that are all phenomenal — because the operator can no longer trust the fleet without auditing it. The flywheel only spins forward if curation keeps the bar high.

The Curation Lifecycle

Curation is not a vibe; it is a lifecycle every skill passes through, with a gate at each stage.

Five phases, each with a gate:

• Draft. Built TDD-style from a failure scenario, as taught in the foundational lessons. The gate: it has a real failure scenario and one verification gate, or it does not enter.
• Name and trigger. The gate: dedup by trigger. Before admitting the skill, check whether its trigger phrases overlap an existing skill. If they do, sharpen one or merge them. A phrase must fire exactly one skill.
• Admit to the library. The gate: it passes the sanitization scan from the previous lesson. A skill that leaks never ships, full stop.
• Maintain. The gate: the correction loop keeps it current. Every correction feeds back into the skill's body; repeated lessons get escalated.
• Prune / escalate. The gate: every skill earns its place every cycle. Unused, superseded, or duplicate skills are deleted. Rules that recur across many skills are escalated to CLAUDE.md so they live in one place.

The phase operators skip is the last one. Pruning feels like destroying work, so libraries accrete. But a skill nobody invokes is not free — it is trigger-space pollution and audit burden. Deleting it is curation, not loss.

Dedup by Trigger: The Curation Move That Matters Most

If you do only one curation discipline, do this one. The single most common library defect is trigger collision: two skills whose descriptions both match the same natural-language intent. When that happens, the selection is a coin flip, and eventually the wrong skill fires — producing a heavyweight result for a simple ask, or the opposite.

The fix is to make each skill own a distinct slice of intent. Either sharpen the triggers so the boundary is clean ("review a single file" vs. "audit the whole repo"), or recognize the two skills are really one and merge them. A library where every trigger phrase maps to exactly one skill is a library the operator can trust to do the right thing without thinking — and that trust is the entire point.

Escalation Closes the Loop

The correction-to-rule loop from lesson 668 had an escalation tier that ended at CLAUDE.md. At the library scale, that escalation is a curation tool. When you notice the same rule has been copied into three skills' bodies, that is the signal to promote it: lift it out of every skill and put it in CLAUDE.md, where it applies globally and lives in exactly one place. Now changing the rule means editing one file, not hunting for every copy. Escalation is how a cross-cutting rule stops being duplicated and starts being a single source of truth.

The capstone challenge brings it together: write the curation check that catches a trigger collision before a new skill is admitted to the library.

You've Completed Skill Engineering Mastery

You can now author a skill that remembers what it has learned, evolves from every correction, ships without leaking, and takes its place in a curated library that makes the next skill cheaper than the last. That is the whole loop — and it is the difference between a folder of prompts and a compounding authority moat. The skills you build from here make the ones after them easier. Keep the bar high, prune without mercy, and the flywheel does the rest.