Source: raw/I_think_I_figured_it_out.md — Creator: Theo Browne (channel “Theo - t3.gg”; the transcript gives only “Theo”, the channel name is from the video page) · URL: https://www.youtube.com/watch?v=XtykeVoSmP8 · Duration: 42:20 · Platform: YouTube · Published: 2026-11-12. The video carries a Browserbase sponsor read, skipped here. His quotations of Anthropic’s guide were checked against ai-research/claude-dev-blog-which-claude-model-should-you-build-with-2026-11-11.md (Addy Osmani, claude.dev, 2026-11-09).

Theo Browne, who works on the T3 Code coding tool, spent two days with Fable 5.2 after far longer with Opus 5.5 and walks through Anthropic’s model-choice guide line by line. His conclusion is that the choice is less about capability or speed than about temperament: Opus checks everything and rarely misses, Fable is smarter but lets small things slide and proposes ideas Opus would not. This is one developer’s account with self-reported numbers; the transcript is auto-captioned and model names are normalized here (“Opus 55” is Opus 5.5, “Soul” is OpenAI’s Sol).

Key Takeaways

  • Default to Opus 5.5. “You can just use Opus until you want more from Opus.” Wanting more covers two cases: Opus is not doing a good enough job, or you do not like the options it is giving you.
  • Split by whether the work can be proved. “If it is possible to verify the work and you can hill climb your way there,” Opus “is more than good enough.” If nobody can “objectively say this is better than that” (graphics, a visualizer, an unusual infrastructure idea), “Fable is going to find things Opus never” would.
  • Opus for perfect, Fable to ship. Opus is the reviewer who leaves eight comments on a small PR. Fable is the senior engineer who says “LGTM.” He moved stalled threads to Fable, which audited the work, said it was fine and merged it.
  • Fable is weaker at code review in his evals. It “underperforms Sonnet and Opus because Fable is a little too willing to let code through that might have something slightly wrong with it.” After auditing the misses, he decided “the gap doesn’t matter.”
  • high is his everyday effort on Opus 5.5. Medium “is a little tiny bit too quick to end its turn”; max he calls “garbage.”
  • On a subscription, Opus goes much further. His measurement of the 14,000 of API-priced usage if spent on Opus alone, against about $3,000 of Fable inside its 50% weekly cap.
  • Speed is not a reason to pick either. He sees about 106 tokens per second from Fable 5.2 and about 112 from Opus 5.5.
  • One prompt line that improved Opus for him: “If you think this is a good idea, do it. Otherwise, suggest something else.”

What he takes and rejects from Anthropic’s guide

Addy Osmani’s post “Which Claude model should you build with?” is the first-party advice he reads from. Its rules are in Which Claude Model for Which Job.

Anthropic’s guideTheo’s position
Start most work on Opus 5.5 at mediumMostly agrees, but prefers high. If medium is always enough, “go bolder. You’re not asking for enough yet.”
Move down to Sonnet 5.5 for well-scoped everyday workDisagrees. “I don’t know when you’d use Sonnet right now.” Useful “as a scoped tool that your agents use,” not as the model you pick yourself. A clear spec does not make a migration or performance job easy.
Haiku 5.5 for classification, routing, extraction, and subagents on side tasksAgrees on bulk work, rejects side tasks: “I would never ever ever use Haiku for a side task.” His use: have Haiku go through every file to find a pattern that cannot be detected programmatically. “Don’t use Haiku to write code please.”
Fable 5.2 for the hardest problems, when Opus at high falls short, or for long unattended runsNotes the guide says high, not xhigh or max.
Fable 5.2 for major refactors, migrations and leading many subagentsDisagrees that Fable is required. “Fable 5.2 does not unlock subagents where Opus couldn’t.” He says he rewrote a whole compiler in Rust with Opus as both orchestrator and implementer. “Fable is slightly better.”
Past high, test the next model up at lower effort insteadAgrees: “a good call out.” He also praises the guide for publishing a comparison in which a cheaper setup matches a dearer one: “a level of honesty we don’t normally see from labs.”
Mythos 5.2 listed separately”Mythos is not a different model. It’s a different way of accessing the same model with fewer safeguards.” This matches the wiki’s Fable 5.2 article.
  • One misreading. He says the guide shows Fable 5.2 at high “beat out” Opus 5.5 at max for half the cost per task. The guide says the two scored “about level” on FrontierCode 2.0 (45.3% against 45.5%) for roughly half the cost per task.
  • His caveat on that cost figure: “Half the cost per task is based on API pricing. The subscriptions are different.” On a $200 plan, “Opus 5.5 max will do more than Fable 5.2 high in real world codebases … because you get twice as much Opus,” and by his measurement more than twice.

