This post originally went up during Fable 5's free launch window, when the question was which tasks to cram in before the meter started running. That window is long gone, and it turned out to be the least interesting thing about the model. The question that survives is harder and more useful: when is the most expensive model Anthropic ships actually worth paying for? After months of running Fable 5 daily across my own projects — this site, client work, content operations — my answer fits in one sentence. Fable 5 earns its price when you make it extract insight from a large pile of context and then act on it. Small prompts waste it. Big context feeds it.
Everything below follows from that rule. These are the five use cases where I keep choosing Fable 5 on purpose, with the real work behind each one — plus the tasks where paying the premium is setting money on fire.
The economics, so the rest makes sense
Fable 5 runs $10 per million input tokens and $50 per million output — exactly double Opus 4.8's $5/$25. Batch API cuts that in half, and prompt caching discounts repeated input by 90%, which matters more than people realize for the workflows below. Those two levers are the difference between "premium model" and "premium model I can afford to run on a 500-post blog."
Double the price means the model has to be more than incrementally better at your task. In my experience it clears that bar in exactly one category: work where the value comes from holding an entire system in context at once — a whole codebase, a whole content corpus, a whole business surface — and reasoning across it. On narrow, well-scoped tasks, the cheaper tiers produce the same output and the delta is pure waste. So the skill is not prompting. The skill is routing.
Use case 1: whole-corpus content operations
The heaviest Fable-class work I have ever run was a surgical rewrite of 84 blog posts on this site — not a template pass, but per-post fact verification, link repair, and de-templating, executed in resumable batches with a durable status manifest. The reason this needed the top model and not a cheaper one: each rewrite decision depended on corpus-level context. Is this phrasing already used in five sibling posts? Does this internal link target a slug that exists? Is this claim consistent with what the other posts say? Those questions require the posts index, the style rules, and the current post in context simultaneously.
That is precisely what the 1M-token context window buys you. A model reasoning post-by-post writes 84 individually fine, collectively identical articles — I know because that is roughly how the corpus got into the state that needed rescuing. The economics work because of caching and batching: the shared context (index, rules) is cached input at 90% off, and nothing about an overnight rewrite queue needs interactive latency, so batch pricing applies. My full pipeline for this kind of work is in automating SEO content with Claude Code.
Use case 2: ship-readiness and honesty audits
The most valuable single findings Fable-class models have produced for me were not features. They were audits — and specifically the cross-cutting bugs that no unit test exercises because they live between components.
Two real examples from my own site. First: my AI systems page had a lead form that was silently broken in production — the frontend never set the captcha token, and separately, my guest-page caching middleware stripped cookies in a way that broke the submission path. Every individual piece "worked." The composite was a form that ate every lead. That bug was found only when I had the model drive a real end-to-end pass instead of reading files in isolation. Second: a deindexing problem I had chased for weeks traced back to fabricated review schema markup that earlier AI-generated content had confidently invented. Finding it required auditing what was actually rendered across page types against what Google's guidelines allow — again, a whole-surface question, not a single-file question.
This is the use case where I now deliberately reach for the expensive model before anything ships: review the entire surface, find what breaks between the seams, hold a high bar. Green tests and "safe to ship" are different sentences, and the gap between them is exactly the kind of distributed reasoning where the top-tier model demonstrably outperforms the mid-tier ones.
Use case 3: cross-surface refactors
I rebuilt this blog's design around a shared token system — one set of design tokens driven through every blog surface: listing pages, post pages, category and tag pages, search, related-post components. The hard part of a refactor like that is not any single template. It is consistency: the same spacing decision, the same dark-mode behavior, the same typography rule applied identically across dozens of Blade templates that were written over years and drifted apart.
A cheaper model handles each template competently and drifts across them, because it cannot hold the whole set plus the token definitions at once. Fable 5 holds the entire surface, which converts "refactor 30 templates" from 30 tasks into one task with 30 outputs. My honest verdict: for one-file changes, the premium buys nothing. For N-file changes that must agree with each other, it buys the agreement — and reviewing agreement is much cheaper than reconciling drift by hand afterward. Related discipline, because these sessions are token-hungry: my token management setup.
Use case 4: plan expensive, execute cheap
The highest-ROI pattern I run: Fable 5 writes the plan, cheaper models execute it. This whole remediation era of my site has run on that split — a top-model session analyzes the problem space and produces batch assignments with per-item evidence and acceptance criteria; then worker sessions on cheaper tiers grind through the batches against those specs.
The insight that took me longest to internalize is that plan quality is the multiplier on everything downstream. A mediocre plan executed by a great model produces polished versions of the wrong thing. A great plan executed by a mediocre model mostly produces the right thing, because the judgment already happened. So I spend top-model tokens where judgment concentrates — decomposition, evidence standards, edge-case enumeration, kill criteria — and stopped spending them where it does not, which is the typing. The same division of labor shows up in my multi-agent architecture notes: one expensive brain, many cheap hands.
Use case 5: make it rank its own work
The meta-move, and the one I would run first if you only steal one thing: before assigning Fable 5 anything, hand it your actual project inventory and ask it to rank where it is worth spending itself. Not "what should I do" — specifically "which of these tasks are complex and valuable enough to justify your price, and which should go to a cheaper model?"
I did this with my real backlog — a six-locale translation set that had drifted out of sync with rewritten English posts, a content section that needed rebuilding from verified sources, an 850-item prompt library needing depth work, ongoing indexation remediation. The ranking that came back was better-calibrated than mine, and the tell was instructive: every task it ranked highly had the same shape — large corpus in, synthesized judgment out. The tasks it ranked low were the well-scoped mechanical ones, which it correctly identified as beneath its price point. The model knows what it is for. Most users never ask it.
Where Fable 5 is the wrong answer
The discipline that makes the five cases above affordable is refusing the premium everywhere else. Renaming variables, writing a single migration, drafting an email, debugging one error with an obvious stack trace, boilerplate CRUD — the cheaper tiers produce indistinguishable output for a fraction of the cost, and on quick interactive questions the routing decision matters more than any prompt technique. My working heuristic: if the task fits comfortably in a small context window and has one right answer, the expensive model cannot show you what you are paying for. If the task requires holding a system in mind and exercising judgment across it, the cheap model cannot hide what you are not.
That heuristic is model-version-proof, which is why this post outlived its launch-window framing. Whatever Anthropic ships next at the top of the lineup, the routing question stays the same: concentrate the premium tokens where context breadth and judgment compound, delegate everything else down.
The prompts behind these workflows — the audit prompts, the planning-session structures, the ranking prompt from use case five — live in my prompt library, organized by use case, free to lift and adapt to your own stack.
