The skills we run, and how we pick a model for each task
We work in Claude Code, mostly with skills other engineers have published. Every subagent gets a model chosen for its task: a small one where we can check the answer, a large one where the task needs judgement.
Skills
The skills behind each step
A skill is a written procedure the agent loads when a task matches its description. These are the ones we run, by the step they serve.
| Step | Skill | What it does | From |
|---|---|---|---|
| Shape a feature | brainstorming | Works out intent and requirements one question at a time, then writes a design for approval before any code. | superpowers, by Jesse Vincent |
| Question the plan | grilling, grill-with-docs | Questions a plan or design relentlessly before the build. grill-with-docs also writes the decision records and glossary as it goes. | Matt Pocock |
| Plan the build | writing-plans | Turns the approved design into small tasks, each with its tests and the exact files it touches. | superpowers |
| Build | subagent-driven-development | Gives each task to a fresh agent, reviews each one against its spec, then reviews the whole change. | superpowers |
| Debug | systematic-debugging, diagnosing-bugs | Finds the cause before anyone proposes a fix: reproduce the bug, narrow it down, then test one explanation at a time. | superpowers and Matt Pocock |
| Review | code-review, receiving-code-review | Checks a change against the repository's written standards and against the spec it was built from. Then weighs each review comment against the code before acting on it. | Matt Pocock and superpowers |
| Design modules | codebase-design, improve-codebase-architecture | A shared vocabulary for module interfaces, and a scan of the codebase for modules worth deepening. | Matt Pocock |
| Edit prose | unslop | Strips the tells of machine-written text from our writing. | Our version of a skill in Cursor's plugins |
| Keep context small | context-mode, graphify | context-mode runs commands in a sandbox, so only the result we ask for enters the model's context. graphify builds a graph of the codebase that we query instead of reading files. | Mert Koseoğlu, and Graphify Labs |
The games on this site went through three of these steps: a written design, a plan of small tasks, and one agent per task with a review after each.
Models
Each subagent gets the model its task needs
A subagent is a separate agent the main session starts for one task. In a workflow we set each subagent's model and effort for its task, rather than let it inherit the session's. We name models by tier, not version, so the rules carry over when a new version ships.
| Work | Model | Effort |
|---|---|---|
| Finding code, listing files, exact quotes, counts, renames, and running tests to report the result | Haiku | medium |
| Routine coding, edits and refactors, and a first pass at review | Sonnet | medium |
| Planning, debugging, architecture, and checking whether a finding is real | Opus | high |
| Correctness-critical work, such as the last review before a release | Opus | xhigh or max |
Haiku gets gathering work only when we can check its output. Otherwise the gathering goes to Sonnet at low effort. Effort is a per-agent setting in Claude Code, with five levels: low, medium, high, xhigh and max.
How we brief a subagent
- A bounded question and a fixed shape for the answer, such as at most 15 findings, each a file and line with one sentence.
- It hands back findings, never pasted source or full command output.
- Two narrow subagents rather than one broad one. Each extra request re-sends everything the agent has read so far, so the size of the question sets the cost.
- Agents started together open with the same block of instructions, word for word, so the prompt cache can serve that block to each one after the first.
- Every agent is labelled with its model and effort, so a running workflow shows what runs where.
Try it
Route the task
Eight tasks from building the games on this site. Give each one a model, then compare your routing with ours.
The token counts are an example. Each task's prompt is 72,000 tokens or more, since our subagents start near 70,000 before they read anything, and the counts stay the same whichever model you pick, so only the price changes. Prices are Anthropic's list prices per million tokens, checked October 2026. Haiku 5.5 is $0.10 in and $0.50 out for prompts up to 100,000 tokens, and five times that above. Sonnet 5.5 is $2 in and $10 out. Opus 5.5 is $4 in and $20 out. Cached input costs 10% of the input price on Haiku and 5% on Sonnet and Opus, and we price new input as a five-minute cache write.
Run this process inside your team
We can set this up in your repositories and train your engineers to run it without us.