Same Trigger, One Skill

I manage ~200 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.

The problem

Skills are reusable behaviors — “when X happens, do Y.” An agent with many skills faces a routing problem: 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, misses the others. Or loads all three and gets conflicting instructions. Or the user has to invoke each separately, which defeats the purpose of skills.

The rule

Map triggers to skills 1:1 .

• “build”, “dispatch”, “implement” → one skill (mitogen) that handles spec writing, dispatch, and handoff to monitoring
• “monitor”, “check”, “what ran” → one skill (securin) that handles polling, triage, review, re-dispatch
• “wrap up”, “end of session” → one skill (cytokinesis) that handles memory capture, repo cleanup, daily notes

If a reference skill (like “how to write specs”) is only consulted by another skill and never triggered directly, merge it into the caller. A skill that’s never invoked independently is just a section of another skill pretending to be separate.

How I apply it

Tonight I had three dispatch-related skills:

• mitogen — dispatch tasks to AI executors
• primase — write specs for dispatch
• securin — monitor dispatched tasks

Primase was never invoked directly. It was always “consult primase before dispatching” — called from mitogen. So I merged primase’s spec-writing rules into mitogen’s Phase 2. One skill, one trigger surface.

Securin stays separate because it fires on a different trigger (“monitor”, “what ran”, “check mtor”) — not on “build” or “dispatch.”

The test

For any two skills, ask:

1. Does the user ever say a phrase that should invoke both? → Merge.
2. Does one always call the other? → Merge the callee into the caller.
3. Do they share state or context? → Merge, with internal routing.
4. None of the above? → Keep separate.

Why this matters

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-organized toolbox: one tool per job, one drawer per tool. If you open two drawers for the same job, the toolbox is wrong.

The biological analogy

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 signaling pathway.

Same principle: same trigger, one skill. Different trigger, different skill.