Effort levels, as he uses them

All of this is for Opus 5.5 unless noted.

LevelHis verdict
low”Garbage.”
mediumVery good, but “a little tiny bit too quick to end its turn and isn’t quite as willing to check the things that I would like it to check.”
highHis default. “I have rarely found tasks high couldn’t complete and it also doesn’t do too much and it is not that much less token efficient.”
xhighFor checking and auditing, and for problems with “really complex hairy things” where he wants a lot of testing. His examples: Windows development; a large pile of logs with a few hidden errors, where he wants the model to build a way to replay and test them; exploratory PRs he does not intend to merge; “turn every stone” tasks.
max”Don’t use it.” It “doesn’t just change how much the model’s allowed to think, it changes how little the model’s allowed to think. It forces the model to think a lot, even if the task is simple.”
ultracode”Sometimes useful for very specific things when you’re trying to burn a lot of tokens on just crazy absurd goals.” He notes it is now a toggle, not an effort level. See [[claude-ai/dynamic-workflows-claude-code
  • Fable 5.2 at max. He calls it “the first model that very consistently scores worse on max than xhigh in most benchmarks.” Anthropic’s own launch chart reports Fable 5.2’s top FrontierCode score at xhigh; “most benchmarks” is his claim.
  • For stone-turning he prefers Opus 5.5 at xhigh over Fable: “Fable is not quite as much a stone turner as Opus is.”
  • Sonnet 5.5 at high effort is poor value. On Artificial Analysis’s index, he says Sonnet 5.5 at max produced the most output tokens of any current model and ended up “basically the same price as Opus.”
  • He wants effort to go away. On his own benchmark (captioned “Skatebench”) the gap between low and maximum effort on recent OpenAI models was “around like 20% or so of the tokens,” which he reads as models learning not to over-reason.
  • Background on the levels: Which Effort Level to Use.

Subscription maths

Self-reported figures from his own usage tracking; none is an Anthropic number.

  • Fable’s cap. On Max, Fable can use up to half the weekly limit; the other half can go to any model, or the whole limit can go to Opus. Anthropic’s help page confirms the 50% rule.
  • **14,000 a month of API-priced usage on Opus alone. The Fable half yields about 7,000 of Opus remains. “It’s less than a fourth as much Fable.”
  • $100 plan: “like 3 to five grand of usage.”
  • His conclusion for tight budgets: “your literal only economically viable option is the most expensive Claude tier you can afford,” because 300 spent on any other model.
  • Priced by subscription, the leaderboard changes. He shows Artificial Analysis scores plotted against subscription cost and says Opus gives the most for the money, that DeepSeek V4.1 Flash is the only open-weight model on the frontier line, and that MiniMax M3.1 “costs more than Opus 5.5 on max.” He adds that OpenAI “just doubled the amount of usage in their subs.” The chart is his own cut, not a published one.

Speed

ModelTokens per second
Haiku 5.5about 255
Sonnet 5.5about 145
Opus 5.5about 112 in his data; he cites Artificial Analysis at 102 to 115
Fable 5.2about 106, “within margin for error of Opus 5.5”
Fable 5.188
Gemini 4 Carbon60 to 70, after about 10 seconds before the first response
  • “There is no speed difference from Fable to Opus.”
  • Anthropic’s guide says Fable 5.2 generates output up to 30% faster than Fable 5.1. His 88 to 106 is about 20%.

Two temperaments

Opus 5.5, “the teacher’s pet.”

  • “It is incredibly rare that Opus misses something.” It “double and triple checks everything,” and he contrasts that with Gemini models rereading the same file many times.
  • It does not challenge the task. “It is pretty hard to get Opus to say no to things.” Left alone it will “quickly bloat out a spec, allow for feature creep to take over.”
  • It applies any feedback it is given, good or bad, so a review loop can turn “a 30 line of code PR” into “a thousand plus.” He says he has adjusted his “Sol loop” skill (as captioned), in which OpenAI’s Sol gives the feedback, for this reason.
  • “Opus is nervous to be wrong.”

Fable 5.2, the student at the back who “somehow gets a perfect score.”

  • “Fable is kind of lazy. It’s kind of willing to cheat.” He wants that sometimes, because lazy engineers “find genius solutions.”
  • It challenges the premise, says when an idea is “stupid,” and will ignore earlier work it judges to be garbage.
  • It gives “a better variety of options” than Opus, some better and some worse.
  • It “misses things that matter sometimes.” His example is the demo video in Anthropic’s guide, which he assumes Fable edited: text sits at the very bottom of the frame, where the player’s control bar hides it.
  • It knows when to stop. “I’ve only ever seen Fable not do this.”

Both, against OpenAI’s models. He says both Claude models stay on task and can still explain themselves in plain English after tens of millions of tokens and repeated compaction, and that OpenAI’s models “slowly lose track of reality” on long runs. His opinion, no test shown.

The reviewer analogy. Allen has six-plus years in one codebase and knows every rough edge; Brad has twenty years’ experience and three months on the team. “I would hit up Allen when I need it to be perfect,” and “Brad when I want to ship.” Allen is Opus; Brad is Fable.

A worked example: long threads in T3 Code

  • The job: make very long agent threads (one prompt that runs for days) load fast on a phone by sending the history in chunks.
  • Opus 5.5 built the test environment: it gathered data from his machines, reproduced the slow cases and “made a beautiful repro.” It did not notice that an unresolved to-do list created at the start of a thread forced the whole history to be sent. Told about it, Opus proposed shrinking the whole history.
  • Fable’s turn. He asked Fable to verify Opus’s environment, “play with it and find the edges that actually cause problems and propose solutions.” It found the to-do list problem at once and proposed sending the goal list separately from the history. That cut data over the wire “by like 150x for some of my edge cases.”
  • The reverse did not work. He had Fable and Opus build the test environment in parallel. Fable’s “was worse. It did not have all the edges.”
  • The pattern: Opus builds the thorough harness; Fable looks at it and finds the non-obvious fix.

Code review: Fable lets more through

  • He runs evals on how well models give feedback on real code. Fable “is slightly more likely than Opus or Sonnet to let something slip.” It does not usually pass “egregiously wrong” code.
  • One judge in that eval is GPT-6.1 Sol, which “hugely downranks Fable because it thinks it missed things that matter.”
  • He first counted this against Fable, then audited what it missed and what it flagged and decided the difference was unimportant. “So far, everything Fable said was good to merge ended up being good to merge.”
  • Other launch-week tests in the wiki point the other way on bug finding: one bug hunt had Fable confirm 63 bugs to Opus’s 54, and Peter Yang uses Fable to audit code Opus wrote (Fable 5.2 vs Opus 5.5 head-to-head tests). A bug hunt on a codebase and review comments on a diff are different tasks, and all of these are single creators’ tests.

Try It

  1. Stay on Opus 5.5 and raise effort to high if medium ends its turns before checking what you wanted checked.
  2. Add the pushback line to Opus prompts: “If you think this is a good idea, do it. Otherwise, suggest something else.” He reports “meaningfully better outputs,” and also that Opus sometimes suggests something worse, so read the suggestion.
  3. Sort the task before choosing the model. If a test suite, a reference implementation or a benchmark can prove the result, use Opus. If the result is a judgment call (design, a novel approach, which of several architectures), try Fable.
  4. Unstick an old thread with Fable. If Opus keeps finding more to do, ask Fable: “Can you audit the work that was done here and tell us what we should actually do next?” It may fix what Opus could not, or tell you the work is already good enough.
  5. Use the two in sequence on a hard bug: Opus builds the reproduction and test environment; Fable verifies it and proposes the fix.
  6. Do not let a reviewer model feed Opus unfiltered nitpicks. Limit what the review step may send back, or the change grows.
  7. Before paying for xhigh or max on Opus, try Fable at high, as Anthropic’s guide says, and remember that on a subscription Fable draws from a capped half of your weekly limit.

Open Questions

  • Two days of Fable 5.2. He says so himself: “my thoughts here may change.”
  • The usage-dollar figures (3,000, 5,000) are his measurements from an earlier video, not reproduced in this one and not confirmed by Anthropic.
  • Sonnet 5.5 cost per task. The captions give “49” for Sonnet at xhigh against “$65” for Opus, which he calls a 50% increase. The units and which model is dearer are unclear in the captions.
  • His evals are not published in the video. No task counts, scores or methodology for the code-review eval or the benchmarks where he says Opus beat Fable.
  • Which compiler. The captions say “Tyco compiler”; a later line mentions “rewriting TypeScript in Rust,” so it is probably the TypeScript compiler. Not confirmed.
  • Names from captions. “Julius,” who persuaded him to try high, and his benchmark “Skatebench” are spelled as captioned.
  • His training theory. He guesses Opus is distilled from Fable (“a pile of data probably from Fable”) and so “designed to regress to the mean.” This is speculation; Anthropic has not said it.
  • Fable 5.2 at max in “most benchmarks.” The wiki has first-party support only for FrontierCode.