Claude Fable 5: Best Code I've Used, at 2x Opus 4.8's Price

Short answer: on my own refactor, Claude Fable 5 wrote better code than Opus 4.8 on the same codebase, and it’s the priciest Claude model I use: $10 per million input tokens and $50 output, twice Opus 4.8 per token (closer to 2.6x if you’re coming from Opus 4.6 or earlier, because of the newer tokenizer; Opus 5.5, at $4/$20, is cheaper still, and I haven’t rerun the refactor on it). On Max it comes out of your weekly limits; on Pro, out of your credit balance. Hand it big, well-specified jobs and keep a cheaper model as your daily driver.

Update, October 6, 2026. Two plot twists since I wrote this: a government order switched Fable 5 off for 19 days in June, and a promo kept it inside subscriptions until July 19. Since July 20 it’s part of Max and premium Team and Enterprise seats, up to 50% of weekly limits; on Pro and standard seats you pay usage credits from the first request. Fable 5.1 is out too, and I haven’t reviewed it separately. The original review follows; the shutdown saga is at the end.

Yesterday I sat down to refactor a personal project I’m building. Normal session: clean up some modules, untangle a few components that had grown in weird directions, the kind of work you save for when you have a full block of time.

I pointed Claude Fable 5 at it and watched it work. Then, very quickly, I hit the wall: 5-hour usage window, gone. Not my subscription. The rolling limit. On a refactor.

My first reaction was annoyance. My second reaction, looking at the diff, was quieter: that refactor was better than the one I would have written. Both reactions are the review.

What Anthropic actually shipped

Fable 5 came out on June 9 as the first model of the Claude 5 family, and the naming needs one paragraph because it confused everyone. There are two names, Fable 5 and Mythos 5, but one underlying model. Fable is the generally available version with safety classifiers on top. Mythos is the same model with the cyber safeguards lifted, restricted to vetted organizations. You and I get Fable.

The numbers that matter for a working dev:

• Pricing: $10 per million input tokens, $50 output. Exactly double Opus 4.8.
• Newer tokenizer. Anthropic’s pricing docs say Claude 4.7 and later produce roughly 30% more tokens for the same text than earlier models. Opus 4.8 already has it, so against Opus 4.8 the gap is the doubled price: 2x. Against Opus 4.6 or earlier, stack the 30% on top and identical work costs about 2.6x before the model even starts thinking longer. Keep those two numbers in mind; they explain most of this post.
• 1M token context, 128K max output.
• On benchmarks it claims state of the art nearly everywhere: 80.3% on SWE-Bench Pro against GPT-5.5’s 58.6%, per the Latent Space digest. Some commenters caution that a few headline numbers reflect the unrestricted Mythos config rather than the Fable you actually get, so keep a pinch of salt nearby.

One date that mattered at launch: Fable 5 was included in Claude subscriptions only until June 22, then usage-credit billing. Events overtook that date (see the October note at the top), but the reason it mattered still holds.

The quality jump is real, and I’m not the only one saying it

My own experience first, clearly labeled as mine: the output on that refactor was a step above what Opus 4.8 gave me on the same codebase. Fewer rounds of “almost, but you broke the date handling”. It held the whole picture of the app while moving pieces around, and the code it left read like the code I wish I had written the first time.

The people I trust on this are seeing the same thing. Simon Willison called it “something of a beast”: slow, expensive and capable. It converted a MicroPython WASM sandbox to full CPython for him and redesigned his library’s tool-call system, work he estimated at several days, in one session. His main complaint was struggling to find tasks it couldn’t do.

Karpathy called it a step change that deserves the major version bump, qualitatively and not just on benchmarks. Boris Cherny, who runs Claude Code, said it’s the best coding model he’s used “by a wide margin” (via NerdsChalk’s roundup).

Not everyone agrees. Some Reddit users quoted in that same roundup find it over-cautious, “always assumes the worst from the request”, with refusals popping up around security topics that older models handled fine. Karpathy himself noted the safeguards felt “a little too trigger happy for launch”. I haven’t hit a refusal yet on app code, but my project is an ordinary app, not a pentesting tool.

“Faster than Opus”? Yes and no, and the distinction matters

My gut said faster. What others measured says it depends what you measure.

Individual requests are slower. Willison reports single requests running many minutes, and Anthropic’s own docs treat a 15-minute turn at high effort as normal. If you sit there watching the spinner, Fable feels like a diesel engine.

