I manage about two hundred skills for an AI coding agent. The single rule that keeps them from becoming an unmaintainable mess: if two skills fire on the same trigger, they are one skill.
Skills are reusable behaviours — when X happens, do Y. An agent with many skills faces a routing problem. The user says “dispatch this task” and three skills match: one writes the spec, one dispatches it, one monitors the result. What happens? The agent picks one and misses the others. Or loads all three and gets conflicting instructions. Or the user has to invoke each separately, which defeats the purpose of having skills at all.
The fix is mapping triggers to skills one-to-one. “Build”, “dispatch”, and “implement” all point to one skill that handles spec writing, dispatch, and handoff to monitoring. “Monitor”, “check”, and “what ran” point to a different skill that handles polling, triage, review, and re-dispatch. “Wrap up” and “end of session” point to a third that handles memory capture, repo cleanup, and daily notes.
If a reference skill is only consulted by another skill and never triggered directly, merge it into the caller. A skill that is never invoked independently is just a section of another skill pretending to be separate.
I hit this concretely when I had three dispatch-related skills: one for dispatching tasks to AI executors, one for writing specs, and one for monitoring dispatched tasks. The spec-writing skill was never invoked directly. It was always “consult the spec writer before dispatching” — called from the dispatch skill. So I merged the spec-writing rules into the dispatch skill’s second phase. One skill, one trigger surface. The monitoring skill stays separate because it fires on a different trigger — not on “build” or “dispatch.”
The test for any two skills: does the user ever say a phrase that should invoke both? Merge. Does one always call the other? Merge the callee into the caller. Do they share state or context? Merge, with internal routing. None of the above? Keep separate.
Every skill the agent loads costs context tokens and decision complexity. Two skills that should be one create a “which skill handles this?” ambiguity that the agent resolves by guessing, and guessing wrong wastes turns. The skill system should feel like a well-organised toolbox: one tool per job, one drawer per tool. If you open two drawers for the same job, the toolbox is wrong.
In cell biology, this is receptor specificity. One ligand binds one receptor. If the same signal activated two different receptors with different downstream effects, the cell would get contradictory instructions. Evolution solves this by merging — receptors that respond to the same ligand get consolidated into one signalling pathway. Same principle: same trigger, one skill. Different trigger, different skill.