Anthropic announced a few weeks ago that Fable would be moving behind API pricing, and today the change takes effect. I’ve been thinking about it since the announcement, because Fable has become the model I reach for whenever I’m planning larger pieces of work. I assumed I’d respond by swapping in cheaper models more often. Instead I’m changing where Fable sits in the workflow, because once I looked at what I was actually buying from it, most of the spend was regeneration, not reasoning.
Until now the loop looked like this: Fable generates an implementation plan, I fan the work out to cheaper models, collect the results, hand everything back to Fable for a revised plan, and repeat until the plan is stable enough to implement against. Looking back at those revisions, most of what I was paying for was another copy of a document that was already mostly correct. The architecture rarely changed between versions. What changed was small: a requirement I hadn’t thought of, an assumption corrected after reading more of the codebase, a contract update, an edge case that surfaced during review. Everything else got regenerated because regenerating was easier than maintaining the document. I was paying frontier prices to reprint pages that hadn’t changed.
The new workflow starts one tier down. Opus generates the initial implementation plan, because the initial architecture is still worth frontier reasoning, but it turns out not to need the most expensive reasoning available. The first draft doesn’t have to be perfect, because the rest of the loop exists to make it converge. After that I gather the current state of the project — code, documentation, contracts, architecture decisions, whatever accurately describes the system — and hand the plan and that state to several cheaper models to review independently. They’re not writing a better plan. They’re trying to prove the current one wrong: the missing requirement, the stale assumption, the contract that doesn’t survive contact with the code.
Fable comes in once, at the end of the loop, and its job is judgment rather than authorship. It gets the original plan together with everything the review models found. Some of those findings will be valid, some won’t, and some will contradict each other, and a reviewer’s report is a claim, not a fact. So the work starts with verification, checking the findings against the actual state of the system instead of taking the reviewers’ word for it, and ends with a decision: which of the verified observations actually change the architecture, and what is the smallest edit that reflects them. If a section is still correct, I don’t want a second copy of it. If one contract needs to change, only that contract changes. Fable never writes the document. The unit of frontier work is the diff.
Working through this changed something else I wasn’t expecting. I’ve spent a lot of time building orchestration systems where the strongest model sits at the top, delegates work to cheaper models, and pulls the results back together. This workflow inverts that. The cheaper models do the generating and the exploring: they draft the plan, search for problems, challenge assumptions, and look for missing pieces. Fable doesn’t orchestrate any of that, because orchestration doesn’t need it. It sits at the end as the skeptic, spending its reasoning on the two things the cheaper models can’t be trusted to do for themselves: verifying what they claim, and deciding what actually matters.
While I was working through this I turned the process into a Claude Code skill. The maintains a rolling implementation plan as a governor, not an author. Each cycle it takes the current plan plus a ledger of what actually happened — session reports, merged PRs, ticket state, decisions — and treats every report as a claim rather than a fact. It verifies the claims it can probe against live surfaces, then applies the smallest evidence-backed delta that makes the plan true again. It is mechanically barred from doing anything more: touching a section with no supporting evidence is a hard failure, and so is dropping unfinished work without a positive signal that it’s done or obsolete. Most of the document survives every cycle untouched, because most of the document is usually still correct. The implementation is a clearer description of the workflow than this post is, which is why I’m publishing them together.
I don’t know yet whether any of this reduces my overall development cost. It should be measurable. Over the next few weeks I’ll compare implementation retries, contract churn, verification failures, planning revisions, and total token usage against the workflow I’ve been running until now. If nothing else, Fable moving behind API pricing forced me to look at where I was actually spending frontier reasoning instead of where I assumed I was spending it.
