Coding agents such as Claude Code and Codex can load skills: packaged instructions for a kind of task, such as building a slide deck or tuning a Postgres query. The usual setup lists every skill's description at the start of a session so the model can pick one. That works with ten skills. I had more than a hundred and sixty, and the list alone cost about 15,000 tokens before I typed anything.
So I built Rosetta, a shared skill hub for both agents, around progressive disclosure. The agent sees a handful of routers, one per area. A router points to an index, and the index points to the single skill that fits. The library has since grown past 260 skills in 15 layers. This post is about what happened when I measured it.
The setup
I wrote 161 routing cases in my own phrasing: requests that should hit a skill, ambiguous ones, requests that no skill covers, and negatives that should trigger nothing. Part of the set is held out as a test split, and I only tune router text on the rest. A model plays the agent's selection step in a clean context, once with the flat list and once with routers.
What I measured
With Claude Sonnet as the agent:
- Startup tokens: 15,036 with the flat list, 1,241 with routers.
- Correct skill, dev split: 92.8% flat, 97.6% routers.
- Correct skill, held-out split: 92.1% flat, 89.5% routers.
Startup context fell by 92%. Accuracy went up on the split I tuned on and down slightly on the held-out one, so the fair summary is that routing held roughly even at a twelfth of the cost.
What went wrong
Stale descriptions. When I added new layers, accuracy with routers dropped to 86.7% on dev and 81.6% on test. The new skills were unreachable because the router descriptions still described the old contents. Regenerating them fixed it. The rule I kept: whenever a layer gains skills, regenerate its description and rerun the evaluation.
Smaller models skip the router. With a smaller model as the agent, routers lost to the flat list by about nine points. It often declined to open a router and tried the task itself. Two levels of indirection assume a model that is willing to look things up.
Shadowing built-ins. One agent took a detour through my media router before reaching its own built-in image generation. I now generate routers per agent and never list anything the agent can already do natively. On that agent, end-to-end results went from 4 of 6 to 6 of 6.
Wording matters more than naming. Descriptions that state a concrete verb and object ("tune Postgres slow queries and indexes") improved routing. Skill names and a "Use when" prefix on their own did not.
The same lesson in memory
Rosetta also gives both agents a shared memory. My first version injected remembered content into each prompt. Measured on real prompts, that content was useful 28% of the time and cost 153 tokens per prompt. I switched to pointers, one line that says what exists and where, at 27 tokens per prompt. The agent fetches the content only when it decides it needs it.
Both results point the same way. Context is a budget, and most of what you could put in it is not needed most of the time. Show the model where things are and let it ask.
Limits
These numbers come from one library, one user's phrasing and a few hundred cases. The end-to-end samples are small. I would not generalize the exact figures, but the failure modes above showed up clearly enough that I would check for them in any agent harness.