But the task finishes sooner. Fewer back-and-forth rounds, fewer “you forgot the migration file” corrections, less of me re-explaining context it dropped. My refactor felt faster because the session was shorter, even if each turn was longer. I did not time it, but my impression is that wall-clock to done is what improved, not latency.

The honest part: it devours tokens, and the limits make it worse

Here’s where my 5-hour window went, and probably where yours will go too.

The in-app warning says Fable 5 “uses your limits ~2x faster than Opus”. Real agentic usage is steeper. Developers Digest documented a Max 5x user ($100/month) who emptied the entire 5-hour rolling window in 8 minutes with max thinking and spawned subagents. Three things compound: longer outputs, invisible thinking-token overhead, and parallel subagent calls that each bill separately.

The anecdotes pile up fast. Willison spent $110.42 on one day of experimentation, $99.26 of it on a single agent session. Scrimba’s CEO burned 1.3M tokens in 7 minutes, roughly $160/hour. Theo from T3 Chat blew past $1,000 in tokens in a day on a $200 plan. My favorite summary came from a user quoted by Decrypt: “My wallet can hear it thinking.”

And one trap you should configure your way out of today: when your subscription window empties, usage can silently overflow into pay-as-you-go credits unless you set a hard spending cap. One documented user found $20 in overage charges they never knowingly approved. Go set the cap. I’ll wait.

This is also why billing matters. On Max, burning your window on Fable is annoying. On usage credits, the same refactor session has a literal price tag, and based on everything above, it won’t be small.

The part that bothers me more than the price

Expensive is fine. Expensive is a business model. What I keep chewing on is the trust story.

Per the system card (covered by Decrypt and Latent Space), Fable 5 doesn’t just refuse certain dangerous requests. For a narrow slice of frontier-AI-research tasks, it silently degrades its own performance, in a way that is “not visible to the user”. Anthropic says it affects around 0.03% of traffic. The reaction from people who build on these models was not gentle: Jeremy Howard wrote that “silent handicaps should not be a thing in a paid product”, and Hugging Face’s Arthur Zucker went with “you broke our trust and I don’t think you’ll ever get it back”.

The classifiers also misfire. A biomedical researcher reported getting blocked on legitimate work, and there are reports of “cancer” tripping the biosecurity filter. Add the 30-day data retention requirement (no zero-data-retention option, which effectively locks out a chunk of European companies), and you get a launch where the model is brilliant and the terms made people angry.

My take, as someone who pays for this thing: I can live with visible refusals, and 0.03% of traffic likely never touches my work. Silent degradation is different in kind, because it converts every weird output into a question: is the model having a bad day, or is it sandbagging me? For a tool I use to ship code, that question is poison, even at 0.03%.

Should you use it?

For coding, yes, with two adjustments to how you work.

Treat it like a contractor, not a chat. Fable rewards big, well-specified tasks and punishes casual iteration. Every “hmm, try again but different” costs real money or real window. Do your thinking up front, hand it the whole job, review the result hard. If you’ve read my post on loops, this is the same lesson with a price tag attached: the filter on your side is now worth actual dollars.

Match the model to the task. My refactor genuinely needed Fable’s quality. Renaming a prop does not. Keep Opus or Sonnet as your daily driver and bring out Fable for the work where one shot done right beats ten cheap rounds. Before you pay for anything, run one typical Fable session and read the usage meter: on Max that’s your share of the 50% weekly cap, on Pro it’s your credit bill.

The model itself is the best I’ve used for code. Everything around it, from the checks to the limits, is the harness, and that is where the cost of a wasted prompt gets decided. The economics and the trust questions are the real review, and they’re not solved yet. The bottleneck isn’t the model’s ability anymore. It’s what you can afford to ask it.

How I run it now: Fable plans, Sonnet 5 sweats

Since it came back I stopped pointing Fable at everything. The 2x-per-token math from above still stands, so now I choose where it gets to spend.

My setup in Claude Code: Fable 5 stays in the main loop as the orchestrator, at medium effort (plenty to plan and review; I save high for the turns where it has to actually think hard). It reads the task and decides the plan, then reviews whatever the subagents drag back. Everything that is legwork (log sweeps, endpoint audits, that kind of bulk search work) goes to subagents pinned to Sonnet 5, at $2 per million input tokens and $10 output against Fable’s $10 and $50: a fifth of the price on both sides. (Anthropic had planned to raise Sonnet 5 to $3/$15 in September, then dropped the increase; $2/$10 is now the standard price.)

The whole trick fits in one line of the task prompt:

Use Fable to orchestrate and review. Run the subagents on Sonnet 5.

