How One Developer Runs Claude Fable 5 All Day Without Blowing His Limits (4 Settings)

TL;DR: While most Claude users burn through their Fable 5 usage limits in a day, developer Theo (t3.gg) publicly documented running the model for 5.5 hours straight, shipping a month of backlogged work in 3 days, with the entire run costing about $150 across every model involved and neither of his subscriptions passing 40% usage. The difference is 4 settings: never run Fable above high reasoning effort, teach it to delegate implementation grunt work to cheaper models, give it a written ranking of your models so it routes tasks automatically, and push token-hungry jobs (huge documents, logs, app testing) off Fable entirely. All 4 work on a normal paid plan, and with free Fable 5 access extended through July 12, this week is the time to set them up.

The complaint everyone has, and the receipt that contradicts it

Spend five minutes in any Claude community right now and you’ll find the same complaint: Fable 5 is incredible, and the usage limit evaporates. The top comment on the access-extension announcement joked about people who “wasted their Fable limit on nonsense,” and the most-requested feature after the extension was a limit reset.

Then there’s the counterexample. Theo, the developer behind t3.gg, published a 43-minute walkthrough called “A proper guide to Fable 5” documenting the opposite experience: a 5.5-hour autonomous run that triaged 16 stale pull requests, planned the replacements, implemented them, and merged a month’s worth of roadmap in about 3 days. He estimated the equivalent work would have cost thousands of dollars run naively. His actual cost was around $150 spread across all the models involved, and he pushed his Claude subscription to only 40% of its weekly limit doing it.

The gap between those two experiences is not plan size. It’s 4 changes to how the model spends tokens. Here they are, translated for people who don’t live in a code editor, because every one of them applies to research, content systems, and automations just as much as to software.

Setting 1: High effort, never max

The reasoning effort selector is the single biggest lever on your usage, and most people have it backwards. Higher effort settings look like they should handle bigger jobs. They don’t. Effort controls how hard the model thinks per step, not how long it can work or how many steps it can take. A 500-step project runs the same number of steps on max as on high; max just overthinks each one.

Past high, in Theo’s words, the model produces “worse code that is way overdone, with way too many changes for the simple thing you’re asking for, at a cost that is absurdly higher than it should have been.” And the pattern held across everyone he talked to: “every single person complaining about blasting through their usage too fast” was running xhigh, max, or ultracode. Even Anthropic’s own heavy multi-agent mode runs high under the hood.

The fix is one command:

/effort high

Set it and forget it. This change alone, he estimates, cuts most people’s burn by half or more.

Setting 2: Cheap models do the grunt work

Fable 5 can run other AI models from the command line the same way it runs any other tool. That unlocks the core move of the whole system: Fable does the thinking, cheaper models do the typing.

Implementation-heavy work with a clear spec, bulk edits, migrations, data analysis, first drafts of mechanical code: a cheaper model handles those fine, especially with Fable writing the brief and reviewing the result. Theo spent about an hour teaching his setup to delegate this way, and it’s most of how a 5.5-hour run stayed at $150.

The operator version is one standing instruction in your Claude configuration: for mechanical, clearly-specified tasks, delegate to a cheaper model and review the output; escalate back to the smarter model when the output misses the bar. His framing of the principle is worth stealing verbatim: judge the output, not the price tag.

Setting 3: The ranking file

Instead of deciding which model should do which job every single time, write the decision down once. Theo keeps a short block in his configuration that scores each model he can access on three axes: cost, intelligence, and taste. Crucially, he also defines what he means by those words (intelligence: how hard a problem the model can handle unsupervised; taste: quality of judgment on things like design, writing, and interfaces), so the model applies the rankings the way he would.

With the ranking written down, Fable routes work automatically: expensive-and-brilliant for planning and anything user-facing, cheap-and-tireless for the grunt work, and it escalates on its own when a cheap model’s output isn’t good enough. He deliberately didn’t publish his exact file so people would build their own, and that’s the right instinct: your scores depend on which subscriptions you have. The free guide linked below includes an editable starter version.

Setting 4: Outsource the token-hungry jobs

Some jobs devour tokens regardless of how smart the model is: reading a 200-page PDF, digging through logs, browsing your app and taking screenshots to verify something works. None of that needs Fable-level intelligence. It needs patience, and patience is cheap.

The fourth setting routes all of it away by default: token-hungry work goes to the cheapest capable model, which reports back a short summary. Fable reads summaries, not raw dumps. Your limit gets spent on decisions, not on scrolling.

What this looks like in practice

With all four settings on, the workflow inverts. Fable stops being a chat window you ration and becomes a manager you brief. Theo’s 5.5-hour run is the extreme version: one goal, dozens of delegated subtasks, work merging on its own while he was at a conference checking his phone. But the same structure scales down to a normal operator project: brief Fable properly once, let it route the grunt work, and check in on results.

And the setup outlives the free window. The routing logic doesn’t care which model sits at the top; when Fable 5 moves to usage-based pricing after July 12, the same ranking file keeps your everyday model delegating the same way.

FAQ

Do these settings require coding skills? No. Setting 1 is one command. Settings 2-4 are plain-English instructions you paste into your Claude configuration file. The original walkthrough is developer-oriented, but the mechanics are identical for research, writing, and automation projects.

Is Fable 5 still free right now? On paid Claude plans, yes, through July 12, 2026 after Anthropic extended the original July 7 cutoff. After that it moves to usage-based pricing, which makes the routing setup more valuable, not less.

Won’t cheaper models produce worse work? For thinking-heavy work, yes, which is why Fable keeps those jobs. The delegation only covers mechanical, clearly-specified tasks, and the standing instruction includes an escalation rule: if the cheap model’s output misses the bar, redo it with the smarter model.

Does the effort rule really matter that much? It’s the biggest single lever. Effort applies per step, not per project, so anything above high pays a premium on every one of hundreds of steps while often producing overbuilt results. High is Anthropic’s default for a reason.

Where can I watch the original walkthrough? Theo’s video “A proper guide to Fable 5” on YouTube (t3.gg). It’s 43 minutes and developer-focused; the guide below is the 20-minute operator version.

Get the setup guide

I turned all 4 settings into a free setup guide with the copy-paste ranking file and routing instructions, editable for whatever models you have. Comment STACK on the reel or grab it from the resource page, set it up once, and your last 5 free days of Fable 5 will out-produce most people’s whole window.