$50 per million output tokens changes how you should use a frontier coding model. That is why this small Claude Code tip matters more than it looks.
Simon Willison shared a neat pattern: instead of micromanaging when Claude Fable should write tests or which model it should use, tell it to use its own judgement. In his example, Claude Code stores that as project memory and starts delegating implementation-heavy work to lower-power subagents while keeping higher-level review and synthesis in the main loop.
That is a good idea, and honestly an overdue one. If a tool claims it can operate like an agent, it should be able to choose when a trivial edit does not deserve the expensive model.
What is the actual trick?
The useful prompt is very simple:
For all coding tasks use your judgement to decide an appropriate lower power model and run that in a subagent
Claude Code then saved a memory file for the project with instructions to delegate coding tasks to a cheaper model, using Sonnet for more substantial implementation and Haiku for trivial or mechanical edits, while keeping design, auditing, synthesis, and review with the main model.
The core pattern here is bigger than Claude Code. It is the same design principle people are now using in Microsoft Copilot and AI agents: reserve the expensive reasoning path for judgment-heavy work, and route repetitive execution elsewhere.
Why this matters beyond one prompt
The pricing makes the argument pretty straightforward. Community research around Fable 5 puts it at $10 per million input tokens and $50 per million output tokens. That is not catastrophic for occasional deep work, but it is absolutely expensive enough that careless use turns into background spend nobody notices until the bill lands.
And coding agents are especially good at creating that kind of spend. They talk a lot, they retry, they summarize, they inspect files, and they often produce large outputs. If you let the top model handle every small refactor, copy tweak, and test adjustment, you are paying premium rates for work that usually does not need premium reasoning.
This is where a routing layer starts to look less like optimization and more like table stakes. Whether that lives inside Claude Code, behind an API gateway, or in your own AI workflow automation, the practical goal is the same: push cheap tasks down, keep judgment up top.
The real win is operational, not clever prompting
What I like here is not the prompt itself. It is that the instruction becomes memory. Once the tool internalizes the rule, you stop re-explaining your cost policy every session.
That has second-order effects:
- less token burn on routine implementation
- more consistent behavior across a project
- a cleaner split between execution and review
- a path toward auditable model-routing policies
That last point matters if teams start standardizing this. The minute model selection becomes automated, you will want to verify the tool is actually making sane choices. For a solo developer, "it feels cheaper" may be enough. For a team, I would still want an automation audit-style review of what gets delegated, when, and at what cost.
My take
This is one of those small workflow ideas that is more valuable than most model launch posts. Let the agent choose a cheaper subagent for code grunt work, and keep the expensive model for review and judgment. That is practical, easy to test, and aligned with how real engineering work gets done.
The caveat is simple: trust, but verify. I would not assume the routing is always optimal, and I would be surprised if every vendor exposed enough telemetry to prove it. But as a working default, this is smart. If you are using Fable for day-to-day coding, you should probably adopt some version of it now.