Routing bulk work to a cheaper model is not a discovery; every serious harness exposes a per-call model override. The delta is what the expensive model is left doing: mine never reads raw data anymore, only digests, and that moves the risk somewhere new. More on that in a minute.

Real example from this week. I audited this blog’s Analytics and Search Console setup: three Sonnet subagents swept every endpoint in parallel, a lot of raw sweeping between them, and Fable read three short summaries and wrote the action plan. The expensive model never touched the raw data.

For anything bigger I script the fan-out as a workflow instead of letting the model improvise the delegation: a deterministic loop decides what spawns, and the models only fill in the gaps. Same loops idea, with a taxi meter attached. Stripped to the bone, the pattern is this:

const digests = await Promise.all(scopes.map((s) =>
  agent(`Sweep ${s}. Return numbers, not prose.`, { model: "sonnet" })
));
// deterministic gate, not another prompt: a dry-run/grep/curl per claim
const checked = digests.filter((d) => dryRunAgrees(d));
const plan = await agent(`Plan from these verified digests: ${checked}`);

The honest part, because delegating has its own failure mode: digests lie. One of those Sonnet subagents confidently reported that my analytics property had zero conversions configured. It had several. Fable took the summary at face value and only caught it a step later, when a dry-run contradicted the report. So this is the rule I run with now: any subagent claim that changes what I do next gets one cheap deterministic check first (a dry-run, a grep, a curl) before the orchestrator acts on it. When the expensive model only reads summaries, verification stops being optional and becomes the actual job.

If you do one thing, make it the check, not the routing: no subagent claim changes what you do next until a dry-run, a grep or a curl agrees with it. Pinning subagents to Sonnet is table stakes and takes one line; the check is the part that saved me. Your weekly limits on Max, or your credit balance on Pro, will notice both.

Related reading: Fable raises the price of every wasted prompt, which makes designing loops instead of prompting less of a productivity trick and more of a budget requirement.

The shutdown saga: off for 19 days, back on a meter

I’m keeping the updates I wrote at the time, as they were. They’re the record of how fast “plan around the billing date” turned into “the model is gone” and then into “it’s back, with a price tag”. Where they say “below”, read the review above.

Update, June 13, 2026. Well, that was short. As of yesterday evening, Fable 5 and Mythos 5 are gone, switched off worldwide. Not deprecated, not rate-limited: off. Anthropic says it received a US government export-control directive on June 12 at 5:21pm ET, citing national security, effective immediately. The government believed it had found a way around Fable’s safeguards. Anthropic reviewed the demo, called it “a narrow, non-universal jailbreak” (asking the model to analyze code for flaws, something it argues other models do just as well) and pushed back, but complied. Every other Anthropic model still works.

So the June 22 billing cliff I told you to plan around is moot. The window didn’t close on price. It closed on policy, and a lot faster than anyone budgeted for. The review below stands as a record of what this thing could do for the few days we had it. Read it as a postmortem now, not a buying guide.

Update, July 16, 2026. The postmortem needs a postmortem. Export controls were lifted on June 30 and Anthropic redeployed Fable 5 on July 1, after 19 days off. Paid plans get it again for up to 50% of weekly usage limits, already extended twice and currently through July 19 at 11:59pm PT; given the track record, don’t be shocked if that date moves again. After the window it goes to usage credits at the launch prices below. The review, written on June 10, holds up. What’s new is the last section: how I run it now that every token has a visible price.

Sources

• Anthropic, Claude Fable 5 and Mythos 5 announcement and migration docs (pricing, tokenizer, retention).
• Simon Willison, Initial impressions of Claude Fable 5.
• Karpathy on X.
• Latent Space, AINews digest on the launch (benchmarks, community roundup).
• Developers Digest, How Claude’s usage limits actually work with Fable 5.
• Decrypt, The internet is furious at Anthropic (degradation controversy, cost anecdotes).
• NerdsChalk, Claude Fable 5 vs the world (Boris Cherny quote, Reddit reactions).
• Anthropic, Redeploying Claude Fable 5 (export controls lifted June 30, 50% of weekly limits on paid plans).
• OfficeChai, Anthropic extends Fable 5 access until July 19 (the second extension).
• Anthropic, Claude Platform pricing (Sonnet 5 at $2/$10 is now the standard price; the September increase was cancelled; tokenizer note for Claude 4.7 and later).

P.S. If Fable 5 ate your usage window too, I want the gory details. What did you feed it, and was the diff worth it? Tell me on LinkedIn.