When is the cheapest Claude good enough?
The cheapest model can miss the one thing a job is for, so let the top model plan, a strong model execute, and give the cheap model only bounded pieces with a check.
What the reel showed
Four Claude models, one short brief: a working drum machine in one web page, with sound you can hear and meters you can see. Opus 5, Sonnet 5, Haiku 4.5 and Fable 5.1, one attempt each.
Haiku 4.5 was done in under a minute for 13 cents, and its drum machine makes no sound. Sonnet 5 took 2m15 for $0.39 and Opus 5 took 3m12 for $1.00. Fable 5.1 took the longest, 5m20 for $2.83, and built one that works, with sound.
Same brief, a 22 times spread in price.
| Entrant | Tool | Time | Cost | Verdict |
|---|---|---|---|---|
| Claude Opus 5 | Claude Code | 3m12 | $1.00 | |
| Claude Sonnet 5 | Claude Code | 2m15 | $0.39 | |
| Claude Haiku 4.5 | Claude Code | 0m58 | $0.13 | Makes no sound |
| Claude Fable 5.1 | Claude Code | 5m20 | $2.83 | Works, with sound |
All four ran in Claude Code with the same brief, one attempt each; costs are read off each run's own bill and can differ from the figures shown in the reel.
What this means for your business
Haiku's silent drum machine is the lesson. It looks like a drum machine and does not do the one thing a drum machine is for. A cheap model can produce work that passes a glance and fails the job. In a business that looks like a summary that reads well and misses the key number, or a polite reply that answers the wrong question.
That is why I stopped asking which one model to use. Haiku is the wrong model to trust with a whole job, and Fable is more than most parts of a job need. Each is right for a different part.
Planning goes to the most capable model, because a plan that misses a hard requirement, like 'it has to make sound', breaks everything built on it. Execution goes to a strong everyday model. The cheap model gets small, bounded pieces with a check attached, so a miss is caught straight away instead of by a customer.
That is agent orchestration: one model plans, one executes, and sub-agents on cheaper models do the bounded pieces in parallel. It is how you get the best result per token instead of paying top prices for everything or cheap prices for a broken result.
What I’d use
My actual setup: I plan with Claude Fable 5.1. Once the plan is done, I switch to Opus to execute, and Opus spins up its own sub-agents for the independent pieces. The cheap models do their best work there, on bounded tasks with a check.
Pick the model for each part by what a miss would cost you, not by the price per token. At 13 cents against $2.83, Haiku is only cheaper if its mistakes are caught before a customer sees them.
I run all of this on my Claude and ChatGPT subscriptions, in Claude Code and Codex CLI, not on a bill per call.
Try it yourself
Run one real task the way I do, in Claude Code on a Claude subscription: plan on your most capable model, execute on a strong everyday one, and let it give the bounded pieces to sub-agents. Then test a cheap model on one bounded piece yourself.
Get Claude Code on your Claude plan
Claude Code is included with Claude Pro and Max. Install it and sign in with your Claude account, and your runs draw on your plan's usage limits instead of a bill per call. Fable is included on Max; on Pro it runs on paid usage credits, so on Pro you can plan with Opus instead.
Start the session on your planning model
Make an empty folder for this task and start Claude Code in it. Type /model and pick your most capable model from the list, for example Claude Fable 5.1.
Switching models in Claude Code
/model
Paste the planning prompt
Fill in the brackets, and be exact about the one thing that must work. The prompt tells the model to plan only, and to mark which steps can run in parallel and which are simple enough for a cheaper model.
I want to plan a piece of work before anyone starts on it. Do not write code, files or final content yet. Only plan. The task: [describe the task in two or three lines, e.g. "Build a price calculator for our website."] Who it is for: [your customers, your team, a client] The one thing that must work: [e.g. "the total matches our price list to the cent"] What done looks like: [how we will know it worked] Constraints: [budget, tone, tools we use, anything that must not change] Give me a written plan with: 1. Scope: what is in, what is out, and any questions you need me to answer first. 2. Steps, in order, each small enough to finish and check on its own. 3. Which steps can run in parallel because they do not depend on each other. 4. Ownership: for each step, which files or sections it creates or changes, so no two parallel steps touch the same thing. 5. A check for each step: how we will know it is done and correct. 6. For each step, whether it needs careful judgment or is simple enough for a cheaper, faster model. If anything is unclear, ask me first. Then write the plan and stop.
Read the plan and fix it now
Answer its questions and check that every step has a real check, especially for the thing that must work. Fixing the plan costs far less than fixing the work.
Switch to your execution model
Type /model again and pick a strong everyday model, for example Claude Opus. The plan stays in the conversation.
/model
Paste the execution prompt
This tells Opus to follow the plan, give the independent, bounded steps to sub-agents on a cheaper model, and keep the judgment calls and the final review for itself. Claude Code can start sub-agents and choose a model for each one.
Now carry out the plan above. You are the lead on this job. - Follow the plan step by step. If you find a problem with the plan, stop and tell me before you change course. - Hand the steps the plan marks as independent to sub-agents, running in parallel where they do not overlap. Where a step is bounded and easy to check, run that sub-agent on a cheaper, faster model. - Give each sub-agent a short brief: exactly what to do, which files or sections it owns, what not to touch, and the check that proves it is done. - Keep the steps that need judgment, putting the pieces together, and the final review for yourself. - When a sub-agent finishes, check its work against its check before you build on it. When everything is done, report: 1. what each sub-agent did, on which model, and whether its check passed 2. what you did yourself 3. anything left open, or that I should look at before I use the result
Test the cheap model on one bounded piece
Want to see for yourself where the cheap model is safe? Switch to it with /model haiku and paste this, with five real customer emails, names and details changed. Then check every order number and date against the emails. If Haiku gets every field right over a few rounds, that kind of piece can go to a cheap sub-agent. To see Haiku, Sonnet and Opus answer side by side with their costs, paste the same prompt into OpenRouter's chat instead: one account for every model, pay per use.
Below are five customer emails. For each one, return a table row with: - customer name - order number, exactly as written, or "none" - what they want: refund, replacement, question or complaint - any deadline they mention, as a date, or "none" Rule: never guess an order number. If it is not in the email, write "none". [Paste five emails here]
Links
- Claude CodeAnthropic's coding agentclaude.com
- Claude plansClaude Code is included with Pro and Maxclaude.com
- Claude Fable on your planIncluded on Max, usage credits on Prosupport.claude.com
- Switching models in Claude CodeThe /model commandcode.claude.com
- Sub-agents in Claude CodeHow Claude Code hands work to sub-agentscode.claude.com
- Codex CLIOpenAI's coding agent, signs in with a ChatGPT plangithub.com
- OpenRouterOne account, every model, pay per useopenrouter.ai
- OpenRouter chatSend one prompt to several models side by sideopenrouter.ai
- Claude Haiku 4.5Fastest and cheapestopenrouter.ai
- Claude Sonnet 5The everyday defaultopenrouter.ai
- Claude Opus 5Stronger reasoningopenrouter.ai
- Claude Fable 5.1Top tieropenrouter.ai
Want to know which parts of your work can run on the cheap model?
I set up the plan-then-execute workflow around your real tasks, find where a cheap sub-agent is safe, and put a check in where it is not.