The Fable 5 and Sonnet 5 work loop
Splitting the work between the strong model and the fast model: planning, execution, review and fixing, with defined subagents and ready prompts for every stage.
What you get
Three defined subagents and a ready prompt for every stage of the loop
Who it is for
For anyone running everything on the strong model and burning through quota, or everything on the fast one and getting shallow planning.
1. Split the responsibility
One model does not need to do everything. The strong one thinks, the fast one executes, and the loop closes with a review.
- Fable 5 scans the project, checks the current state and plans.
- Sonnet 5 executes the plan: builds, writes, runs.
- At the end, Fable 5 goes over the result as a reviewer.
- Sonnet 5 fixes what the review found.
- You stay on product decisions, money, and customers.
2. Define three subagents
In Claude Code, every subagent is defined in a file under .claude/agents/, and each one has its own model field. That way every stage runs on the right model automatically:
# .claude/agents/planner.md
---
name: planner
description: Scans the codebase and produces a step-by-step plan. Use before any multi-file change.
model: fable
tools: Read, Grep, Glob
---
You are the project planner. Read the relevant code, map risks,
and return a numbered implementation plan with file paths.
Do NOT write code. End with open questions if any.
# .claude/agents/builder.md
---
name: builder
description: Implements an approved plan. Use for the execution stage.
model: sonnet
---
You implement the given plan exactly. Small steps, run checks
after each change, report what passed and what failed.
# .claude/agents/reviewer.md
---
name: reviewer
description: Reviews finished work against the plan. Use after the builder is done.
model: fable
tools: Read, Grep, Bash
---
You are a strict reviewer. Compare the result to the plan,
run the tests, and list concrete problems with file:line.
Do NOT fix anything yourself.3. Planning prompt
First stage: send the task to the planner. The output is a plan, not code.
Run the planner subagent on the following task:
Task: [what you want to build or change]
I want the planner to return:
1. A short scan: which files and flows are relevant.
2. A numbered plan with file paths.
3. Risks: what could break.
4. A definition of done: how we will know the task succeeded.
Do not start executing. Come back to me with the plan for approval.4. Execution prompt
Once you approve the plan, execution moves to the fast model:
The plan is approved. Run the builder subagent:
- Execute the plan step by step, exactly as defined.
- After every step: run the relevant tests.
- Do not add anything that is not in the plan.
- If something in the plan does not match the actual code, stop and come back to me.
At the end, report: what was done, what ran, and what failed, if anything.5. Review and fix prompt
The most important part: the loop does not end at execution. The strong model reviews, the fast one fixes:
Review stage:
Run the reviewer subagent on the finished work:
- Compare the result to the original plan.
- Run the tests.
- Return a list of concrete problems with file and line.
- Do not fix anything yourself.
If the review found problems:
Run the builder again with only the list of problems:
- Fix only what is on the list.
- Run tests after every fix.
Repeat review and fix until the reviewer returns an empty list,
or up to 3 rounds. After 3 rounds, stop and come back to me with what remains.6. When not to split
- A small change in one file: just ask, no ceremony.
- A task that is all thinking with no execution: the strong model alone is enough.
- If managing the loop takes longer than the work itself, the task is too small.
- Product and business decisions never enter the loop. They are yours.
How to use this now
The strong model is not meant for grunt work, and the fast one is not meant to decide alone. Give each one its own stage, and close every task with a review.