Skills
Each skill owns one job and carries its own name and description. The assistant matches on those, so there is no dispatch table to maintain and no per-workflow always-on cost.
Open showcase
Describe the task. The right workflow, tools and guardrails load themselves.
A routing layer for GitHub Copilot and Claude Code: a library of focused skills that match to what you ask, a small always-on policy router, and the MCP integrations to act on real systems. This page replays how a request gets routed, using the real skill files, with no model calls.
How it works
Three layers, each loaded only when it is needed.
Your message"Fix this failing build"
Always-on routermeta-policy only
lines
lines
Skill catalog names and one-line descriptions
no skill bodies
no skill bodies
Matchload only the skills it needs
Overlapconsult router-playbook
No matchplain assistant, nothing loaded
Always-on router
Only rules that must hold in every conversation: load MCP guidance when tools are involved, never re-read what is already loaded, subagent ground rules, and the no-merge rule.
On-demand playbook
Edge cases a description cannot express: two skills overlap, a task spans phases, nothing matches, or a subagent might help. Read only when one of those fires.
Live replay
Pick a prompt. The replay shows what loads, what does not, and the workflow the skill will follow. It is pre-computed from tests/skill-triggers.json and the real skill files, so it costs nothing to run again and again.
Line counts are read from the real files. This replay shows which files load; it says nothing about token use, cost or premium requests, which depend on the model, the conversation and your plan. Matching shown here is what the test corpus expects; a real model decides at run time, which is why the corpus is also checked in CI.
Anatomy of a skill
The real opening of each file: frontmatter the assistant matches on, then the workflow it follows.
Say when, and when not
Every skill states what triggers it and what it is not for, and points to the neighbour that owns the near-miss.
Rules with reasons
Instructions are specific and checkable: coverage targets, read the code first, confirm before anything destructive, escalate by a fixed ladder.
Edited like code
Skills are versioned, linted, renamed through a manifest with migration, and refined against a trigger corpus instead of by feel.
Same task. Far less for the agent to read.
Everything an agent has to read to finish one task, stacked in the order it happens.
What loads, and what doesn't
Lazy-loaded MCP guidance
The MCP guidance used to be one 1,027-line file loaded up front. It is now a -line index plus one file per server, read only when that server is used.
Three escalation tiers
Do it inline. For heavy read-only batches, delegate to a cheap in-assistant worker. Hand off to a second agent only when your own budget is the constraint, using a short HANDOFF.md note so nothing is lost.
Match the model to the task
Pattern-following work (reviews, docs, stories) runs on cheaper models; multi-step reasoning is reserved for stronger ones, and each skill says which.
Guardrails
Autonomy with limits. Each rule is written where agents read it, and a test fails when it drifts.
Engineering rigor
The instructions are treated as production code: test suites, prompt cases in the demo corpus, and versioned releases.