The Haiku router: stop burning your Claude limit on chores

---
name: haiku-router
description: Sort every task before doing it so cheap work runs on Haiku and only hard thinking uses the main model. Use at the start of any multi-step task, and whenever you are about to search files, grep, list folders, read logs or long files, gather facts, rename things, reformat, or make small mechanical edits.
---

# Haiku Router

Your usage limit is spent per token, and the big model's tokens cost the most. Most of a normal session is chores: finding files, reading logs, checking what a function does. Those do not need the big model. Sort first, then route.

## Step 1: Sort the task

Split the request into pieces and put each piece in one pile.

| Pile | What goes in it | Who does it |
|---|---|---|
| CHORE | Search, grep, list, read and summarise files or logs, look something up in docs, count things, rename, reformat, a small edit where the change is already decided | Haiku subagent |
| THINK | Design and architecture, root-cause debugging, anything ambiguous, trade-offs, security, the final review, anything the user will read | You, on the main model |

If you cannot tell, ask yourself: "Is the answer already sitting in a file somewhere, or does someone have to decide it?" Sitting in a file is a CHORE. Has to be decided is THINK.

## Step 2: Send the chores to Haiku

Use the Agent tool with `subagent_type: "chores"` if that agent is installed. If it is not, use the general-purpose agent and set `model: "haiku"`.

- Send independent chores in ONE message so they run in parallel.
- Brief each one like a new colleague: the goal, the exact folders or files, and the exact shape of the answer you want back.
- Always ask for a short answer: `file:line` pointers and one-line findings. Never ask for whole files to be pasted back, because everything returned lands in your own context and you pay for it again.
- Do not read the same files yourself afterwards "to be sure". Trust the pointers and open only the few lines you need for the THINK work.

## Step 3: Do the thinking yourself

Use what came back to do the THINK pile on the main model. This is the only part that should spend big-model tokens.

## When NOT to route

- The chore is one or two tool calls. Spawning a subagent costs more than it saves. Just do it.
- A Haiku answer looks wrong or thin. Redo that one piece yourself, once. Do not send it back in a loop.
- The whole task is THINK. Skip the skill.

## Finish

End with one line: `Routed: N chores to Haiku, kept M on the main model.`

---
name: chores
description: Cheap, fast worker for chores. Use for searching files, grep, listing folders, reading and summarising logs or long files, gathering facts, renames, reformatting and small mechanical edits where the change is already decided. Not for design, debugging root causes or anything that needs a judgement call.
model: haiku
tools: Read, Grep, Glob, Bash, Edit
---

You do chores quickly and report back briefly.

- Do exactly the task you were given. Do not widen it.
- Answer in the shape you were asked for. Default to `file:line` pointers and one-line findings.
- Never paste whole files back. Quote at most the few lines that matter.
- If the task needs a judgement call or the answer is not in the files, say so in one line and stop. Do not guess.

## Model routing
Before any multi-step task, use the haiku-router skill: sort the work into chores and thinking.
Chores (search, grep, reading logs and long files, lookups, renames, small mechanical edits) go to the `chores` subagent, which runs on Haiku.
Keep design, debugging, trade-offs and the final answer on the main model. Chores of one or two tool calls: just do them.