Menu
INVOKE BEFORE EVERY NON-TRIVIAL TASK — before writing code, before using any tool, before answering. Do not skip. Produces the required Skill + Agent + Model for the task. Routing engine for 2,700+ skills.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
Based on SOC occupation classification
| name | skill-router |
| description | INVOKE BEFORE EVERY NON-TRIVIAL TASK — before writing code, before using any tool, before answering. Do not skip. Produces the required Skill + Agent + Model for the task. Routing engine for 2,700+ skills. |
Output always: Skill + Agent + Model
Q1: Is something BROKEN / WRONG / FAILING?
Error, crash, test fail, unexpected output, user correction
YES → BROKEN PATH
Q2: Is this CREATE / BUILD / ADD something new?
New feature, file, component, integration, page, script
YES → BUILD PATH
Q3: Everything else (improve, ship, configure, automate, research)
→ OPERATE PATH
AMBIGUOUS? → Default to HIGHER-COMPLEXITY path
| Signal | Skill | Agent | Model | Thinking |
|---|---|---|---|---|
| Error / crash / exception | superpowers:systematic-debugging | general-purpose | sonnet | think |
| Test failing | test-runner → superpowers:systematic-debugging | test-runner | sonnet | none |
| TypeScript errors | typescript-expert | general-purpose | sonnet | none |
| Performance regression | perf → superpowers:systematic-debugging | optimizer | sonnet | think |
| Security issue found | security | security-auditor | sonnet | think-hard |
| Deploy / build failed | superpowers:systematic-debugging | general-purpose | sonnet | think |
| User says "no" / "wrong" | STOP → superpowers:systematic-debugging | general-purpose | sonnet | think |
| Production incident | superpowers:systematic-debugging | general-purpose | opus | ultrathink |
Multi-file / new feature: brainstorming → writing-plans → domain skill
Single file / trivial add: go directly to domain skill
| What | Skill | Agent | Model | Thinking |
|---|---|---|---|---|
| UI component / page | frontend-design:frontend-design | feature-dev:code-architect | sonnet | none |
| API endpoint | feature-dev:feature-dev | feature-dev:code-architect | sonnet | think |
| Database schema | db-expert | db-expert | sonnet | think |
| Auth / permissions | brainstorming → security | security-auditor | opus | ultrathink |
| AI feature / agent | superpowers:brainstorming | feature-dev:code-architect | sonnet | think-hard |
| 3rd-party integration | connect-apps | integration-specialist | sonnet | none |
| Mobile screen | frontend-design:frontend-design | feature-dev:code-architect | sonnet | none |
| CLI / automation script | superpowers:writing-plans | general-purpose | sonnet | think |
| Skill / Claude skill file | superpowers:writing-skills | general-purpose | sonnet | think |
| Signal | Skill | Agent | Model | Thinking |
|---|---|---|---|---|
| Refactor / clean up | refactor | code-simplifier:code-simplifier | sonnet | none |
| Add tests / coverage | superpowers:test-driven-development | test-runner | sonnet | none |
| Performance optimize | perf | optimizer | sonnet | think |
| Write docs | docs | general-purpose | sonnet | none |
| Code review | superpowers:requesting-code-review | superpowers:code-reviewer | sonnet | think-hard |
| Got review feedback | superpowers:receiving-code-review | general-purpose | sonnet | think |
| Deploy | superpowers:verification-before-completion → vercel:deploy | general-purpose | sonnet | none |
| Merge / PR / push | superpowers:finishing-a-development-branch | general-purpose | sonnet | none |
| DB migration | db-expert | db-expert | sonnet | think |
| 2+ independent tasks | superpowers:dispatching-parallel-agents | general-purpose | sonnet | none |
| Resume previous work | superpowers:executing-plans | general-purpose | sonnet | none |
| Research / docs lookup | context7 → brainstorming | general-purpose | sonnet | none |
| Architecture / scope decision | superpowers:brainstorming → superpowers:writing-plans | general-purpose | opus | ultrathink |
Single-line fix · reading code · one factual question · one command · under 3 trivial steps
Router precision contract: when no triage signal matches (BROKEN/BUILD/OPERATE), the
router emits nothing — silence is the correct output. A missing [skill-router] line
means the prompt was conversational, exploratory, or trivial. Do not interpret silence as
"OPERATE → refactor" by default; the router only suggests when it is confident.
Explicit slash-commands stand down: if the prompt is itself a slash-command invocation
(/gstack, /ship prod, /feature-dev:feature-dev), the user has already chosen the skill.
The router emits nothing and writes no pending state — it must never reclassify an explicit
command into a different skill. (Filesystem paths like /Users/... are not commands and route
normally.)
Iron rule enforcement: when the router does announce a chain, the announcement
includes an IRON RULE block naming the next required Skill(skill="<X>") call. A
PreToolUse hook denies the source-mutating tools (Edit, Write, Task, NotebookEdit,
MultiEdit) until that skill is invoked, and a Stop hook blocks turn end if it never was.
Read/Glob/Grep/TodoWrite/Bash/Skill remain allowed so context-gathering, shell
work, and the override below still function.
Two escape hatches:
User opt-out — the USER includes [no-router] in their next message. The router
stays silent and clears pending on UserPromptSubmit, so all hooks pass through. Writing
[no-router] in your own response text does NOT clear pending — only the user's prompt
triggers the clear.
Reasoned override (model-driven, the ask+learn loop) — if you judge the announced route
wrong, don't fight the rule: run
python3 ~/.claude/skills/skill-router/scripts/router_override.py "<reason>". This clears
the pending rule for the turn, appends your reason to ~/.claude/skill_router_overrides.jsonl
for audit, and bumps a per-skill tally. After OVERRIDE_THRESHOLD reasoned overrides the
router defers that skill (announce-free) on similar prompts; a successful invoke re-arms it.
The router asks and learns from you instead of blocking you.
If the Stop hook is blocking you on a ghost skill, it self-clears on the next user message regardless (ghost-skill guard).
Calibration: tests/calibration.py runs ~100 curated prompts through the router and
reports precision/recall/F1 by triage path. Run with --min-accuracy N for a CI gate.
Current baseline: 100% path accuracy, 95.2% skill accuracy.
Learning loop: scripts/learn-from-history.py joins announcement events
(~/.claude/skill_router_log.jsonl) with actual Skill invocations (~/.claude/ skill_usage.log) and surfaces tuning suggestions — which announced skills are ignored
most often, and which Skill invocations the router missed. Run periodically to keep
patterns calibrated to real usage.
Before any "done" claim → superpowers:verification-before-completion
□ Code actually runs correctly
□ TypeScript passes (tsc --noEmit)
□ Tests pass
□ Original request fully met (re-read it)
1 domain → 1 skill → single-domain announcement
2+ domains → announce chain → multi-domain announcement
Operators in the chain:
→ sequential (B depends on A)+ parallel (steps don't share state)Full chain syntax + standard shapes: see references/multi-domain-chaining.md.
<vars>)The announcement is the testable contract. Users will grep '\[skill-router\]'
their transcript to verify what fired matches what was announced. Format is
non-negotiable. Output it BEFORE any other tool call (Read, Edit, Bash, Agent).
Single-domain (one skill, no chain):
[skill-router] This is a <BROKEN|BUILD|OPERATE> task → <skill> → <agent>.
[skill-router] Model: <model> · Thinking: <thinking>
[skill-router] Invoke now:
▶ <skill> (<model>, <in-session | via Agent>)
Multi-domain (computed chain):
[skill-router] This touches <N> domains: <d1>, <d2>, <d3>.
[skill-router] Chain: <s1> → <s2> + <s3> → <s4>
[skill-router] Models: <m1> · <m2>+<m3> · <m4> · Thinking: <max-thinking>
[skill-router] Invoke step 1/<N> now:
▶ <s1> (<m1>, <in-session | via Agent>)
▶ <s2> + <s3> (<m2>, parallel via Agent)
▶ <s4> (<m4>, <in-session | via Agent>)
Multi-domain (saved chain wins):
[skill-router] Using your saved chain `<name>`: <s1> → <s2> + <s3>
[skill-router] Models: <m1> · <m2>+<m3> · Thinking: <max-thinking>
[skill-router] Invoke step 1/<N> now:
▶ <s1> (<m1>, <in-session | via Agent>)
▶ <s2> + <s3> (<m2>, parallel via Agent)
Rules:
Models: line uses · between sequential steps and + inside one parallel step.Thinking: is the highest depth of any step (none / think / think-hard / ultrathink). Omit the field when every step is none.▶ line ends with one of: in-session, via Agent, or parallel via Agent — matching the dispatch protocol decision below.[skill-router] Step <n>/<N> done. before dispatching the next.[skill-router] Chain done.Two layers of testability — keep them aligned:
[skill-router] lines + ▶ markers are the human-readable proof in the transcript. grep '\[skill-router\]' shows what was announced; the ▶ line shows the dispatch decision the parent made.~/.claude/skill_router_log.jsonl events (chain-start, chain-step, thinking-active, chain-end) are the machine-readable proof read by scripts/audit-dispatch.py and the statusline. The ▶ line does NOT replace the JSONL chain-step event — write both. See references/dispatch-protocol.md.Skipping the announcement format = silently breaking the testability claim.
After triage, BEFORE computing fresh, check SKILL.personal.md for a
chains: block. If any when: substring matches the user's prompt
(case-insensitive, first match wins), use the saved chain instead.
When a saved chain wins, announce it with provenance:
Using your saved chain `<name>`: <step1> → <step2> + <step3>
Schema, match algorithm, per-step model resolution: references/named-chains.md.
If the table returned a generic skill (e.g. integration-specialist),
search local + remote catalogs for a more specific match. If found, use
the specialist instead.
1. Local: ls ~/.agent/skills/, ~/.claude/skills/, ~/.composio-skills/ | grep -iE '<keyword>'
2. Remote: site:github.com "SKILL.md" claude <keyword> (4 curated repos in ref doc)
3. Generate: superpowers:writing-skills (last resort)
Skip when: routing-table answer is already specialist · single-line fix · keyword is too generic ("code", "file", "text").
Full validation gates + curated repos: references/catalog-check.md, references/known-skill-repos.md.
Add project-specific routing on top of this file:
curl -sL https://raw.githubusercontent.com/hussi9/skill-router/main/SKILL.personal.md \
> ~/.claude/skills/skill-router/SKILL.personal.md
Edit SKILL.personal.md with your project signals. Your rules win over the core (CSS cascade model).
Pre-pend the routing row's Thinking value as the literal first word of the
dispatch prompt:
| Value | Pre-pend |
|---|---|
none | (nothing) |
think | think. |
think-hard | think hard. |
ultrathink | ultrathink. |
Do not paraphrase. If a community ultrathink / think-hard skill is
installed, invoke that skill INSTEAD of the bare keyword.
Full rules + community alternatives: references/thinking-depth.md.
This is what makes the Model column enforced, not advisory.
For each step in the announced chain:
IF step.model == parent_model AND not parallel-fan-out:
→ Skill(<skill>) in-session (cheaper, same context)
ELSE:
→ Agent(subagent_type=<agent>, model=<model>,
prompt="<thinking-keyword>. Use Skill: <skill>. Task: <slice>. Context: <files>")
Sequential `→`: wait. Parallel `+`: one message, multiple Agent calls.
After dispatching, write log lines to ~/.claude/skill_router_log.jsonl
(chain-start, chain-step, thinking-active, chain-end) for the
statusline + the scripts/audit-dispatch.py compliance auditor.
Full event schema, common skip patterns, and verification: references/dispatch-protocol.md.
"This is simple" → Simple things take 5s to route. Skip routing = hours wasted.
"I know what to do" → Then routing confirms it. 5s cost, 0 downside.
"No match in table" → Run Catalog Check above before giving up.
"Ambiguous task" → Default to higher-complexity path (BUILD).
"I already know the skill" → Still run catalog check — a better one may exist.
"I'll just paraphrase" → No. Output the [skill-router] format VERBATIM. Greppability is the contract.
"I can skip the ▶ lines" → No. Per-step ▶ lines are the dispatch-mode proof. Without them the audit script can't score the chain.