33:48Theo - t3․gg · Essay
He's right.
Boris Cherny said coding is solved. Matt Pocock called it VC-funded bullshit. Theo argues they're both right, because they're using the word coding to mean two different things.
August 24thThe argument in one line.
Pick between Opus 5.5 and Fable 5.2 by temperament, not raw intelligence: Opus is the meticulous checker for provable work, Fable is the lazy genius for creative, unprovable, or stuck work.
Read if. Skip if.
READ IF YOU ARE…
- You pay for a Claude Max plan and keep second-guessing which model and effort level to select in Claude Code.
- You run long agent sessions that stall in review loops, and you want a rule for when to switch models instead of grinding.
- You're weighing cheaper open-weight or API-billed models against a flat-rate subscription and want the cost math done for you.
- You lead engineers and want a mental model for matching an AI reviewer's style to how risky a change is.
SKIP IF…
- You want controlled benchmark tables. Most of this is one heavy user's two-day impressions plus analogies.
- You're on a provider other than Anthropic by policy. The whole argument assumes you can use Claude subscriptions.
The full version, fast.
For coding right now, only Opus 5.5 and Fable 5.2 are worth picking, and a Claude subscription is the cheapest way to run either because a $100 to $200 plan buys thousands of dollars of API-priced usage. Opus is the default: run it on high effort, avoid max, and expect it to double-check everything and rarely miss details, though it will happily bloat a spec. Fable is no slower than Opus at roughly 106 tokens per second, but it is lazier and more creative. Use Opus for work that can be verified and hill-climbed. Switch to Fable when the problem is unprovable, when Opus offers samey options, or when a stuck PR needs a confident reviewer who will say it's fine and merge.
Free for members
Chat with this breakdown — free.
Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.
Create a free account →Where the time goes.
00:00 – 00:55
01 · Cold open
Twelve frontier models listed, ten deleted on the whiteboard.
00:55 – 01:36
02 · Two models, not twelve
The thesis: only Opus 5.5 and Fable 5.2 matter for real work, and the $200 subscription is the way to run them.
01:36 – 03:02
03 · Sponsor: BrowserBase
Browser infrastructure for agents plus the open-source StageHand SDK.
03:02 – 05:45
04 · The budget argument
Subscription subsidies make the most expensive Claude tier the only economical option; score versus subscription cost chart.
05:45 – 06:16
05 · Opus for most, Fable for hard
The simple split, and why it turns out to be more nuanced.
06:16 – 09:55
06 · Anthropic's guide and the effort tier list
Walking through Addy Osmani's model-picking article; high is the best effort level, max is the worst.
09:55 – 11:48
07 · Where Sonnet and Haiku fit
Sonnet is rarely worth picking; Haiku is for bulk analysis, not code.
11:48 – 14:52
08 · When to move up
Effort level versus bigger model, and why Opus on extra-high is the best stone-turner.
14:52 – 17:43
09 · Orchestration and subscription math
Opus can orchestrate huge migrations; Fable's 50% weekly cap gives far less usage than the API price gap suggests.
17:43 – 20:55
10 · The speed myth
Tokens-per-second reveal: Fable 5.2 runs as fast as Opus 5.5.
20:55 – 24:25
11 · Opus is the teacher's pet
Personifying Opus: never gives up, never cuts corners, bloats specs, rarely challenges the task.
24:25 – 26:12
12 · A teacher's pet confession
Personal college story about why the teacher's pet is never the smartest in the room.
26:12 – 28:00
13 · The kid in the back row
Fable as the student who barely tries and aces the test, and the read-everything-first test it would fail.
28:00 – 31:22
14 · Case study: four-day threads
Opus built the repro environment; Fable spotted the to-do list bug and cut payloads about 150x.
31:22 – 35:26
15 · Alan vs Brad
Two reviewer archetypes: the tenured perfectionist and the veteran who says LGTM.
35:26 – 37:10
16 · Provable vs unprovable
Verifiable work goes to Opus; judgment calls, creativity and exploration go to Fable.
37:10 – 38:59
17 · Use Opus until you want more
Reach for Fable when Opus's ideas feel samey, not only when it runs out of capability.
38:59 – 41:45
18 · When you just want to merge
Fable's willingness to let things slide unsticks PRs Opus keeps reopening; code-review eval results.
41:45 – 42:19
19 · Outro
Asks viewers whether analogy-driven comparisons work.
Lines worth screenshotting.
- A $100 Claude subscription delivers roughly $3,000 to $5,000 of API-priced usage, so it beats every pay-per-token option on cost.
- When you chart benchmark score against subscription cost instead of API cost, Opus dominates the frontier and open-weight models nearly vanish.
- Opus 5.5 on high effort is the sweet spot: medium ends its turn a little too early and max forces overthinking on simple tasks.
- Max effort doesn't just let a model think more, it forbids the model from thinking less, which produces worse work on easy tasks.
- Fable 5.2 is the first model that consistently scores worse on max effort than on extra-high in most benchmarks.
- If medium effort has never failed you, you're not asking the model for anything ambitious enough.
- Sonnet 5.5 can cost about as much per task as Opus because it burns far more output tokens when the path isn't clear.
- Use Haiku for bulk pattern-matching across thousands of files or log lines, never for writing code.
- Fable 5.2 runs around 106 tokens per second, within margin of error of Opus 5.5, so speed is no longer a reason to avoid it.
- On the $200 plan, the 50% weekly cap on Fable works out to about $3,000 of usage versus about $14,000 of pure Opus.
- Adding 'if you think this is a good idea do it, otherwise suggest something else' to Opus prompts noticeably improves its output.
- Opus checks everything because it knows it isn't the smartest in the room, which makes it better than Fable at catching small misses.
- One Fable insight, splitting an unresolved goal out of a giant thread history, cut data over the wire by about 150x.
- If correctness can be objectively verified, Opus is enough; if 'better' is a judgment call, Fable finds things Opus never will.
- Fable scores lower on code-review evals precisely because it lets minor issues slide, and so far everything it approved was safe to merge.
- When an Opus thread has been looping on a PR for days, hand it to Fable: it either fixes the real problem or tells you it's already fine.
Pick the model by temperament, not by IQ.
WHAT TO LEARN
Opus 5.5 is the meticulous checker you default to for verifiable work, and Fable 5.2 is the confident outsider you call for judgment calls, fresh ideas, and stuck merges.
04The budget argument
- A $100 to $200 Claude plan buys thousands of dollars of API-priced usage, so it is the cheapest way to run frontier models.
- Benchmark charts priced against subscription cost put Opus on top and push nearly every open-weight model off the frontier.
06Anthropic's guide and the effort tier list
- Run Opus 5.5 on high effort by default; medium ends turns a bit early and max makes it overthink simple tasks.
- Before switching to a bigger model, try one effort level up, and remember one level past high can cost as much as the bigger model.
07Where Sonnet and Haiku fit
- Sonnet 5.5 can match Opus on cost per task because it spends far more output tokens when the path is unclear.
- Point Haiku 5.5 at bulk pattern-matching across many files or logs, and keep it away from writing code.
08When to move up
- Use Opus on extra-high for audits, Windows work, and digging hidden errors out of large log sets where every stone needs turning.
09Orchestration and subscription math
- Opus is fully capable of orchestrating large migrations with sub-agents, so Fable is not required for big multi-agent jobs.
- On the $200 plan Fable is capped at half your weekly usage, which buys far less work than the API price gap suggests.
10The speed myth
- Fable 5.2 streams at about 106 tokens per second, essentially the same as Opus 5.5, so speed is no longer a tiebreaker.
11Opus is the teacher's pet
- Opus rarely misses details but will bloat specs and accept feature creep unless you explicitly invite it to push back.
- Ending prompts with 'if you think this is a good idea do it, otherwise suggest something else' gets noticeably better Opus output.
13The kid in the back row
- Fable trusts its intuition and cuts corners, which surfaces clever solutions but means it can skip instructions Opus would follow.
- When every detail must be known up front, Opus wins; when you need the shortcut nobody saw, Fable wins.
14Case study: four-day threads
- Let Opus build the thorough test environment, then ask Fable to verify it and find the edges that actually cause problems.
- Fable spotted that an unresolved to-do list forced the whole thread history to load, and splitting it out cut payloads about 150x.
15Alan vs Brad
- Call the meticulous, codebase-native reviewer when a change is high risk and must be perfect.
- Call the experienced generalist when you want to ship; they check for patterns that are hard to fix later and approve the rest.
- Opus behaves like the nitpicking reviewer and Fable like the one who says LGTM, so match the model to the risk of the change.
16Provable vs unprovable
- If success can be objectively verified and hill-climbed, such as a language port, Opus is more than enough.
- If 'better' is a judgment call, such as visuals, novel visualizers, or unusual infrastructure savings, Fable finds what Opus won't.
17Use Opus until you want more
- Switch to Fable when Opus's proposed options feel too similar to each other, not only when Opus runs out of capability.
- Fable gives a wider spread of ideas, some much better and some much worse, which is what you want when exploring.
18When you just want to merge
- Hand a PR that Opus keeps reopening to Fable: it either fixes the real blocker or confirms the work is already fine.
- Fable scores lower on strict code-review evals because it lets minor issues pass, yet everything it approved so far merged safely.
Terms worth knowing.
- Effort level
- A setting that controls how much reasoning a Claude model does before answering, from low through medium, high, extra-high and max. Higher levels cost more tokens and add latency.
- Pareto line
- On a cost-versus-score chart, the set of options where no other choice is both cheaper and better. Anything below the line is a worse deal than something on it.
- Open-weight model
- A model whose trained weights are published so anyone can run it on their own hardware or through third-party hosts, such as DeepSeek or MiniMax.
- TPS (tokens per second)
- How fast a model streams its output. Higher TPS means responses and agent turns finish sooner for the same amount of text.
- ZDR (zero data retention)
- An enterprise API arrangement where the provider stores no prompts or outputs. It requires paying per token rather than using a consumer subscription.
- Sub-agent
- A secondary model instance that a main coding agent spawns to handle a side task, such as searching files or implementing one piece of a larger change.
- Hill climbing
- Improving a solution in small steps, keeping each change only if a measurable check says it got better. It works when success can be objectively tested.
- LGTM
- Short for 'looks good to me', the approval a reviewer leaves on a pull request when they see nothing blocking a merge.
Things they pointed at.
03:58linkPriors: AA-II vs subscription cost per task chart
06:16linkAddy Osmani's Claude model selection article
12:36toolSkatebench
28:04productT3 Code
39:55toolEvalboard code-review evals
Lines you could clip.
03:09
“If you're on a tight budget, your literal only economically viable option is the most expensive Claude tier you can afford.”
08:40
“Overthinking isn't good, guys. If you spend three minutes trying to figure out if your outfit is good, you're better off than somebody who spent 30 minutes.”
09:36
“If Medium is enough for you, go bolder. You're not asking for enough yet.”
19:20
“Fable 5.2, I consistently see 106 TPS. The speeds I am seeing in my day-to-day are within margin for error of Opus 5.5.”
25:26
“The teacher's pet is never the smartest person in the classroom.”
26:12
“Do you know who the smartest person in the room is? The student in the back of the classroom who smokes too much weed and somehow gets a perfect score. That's Fable.”
27:40
“I like engineers who are lazy and cheat occasionally because they will find genius solutions.”
33:50
“Brad says LGTM.”
37:10
“You can just use Opus until you want more from Opus.”
41:25
“One of the most underrated aspects of Fable is that it's willing to say, fuck you, ship.”
Word for word.
Read-along
Don't just watch it. Burn it in.
See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.
metaphoranalogystory
It truly feels like we're in a renaissance of agents for code. The number of models we have available to us that are world -class engineers is truly hard to comprehend, especially considering where we were at this time last year, where there were only a few options that kind of worked. Now we're in a renaissance.
It's truly insane. We got Opus 5 .5, Fable 5 .2, Sonnet 5 .5, Haiku 5 .5, GBD6 Astra, Sol, Terra, Muse Wonder, Muse Wonder Full, which is different, Gemini 4 Carbon, and Kimi K31 Pro. How can we ever pick which model we should be using for our day -to -day work?
It's not easy to do. I'm going to do one thing to make it easier as we start here. All these different models have different prices, different capabilities, different things you can do with them, different things you can't do with them, and more.
Picking is hard. So let me make it slightly easier quick. Let's just delete those and also that.
Okay, there we go. Now we have a thing to actually talk about. This video is not about picking the right model.
This video is about picking one of the right two models. Because I'm gonna be real with y 'all, everything else is cope. This is not fun for me, more than anyone.
It is insane that we are at this point, but without very good and very specific reasons, using anything other than these two is insane. I could spend time justifying this, but the comments will be a disaster anyways. So I'm just gonna go straight into the reasons why you should use Opus 5 -5 or Fable 5 -2.
the benefits and weaknesses of both, and a little bit about how you can take as much advantage as possible of those $200 subs that I would hope most of us have now. It's a shame I don't get paid a commission on all the $200 subs people get as a result of my videos, because I've been told by many people they have a lot of them as a result.
As I'm sure y 'all know by now, Anthropic doesn't pay me. In fact, I pay them quite a lot, and someone's got to cover the bill, so the only people paying me today are the sponsor. You might have noticed that tools like Grokbot, ChatGPT Dots, and Muse Assistant have been blowing up recently.
It's kind of confusing if you're a big Cloud Code fan, because what are they doing that different? Well, it turns out once you give your agents the ability to do things for you, they become way more powerful. When you lock your agents into just editing files on your computer, you're kind of limited.
When you give them access to the entire internet, suddenly they can do almost anything. But how are you going to give them that access? I can't imagine any better way than today's sponsor, BrowserBase.
These guys have everything your agents need to take advantage of the entire internet, whether they need to search to find some information, do actions on your behalf, or just parse data from URLs they don't normally have access to. That's what BrowserBase is here to get. There's a reason why companies like Ramp, DeepMind, and even Microsoft have been leaning on BrowserBase to help them get their browser usage right.
BrowserBase provides all the infrastructure and APIs you need, but they also have some really cool open source work like StageHand and SDK to make it easier for LLMs to use browsers. Even if you're not using BrowserBase, you probably should use StageHand. because it makes your agents way faster and more reliable.
It's just a great SDK. Your agents are only limited by what they can access. Unlock those limits today at soydiv .link slash browserbase.
There's a particular person who is currently typing on their keyboard a comment that I'm going to respond to now before they hit enter. But Theo, not everyone has an unlimited budget. We need cheaper tokens because that's too expensive.
I got some bad news, bud. If you're on a tight budget, Your literal only economically viable option is the most expensive clod tier you can afford.
Everything else is too expensive when you factor in the fact that the subsidization you get on the subscriptions is insane. You will get more tokens and more work done for $100 in a clod sub than you would get for $300 on literally any other model in the world because that $100 sub is going to get you like three to five grand of usage.
I already see people in chat. Not necessarily true. Kind of true.
No, this is a fact. This is a fact. There is no other subscription that will get you more tokens.
And if you can't afford a $200 plan, you don't need ZDR anyways. You're fucking coping and I'm not going to entertain you anymore. When you start pricing artificial analysis on subscription cost instead of raw API cost per task, the chart looks really different.
OpenAI just doubled the amount of usage in their subs, which helped them a little bit here on the edges with Sol and Terra. But as you see on the right here, all of the top scores, cost and performance calculated against the sub, you get way more with Opus than you do with almost anything else. And the only openweight model on the Pareto line at all is DeepSeek V41 Flash, all the way stuffed in the corner over there.
Good for it. i would say this shows how bad terra is rather than how good deep seek is but you get the idea you're not getting much done on any of those open weight options and even if we look around here to see something like uh i don't know that's muse ember where's uh yeah minimax minimax m31 great model it costs more than opus 55 on max that's insane I will also say your sanity is worth some amount of money.
And personally, I'll take the hit on score from 6 -1 Sol on Max to Opus 5 -5 on Medium, which I don't think is a real score gap. I think Opus 5 -5 Medium will smoke any Sol on anything that is real -world code. But when you also consider the fact that Opus 5 -5 doesn't suck to work with or talk to, obvious win.
Just go with the Claude sub. You're going to get way more for your money right now. This could change in the future.
But anybody who is saying that they can't use Opus or Sonnet because it's too expensive, So they're going to go use a bunch of open weight models because they can't afford the $200 sub. Has not ran any of the numbers.
They are just wrong objectively. Now that that is settled, let's talk about the two models that actually matter for real world work right now, which is these two. We can do this split a really, really simple way, which is use Opus 5 .5 for most things.
I mean, obviously it's super cheap and super good. And then Fable for hard things. Cool.
Yay. Video's done, right? We can pack it up and go home.
Now there's a lot more nuance to this than I expected. I have actually seen, in various of my own benchmarks, Opus outperforming Fable. On top of that, I have noticed Fable missing things that I really did not think it would, that Opus, in many of those cases, didn't.
Deciding between these models is more nuanced than I would have expected, and I've been doing a lot with both as I try to figure this out. Before I expose my mental illness to y 'all very directly in this video, I am first going to go through how Anthropic recommends thinking about these things. Addy Asmani wrote an article on day one with Fable dropping, and there are good pieces in here that I think are worth learning from.
The current Cloud lineup has four generally available models. Haiku 5 .5, Sonnet 5 .5, Opus 5 .5, and Fable 5 .2. Mythos 5 .2 is our most capable model for cybersecurity and life science research available through the verification program.
I wish you didn't wear it this way. Mythos is not a different model. It's a different way of accessing the same model with fewer safeguards.
They're the same model. If you're building on the Cloud platform where you're working in Cloud code, you may be wondering which model to use for your common tasks. I get it.
I'm there as well. Specifically because Fable isn't 5 .5, it's 5 .2. That almost feels like an indication that you should think about it a bit deeper.
He starts with a very interesting video demo without too much context. This is a photo that four models were given and they were told to write a Python program to recreate this image. And they all did it quite differently.
I find this one very interesting. Also that they chose to do a more... creative example early, but also I know that this video was edited by Fable because it put text at the very bottom where the bar for the player is that isn't visible.
And these are the exact types of little things I find Fable often misses that are worth working around in some way in some cases. Remember this example. I'll have a lot more of these as we go.
He opens with a TLDR. The quick answer is that you should start most work on Opus 5 .5 at its default effort level, which is medium. I don't...
fully disagree here that said i have found that medium with opus is 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 i personally used to be an opus 55 x guy ride or die then julius convinced me to start trying out high so i did and he was right opus 55 high is goaded medium and x high are both very good as well low is garbage ultra code is sometimes useful for very specific things when you're trying to burn a lot of tokens on just crazy absurd goals and ultra code is also no longer an effort level it's now a toggle like it should have been thank you anthropic for making that a mode how it always should have been and then max is just garbage don't use it in fact fable 5 -2 is unique in this case because fable 5 -2 is the first model that very consistently scores worse on max than x high in most benchmarks i also feel confused why is x high worse overthinking isn't good guys if you spend three minutes trying to figure out if your outfit is good or not you're better off than somebody who spent 30 minutes figuring out if that outfit's good or not the person who spent 30 minutes is going to overthink every detail they're going to start hating things that aren't a big deal they're going to care too much and they're going to do too much as a result high is a much more reasonable balance here also max i've talked about this before max doesn't just change how much the model is allowed to think it changes how little the model is allowed to think it
forces the model to think a lot, even if the task is simple, which results in it doing a lot of stupid shit. So personally, I think medium and X high are both incredible. High is the goat.
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. I have been very happy with high.
Play with them though. And I agree with the advice here. Start with medium.
If it isn't enough, bump up to high or X high if you notice it missing things. A chatter just said that he's not yet found something that Medium can't do. You gotta start asking it to do bolder things then.
That's the other take is if Medium is enough for you, go bolder. You're not asking for enough yet. Addy's really trying to paint a path for you starting with Opus 5 .5 Medium to where to go depending on what happens from there.
He recommends that you can try moving down to Sonnet 5 .5 for well -scoped everyday work like bug fixes or features built against specs. Just because you have a clear spec doesn't mean you should use Sonnet though. Migrations or performance optimizations can have clear specs but still be difficult enough to warrant Opus or even Feeble 5 .2 for major ones.
Personally, I don't know when you'd use Sonnet right now. It ended up being more expensive than Opus for fish slop and made a worse version. Sonnet has actually turned out to be one of the most expensive models when it...
doesn't have a clear path which happens a lot because it's not that smart if i turn it on here it actually ended up doing the most output tokens of any modern model in artificial analysis intelligence index when you have max on because it just goes it ended up costing 10 per task we switch over to cost you'll see that actually ended up making it basically the same price as opus yeah it's not as bad when you knock down reasoning effort but still like x high sonnet 5 5 was $4 .09.
X -High Opus was $6 .05. So it's like a 50 % cost increase. But you're using a sub anyways.
Doesn't matter that much. Sonnet is not a great value right now. It's better than I expected.
Like I think that these numbers make it seem a little worse than it is. And it can be useful as a scoped tool that your agents use. I just don't think you should pick it in the model picker.
Similarly, Addy recommends moving down to Haiku 5 .5 for simple high volume work like classification, routing, and extraction. He says it's also good for usage with sub -agents to work on a larger model side tasks. I hate this framing.
I would never, ever, ever use Haiku for a side task. I would use it for bulk analysis. To go through a ton of data and have Haiku pattern match it.
Or having a pattern you notice in your code base that sucks that you can't programmatically identify. So having Haiku go through every single file and identify that. Those things are great.
Use Haiku for that. Don't use Haiku to write code, please. And here's where we get to what we're all here for.
Fable. move up to fable 5 -2 for the hardest technical problems in coding finance and the sciences also move up when opus 5 -5 at high still falls short or for long unattended runs notice that he said opus 5 -5 high not x high or max it does not seem like he is as fond of those reasoning levels because they have not even been mentioned yet although he does have a good call out here Past high, one more effort level can cost as much as a bigger model.
So compare both on your own work. If you're past high, test the next model up at a lower effort level instead. Conversely, one level down can get you the results you need at a lower rate.
Yeah. Do you know how excited I am for a future where you don't have to pick reasoning levels and the models are trained well enough to know which one makes sense and to reason more or less depending on the task? We are starting to get there.
With something like Skatebench, I noticed with recent OpenAI models that the difference between low effort and max effort was around like 20 % or so of the tokens. And it helped the score a bit, but not a lot. Clearly, the models are getting good at not over -reasoning even with effort really high.
And if we can keep going down that path, this whole dimension we currently care about will finally, hopefully, fingers crossed, go the fuck away. I'm so tired of effort levels. I don't want to think about this anymore.
that said we do need to care right now so we should understand how to pick between effort levels higher effort levels help when the model needs to think longer call more tools or check its own work more i will say that generally i use it for checking work and for auditing work i only bumped x high now if like the problem involves really complex hairy things i want a lot of testing in like windows seriously windows dev is one of the main things i reach for opus x high on right now because it needs a lot of extra checks to be sure it also can be useful when analyzing like big corpuses of data where you really want to get the details like if you have a shitload of logs that have a few hidden errors in them and you want to not just go through the logs but create a way to replay them and test them against your implementation x high will go further with that type of thing the prs that i don't want to merge but i want to build for exploration the tasks where i want to like turn every stone type stuff
i think opus 55x high is really good for that even more so than fable fable is not quite as much a stone turner as opus says opus doesn't i guess that's where we're going to start getting into my philosophy a bit i'll go much deeper in this later i promise opus is not as smart and that is often a good thing because opus knows it's not as smart so it double and triple checks everything not in a way that makes it super slow this isn't gemini models rereading the same file 16 times which they still do this is opus wanting to be as certain as possible that something is the case so it goes and quadruple checks everything just to be sure there's a lot of work that opus is better than fable 4 for that reason it will find the things that fable would have glossed over addy has a bunch of example tasks here and how he thinks of what model to use everyday engineering debugging multi -pr feature work opus 5 .5 medium default then high this is a good balance of cost and capability for everyday tasks classification routings things like that haiku because it's really low cost and latency sub -agents that search files read logs or summarize haiku or sonnet because wrong answers are cheap to spot and the main model has a judgment call anyways chat interactive sessions recommend sonnet or even haiku for simple with high volume well scoped bug fixes and coding
like feature iteration and spec driven type work sonnet on medium or high yeah i like that he says half the opus 55 token price here he also talks a little bit about latency and i'm gonna put that in my notes to like talk more about because i was actually surprised a bit when i dug into that in terms of how the latency differs across these options where did he say fable major refactors and migrations architecture planning and leading many sub -agents fable deep research and scientific or qualitative analysis fable as well i will say i rewrote the entire types of compiler from scratch in rust using opus as the commander and the implementer and it went great no reason to not use it so yeah fable 5 2 does not unlock sub -agents where opus couldn't opus 5 5 can absolutely do huge migrations with lots of sub -agents with no real problems i've done it many times now it's unbelievable fable is slightly better i have a couple things i'm testing right now to be sure of that but you can absolutely get away orchestrating with opus
I actually like how honest this article is compared to a lot of the other things the labs put out. For example, here it points out that Fable 5 .2 at high beat out Opus 5 .5 at max for half the cost per task. There's a level of honesty we don't normally see from labs and things, so nice stuff.
Also very real. There is one other catch here, though. Half the cost per task is based on API pricing.
The subscriptions are different here, and there's a couple things to remember. You get twice as much Opus as you do Fable, in terms of the actual limits because you can only use half your weekly for fable the other half can be used for anything else or you could use the whole thing for just opus they don't care but you can only do up to half your weekly with fable which means the 50 gap in cost here is already covered opus 5 5 max will do more than fable 5 too high in real world code bases with the 200 plan because you get twice as much opus but it turns out it's not twice as much i showed this in my fable 5 5 video i feel obligated to show it again The 50 % limit on your Fable gives you around three grand or so a month in the $200 plan.
You get 14 grand of pure Opus. So it's less than a fourth as much Fable in your $200 plan. To be clear, you still have the other 50%.
You could still go do seven grand of Opus after clearing the three grand of Fable here. But you should consider this when you look at the dollar difference because it isn't quite that simple. The next section he has is about latency versus accuracy.
A faster setup finishes sooner and can miss more. Think through how long a person can wait before you pick your model and effort level. For replies, a person waits on start Sonnet 5 .5 at low or medium.
Often next generation models are faster than their predecessors. Fable 5 .2 generates outputs up to 30 % faster than 5 .1. Sonnet 5 .5 runs 30 % faster than Sonnet 5 does.
This is where we're going to start touching on the latency. Obviously, Fable, biggest, slowest. Opus, smaller, slightly faster.
Fable, even smaller, even faster. Haiku, blazingly fast, right? no one disagrees with that right like fables the biggest and the slowest like who's the smallest and the fastest that all sounds correct right opus 5 5 from my data is around 112 tps artificial analysis measured at 102 to 115.
so it was 5 5 is very fast for comparison sonnet hits around 145 tps that is meaningfully faster but also it these were tokens for a lot of things still though if it can be done in the same number of tokens a 50 increase is great and of course haiku 5 5 is insane at 255 tps So Opus is 100 to 110. Sonnet is 140 to 150.
Haiku, 250. Pretty big gaps, right? So you probably expect a similar gap the other way too.
How fast would you expect Fable to be? I want y 'all, if you know the answer, don't say it. But if you have a guess in chat, how many tokens per second are you expecting from Fable seeing 100 to 110 for Opus, 140 or 150 for Sonnet, and then 250 for Haiku?
80 to 120 is a wild range. They're seeing 80, 50 to 70, 60, 50. My honest guess was in the 50 to 60 range.
I'm going to give you all a quick hint. Fable 5 .1, 88 TPS. This reveal broke me a little.
Fable 5 .2, I consistently see 106 TPS. The speeds I am seeing in my day -to -day are within margin for error of Opus 5 .5. Yeah, there is no speed difference from Fable to Opus that's real.
There just isn't. Also a fun fact, Google, the lab that's known for fast models, even if you discount the fact that it takes 10 seconds for them to spin up and start responding, which is consistent, every other lab's under a second, they're over 10. Even discounting that, they're hitting 60 to 70 TPS with Gemini 4 Carbon right now.
Not only is Anthropic making the best models for code, they're also somehow doing the best inference right now. Anthropics are so far ahead of everybody right now, it's disgusting. The point I'm trying to make here is when you're choosing between Fable and Opus, there's a lot of things that are not as relevant as we might have thought in the past.
Things like speed, things like ultimate capability, things like understanding of sub -ages and orchestration and tools. Opus and Fable both do those things incredibly well right now. When Opus 5 .5 came out, it was so good that even though I missed talking to Fable, because I do like the way Fable thinks, it's a bit different.
It's hard to put into words. It kind of is . aspect of things made me miss Fable, but it didn't make me reach for it.
Because honestly, Opus 5 .5 was more capable than Fable 5 .1. There were things Fable 5 .1 couldn't do that Opus could. So when do we use the new Fable then?
When do we actually reach for Fable 5 .2? I hate to play into Anthropic's hand as hard as I'm about to, but we gotta personify the models a little bit here. Hear me out.
and i will also preface this with i've only been using fable 5 -2 for like two days i've used the hell out of it but i've only used it for two days and my thoughts here may change but this is roughly where i'm at i am much more intimately familiar with opus 5 -5 i don't think i've ever used a model ever even a tenth as much as i've used opus 5 -5 like i have i have pushed this model to its limits and back it's incredible the way i'm going to think of these models is as students in our classes opus 5 -5 is the teacher's pet it is too willing to do too much work it will always take the teacher's word.
It will not push back on what it's told to do much because it just wants to appease. It wants to get the thing done and it will go to the end of the universe and back to do it. But it's also the model that's going to remind the teacher, hey, I think you forgot to hand out the homework.
It is incredibly rare that Opus misses something, but it does have a negative effect from that. It goes too far sometimes. Since this model is so desperate to appease, it will, unless told otherwise, quickly bloat out a spec, allow for feature creep to take over.
It's a little bit too quick to let those types of things happen. This model does not stop unless it's told to. It doesn't know any better.
All it wants to do is please. It's kind of similar to how 5 .6 Sol felt at the time, the difference being that 5 .6 Sol's goal was to kill. It was out here trying to tear the problem to tiny, tiny pieces, and it doesn't care what it destroys in the process.
Opus is still a clod model. It's still very sensitive. It's still a little bit autistic.
It takes no's well. It takes goals well. It stays on task well.
It gets work done well. The biggest problem with OpenAI models in similar tiers, even like 5 .6 Sol back in the day, but now even with 6 .1 Sol, Astra, Tara, and all the other models, they will continue working on a problem for a while. but they slowly lose track of reality and when they don't talk to you on the other end enough and they talk to themselves too much the outputs quickly become entirely impossible to understand the coherence has layers is the simplest way i can put it where like part of coherence is does the model remember what it is doing and stay focused and continue grinding the goal the other side is once the model has put tens of millions of tokens in its context window and compacted over and over again, can it still speak to you in English about what it's doing?
Both of these models do that incredibly. Zero models from OpenAI can do this at all. So Opus 5 .5 is the teacher's pet.
It doesn't give up. It doesn't cut corners. It will smile along with you as it bloats your app to all hell.
It will say no if you prompt it to. It is pretty hard to get Opus. to say no to things you can put it it's not like sycophantic to be clear it's more that it's not going to challenge the task it was given i have gotten much better results from opus when i started adding to my prompts if you think this is a good idea do it otherwise suggest something else That one small change with how I use Opus has resulted in meaningfully better outputs, but it also misses things.
I've had a lot of times where I did that and it suggested something that was bad. It's like, no, that's fucking stupid. Do it the way I said.
And then by the time it's done, it's like, oh yeah, that was better. So yeah. Ready for my spiciest take?
It's about the teacher's pet thing. And this one comes from me personally. I'm sure y 'all aren't too, too surprised to learn that I was a little bit of a teacher's pet.
Let me know, chat. Is that surprising news to y 'all? It varies across everyone.
Aston, you went to college with me. You saw how much I was spending all my free time in the music department working with the professors. I became the first ever TA for Computer Music 1 because I was the only person that didn't hate that professor because he went so fucking hard.
But I loved it. Computer Music 1 should not have been the hardest class at RPI, but it kind of was. And that teacher fucking loved me.
The only reason I didn't fail bio is because the professor there loved me too. And she should not have. I was a fucking degen then.
But yeah, I am a hardcore teacher's pet. If they're willing to put in the effort and they're dedicating their lives to educating and helping people grow, I just love that. I'm a nerd about learning and growth and I become very close to teachers as a result of that.
But it's like 50 -50. Like half my teachers fucking hated my guts. The other half fucking loved me and I was the one they would call for shit all the time.
I only did one internship because I spent all of my summers on campus working on random things with the professors because they liked me because I was such a fucking teacher's pet. I really was. Even when I didn't go to class, I was.
So I say this lovingly. The teacher's pet is never the smartest person in the classroom. Part of why they are a teacher's pet is because they want to be the smartest in the room.
They know they aren't. And they are trying to make up for it by getting closer with the people who can make them smarter. That's why I'm here.
I started making videos about the shit because I loved the things I was learning about and I wanted to share the things I love with other people. I wanted to learn more in the process and get closer to the people who invented the things I was excited about and help their ideas be shared because it was so cool to me. The teacher's pet is not that smart is the point I'm trying to make.
They're not stupid. They're not stupid at all, but they are not the smart one in the room. Do you know who the smartest person in the room is?
The student in the back of the classroom who smokes too much weed and somehow gets a perfect score. That's Fable. There are certain tasks that Fable will absolutely slaughter that Opus will get too caught up in the details of.
I remember the classic, like, do you do the work right test that I got in, I think it was like fourth or fifth grade. The test was roughly structured. Like, this is a test and a subtitle of like, make sure to read the whole thing before you start.
But you keep going and it's like question 17. Congrats. you read the whole thing ahead like i said don't fill out anything turn this test in blank classic test to see if your students actually do what they're told not sure how many of y 'all had this elementary school experience but i did this particular test opus will pass and fable will fail that's the point i'm trying to make here and you kind of gotta figure out which tasks you have fit this versus don't because if the model should know all of the things about the task before it starts opus is going to do incredibly opus is going to dot every i and cross every t and put so much work in to make sure it is aware of everything that matters fable is going to do a really smart thing without overthinking it fable is kind of lazy it's kind of willing to cheat and honestly i want my models to be lazy and cheat occasionally i like engineers who are lazy and cheat occasionally because they will find genius solutions to get out of so how do we apply this in real world work one example of some work i was doing recently was on performance for super long running threads in t3 code like you send one prompt and then it runs for four days chunking up the turns so that they could load fast on your phone that is a thing i've been fighting constantly
And it requires a very deep end -to -end understanding of where the problems could live. And when I work on this problem, I want the model to go through all of my different machines, all my environments for T3 code, collect all the data it needs and analyze it and replicate it, create environments to test it with and figure out why this happens and all of the edges that it can fix in the process.
When I did this task, I was working on it largely with Opus 5 .5 because Fable wasn't out yet. I didn't have it yet. Opus.
put together everything needed to have a really nice environment for testing all of these edge cases and figuring out how to smooth things out. It made a beautiful repro. It got things significantly better.
It was making real progress. But I noticed it was a little hesitant to do things that it absolutely should have been willing to. For example, in T3 code, we have the like task list that some models still use.
Most don't, but like OpenAI ones do and Anthropic ones don't really. Those to -do lists. get started really early in the history but if they're not resolved they still need to be shown so despite opus doing all of this work to put together this environment to test this it didn't really recognize the problem where if you had one of these long -running goal like to -do list things and that start at the start of the history and it wasn't resolved yet it would always include the whole history from that point because of how we were collecting the projection we would use to show you the state of the threat opus didn't even notice this was happening.
And when I told Opus it was happening, it was like, huh, well, we do need to show that. So I guess we need to find a way to make the whole history smaller so we can still go back that far. Because if we don't do that, we're sending a truncated history with multiple chunks and that could break things.
That would be bad. So I did what any sane developer would do. And by sane, I mean somebody suffering severe AI psychosis with a lot of clod subs.
I moved over to Fable and said, verify the work Opus did here to create this environment to figure out and test all of these bad cases. Then I want you to play with it and find the edges that actually cause problems and propose solutions.
And it immediately latched onto this exact problem. It was like, anytime a list is started at the top, it gets fucked up and persists the whole thread. I'm just going to expose that separately on top.
The goal should just be its own separate thing that we pass over the JSON that is not part of this gigantic hellish history. And that one change was able to cut the amount of data being sent over the wire by like 150x for some of my edge cases. Fable would have been miserable to build that all with, though.
I know because I actually tried initially. I started this task with Fable and Opus, both creating the fake environment for testing in parallel. Fable's was worse.
It did not have all the edges, but it managed to fix the problem. One of the problems I've had with a lot of models, and honestly, I've only ever seen Fable not do this, is not knowing when to stop. Again, as I said with Opus, if you give it feedback it will apply the feedback it doesn't matter how good or bad the feedback is if there's anything in there that it thinks it can do something with it will and this is why i have adjusted the soul loop skill as much as i have because it can get dangerous if you let soul just give feedback on every little thing always will keep fixing it and what should have been a 30 line of code pr will become a thousand plus so you need a way to steer from that to prevent that from occurring This analogy is going to work a lot better for the people who had jobs pre -AI in the software dev world.
Imagine you're working on an important PR at your job. You have PR number 12895, fix data retention policy in certain regions when X, Y, and Z. You have this PR, you have a bunch of changes in it, and you need this PR reviewed so you can merge it.
Because back in my day, a human had to approve changes before another human could hit merge and you have a couple people on your team that you can reach for you have alan who is a tenured engineer this is his first job but he's been there for 10 years or we'll say six plus years good eng not great knows this code base way way way too well then you have brad 20 plus years of experience fourth job here for three months incredible eng doesn't know the code base much yet or another case i've had here somebody like brad might be working in one code base at the company and is not as familiar with the other a particular skill you will build over the years is knowing when to call on one of these two people ready for the spiciest take here and hopefully like this is where it clicked for me when to use fable i would call one of these people in with very different goals and this might sound contradictory but hear me out I would hit up Alan when I need it to be perfect.
When the changes are really high risk and I want to make sure nothing can go wrong in them. Alan is the person I call because he knows all of the rough edges. He knows the places where the code base gets shitty.
He knows where things have broken in the past and he will double, triple, quadruple check and he'll leave eight plus comments on your PR even though it's small. And I hit up Brad when I want to fucking ship. Even though Brad is more experienced, even though Brad could hypothetically find more holes in the PR than Alan can.
He has a different level of intuition. His intuition isn't around the code base. His intuition is around engineering.
And when he looks at the thing, he'll give it a brief glance, look for the patterns and the risks he is concerned about, not because they go wrong in this code base, but because they are hard to fix in the future. Alan's communist PR is going to look something like, this is really good work. There's a few things I have some concerns about.
For example, here you do this. This caused a problem three years ago. We try to do this instead.
Here, you're not following the shape of the function definitions we'd like to use. The type definitions you use here aren't the format I prefer. I'd prefer if we do it this way everywhere, yada, yada, yada.
Brad says LGTM. The point I'm trying to make here is that one of these models will not let things slide. even if they're not that important it will die on the hill of nitpicks and that is not that important edge cases that just really don't matter in the real world fable's like yeah it's probably fine and this has been one of the biggest surprises to me but it makes sense once you understand the way these models differ opus is nervous to be wrong imagine the teacher just called on both of these students for an answer opus is going to check extra hard to be sure the answer is right before it has the balls to say anything because it's so scared of getting it wrong.
Fable's like, fuck it, it's probably B. These two people are incredible to have on your team. I love having both.
As an engineer who has worked a lot of traditional jobs in the past, learning who each of these types of people were at your job was so valuable. Like I have specific people in mind when I write these and both of them are some of the best engineers I've ever worked with. Sometimes you need the meticulous focus.
care and paranoia of Alan is sometimes you want the guy who's ready to retire and is kind of here for fun and spends most of his free time smoking weed and hanging with his kids. And that's Brad. Once you think of these models this way, I bet you'll be surprised how much easier it is to pick which one for a task.
Opus is so by the book that it's going to be less creative. It's going to miss fewer things, but it's not going to come up with clever bullshit. Fable is going to say things that are stupid sometimes.
It's going to miss things that matter sometimes. but it's also going to come up with shit no one else would think of and it's not going to try that hard when it does it because it doesn't care the thing i hit at the bottom here i think will help a bit i chose to put this at the end because i really want these mentalities to stick in first if you want a simpler way to choose you can split this to be provable versus unprovable if it is possible to verify the work and you can hill climb your way there Whether this is something like rewriting TypeScript in Rust, you can verify that it's correct relatively easily.
Opus is more than good enough for that. But if it is a thing that you cannot objectively say this is better than that, if it is a thing that requires a little more nuance or creativity or exploration or curiosity, Fable is going to find things Opus would never. Any decision that can be decided is correct by reading a bunch of literature, thinking really deeply about it, testing all of your theories, and then doing the thing.
Opus will find pretty much all of those. But when it comes to making the graphics better, or making a visualizer that is unique and doesn't suck as much, or coming up with some stupid way to fuck up your infrastructure that might actually save you a lot of money, that's what Fable's here for. Fable is so much fucking smarter than anything I've ever worked with.
And it's also fun. It's like, nah, fuck you, is the attitude I get from it. And I love that.
I love when Fable's like, that is stupid and I'm not going to do it. I love when Fable challenges the premise of the whole thing that I'm doing in the first place. I love when Fable's like, all the work that has been done here already is garbage.
I'm just going to ignore that and move on. But even Opus is willing to do some of those things. And now I'm going to give you the simplest possible way to think of this.
You can just use Opus until you want more from Opus. Not only is Opus... unbelievably capable it's also better in some places i've had a couple times now where i was reaching for fable and it didn't give me what i wanted and i just went and re -ran the exact same thing on opus and got the right result and it's not so much that like opus has a ceiling that it hits that fable blasts through it's that fable will try different things it is smarter like fable's obviously smarter but its willingness to go past the norm And I guess it comes down to the training where Opus isn't a gigantic pre -training that is being tuned to write code.
Opus is a pile of data, probably from Fable, that they are trying to get similar behavior out of in as small of a shape as possible. Opus was designed to regress to the mean. It's designed to find the similar pattern and then apply it.
Fable's just out here doing shit, man. Fable's... having fun, experimenting, trying things, pushing its own limits, pushing your limits to an extent too, certainly pushing your subs limits.
Those are going to go away fast. When I say this, it is not, I want more capability than Opus. It can be.
Like if you don't think Opus is doing a good enough job, Fable is worth trying out. But if you don't like the options Opus is presenting, Fable is also worth checking out. It's not just Opus couldn't do enough.
Sometimes it's that Opus didn't try enough different things or the things it was trying were too samey. If you've ever asked Opus to give you five potential solutions to a problem, and two of them were very similar, one of them was a little different and okay, and the other two just made no sense, and it pissed you off, I'm speaking from a lot of experience here, Fable will give you a better variety of options, some of which might make a lot more sense, some of which will make a lot less.
But there's one more here that has surprised me. The other reason to use Fable is that you just want to merge the fucking code. this always happens when a new capability level is unlocked for me where i have a bunch of work that's like on the line but it's been running in circles for a while the agent keeps gaslighting itself and second guessing things fable is better at this both because it's smarter but i have found it's better that this also because it's more willing to let things slide it's not going to block you on some hypothetical for a user that has a piece of data from two years ago that might have the ui in a slightly worse state because it preloaded this piece of data.
It's going to be like, fuck it, whatever. It's probably fine. I have a lot of code that was sitting there unmerged because Opus kept telling me there's more we should do here.
And I pulled Fable and I was like, can you audit the work that was done here and tell us what we should actually do next? And it came in, looked at the work. It's like, this is fine.
I don't know what Opus was smoking. We're good here. And then just merged it.
This came up in a weird place for me. I have a bunch of evals where I'm comparing how well models give feedback on real code bases and real work. And I have found that consistently Fable.
underperforms Sonnet and Opus because Fable is a little too willing to let code through that might have something slightly wrong with it. It won't let things through that are egregiously wrong. Usually, obviously, it's all random.
But Fable is slightly more likely than Opus or Sonnet to let something slip. Initially, I thought this was a flaw. In my first day, even in my Fable 5 .2 video, I was talking about how this is a reason to maybe not use Fable as much and a reason Opus is better.
I did a deeper audit of the comments that Fable leaves on things compared to Opus and Sonnet. The ones Fable missed, the reports Fable didn't file, as well as the less important things or the incorrect things Fable said, the gap doesn't matter. One of the judges here is 6 -1 Sol, and 6 -1 Sol gets pissed at you if you miss anything.
So Sol hugely downranks Fable because it thinks it missed things that matter. But this is also why I like Fable, because it pisses off the other models. It's willing to say, fuck you, this is fine, and then merge it.
And so far, and obviously knock on wood, this could change. So far, everything Fable said was good to merge ended up being good to merge. And I had a bunch of random shit that I was scared to merge.
And Fable has been as much a like older mentor that's like, stop worrying, you're fine, bro, as it has been an actual collaborator. And that's how I thought of the Brad versus Alan thing here. And if you're wondering the names, AB, I just wanted to go down the alphabetical list.
My experience with engineers like Brad, the smartest people I knew was rarely them teaching me things I didn't know. Obviously they didn't, it was helpful. A lot of their role was giving me the confidence to stop over checking and triple guessing every single fucking thing and just tell me it's fine ship.
And I think this is one of the most underrated aspects of Fable is that it's willing to say, fuck you ship. And I love it for that. So if you have some old thread where Opus has been running in circles that you've been trying to land for a while, you should switch to Fable for two reasons.
One, Opus might be stuck on something that it's not smart enough to fix, and Fable is smarter, it might fix it. But more importantly, if it's already good enough, Fable will say, fuck you, it's fine.
Wow, this video was a lot longer than I thought it would be. I thought this was going to be a real quick one. God damn.
This was fun. I enjoyed this a lot. Let me know how y 'all feel about videos like this.
I know the comparisons aren't usually my cup of tea. I just like talking about the things I like. But I really enjoyed this way of doing a comparison.
Yeah. Let me know how y 'all feel about this one. Should I do more videos like this?
Is this the type of thing you wanna see more of on my channel? Or was all the analogies just too cringe and you wanna see facts? Let me know how y 'all feel.
And until next time, peace.
The Hook
The bait, then the rug-pull.
The cold open lists twelve frontier coding models, then deletes ten of them on screen. What's left is a blunt claim: without a very specific reason, anything other than Opus 5.5 or Fable 5.2 is cope, and the rest of the video is about choosing between those two.
Named ideas worth stealing.
07:41list
Opus 5.5 effort level tier list
- S: high
- A: medium, extra-high
- D: low, ultracode
- F: max
High is the best balance. Medium ends turns slightly early, extra-high is for audits and messy environments, max forces overthinking on simple tasks.
Steal fordefault settings guide for any team rolling out Claude Code
21:00model
Teacher's pet vs back-row genius
- Opus 5.5: teacher's pet, never gives up, never cuts corners, bloats your app, says no only if prompted
- Fable 5.2: the student who barely studies and still gets a perfect score
Opus over-checks because it knows it isn't the smartest; Fable trusts its intuition, cuts corners and finds unusual solutions.
Steal forexplaining model choice to non-technical stakeholders
31:51model
Alan vs Brad reviewers
- Alan: tenured, knows the codebase too well, call when it must be perfect
- Brad: 20+ years experience, new to the codebase, call when you want to ship
Opus reviews like Alan and dies on the hill of nitpicks; Fable reviews like Brad, checks for patterns that are hard to fix later, then says LGTM.
Steal fordeciding which model should audit a risky versus routine PR
35:40concept
Provable vs unprovable
If you can objectively verify the result and hill-climb toward it, Opus is enough. If 'better' is a judgment call needing creativity or exploration, Fable finds things Opus won't.
Steal fora one-question routing rule for agent tasks
37:10concept
Use Opus until you want more from Opus
Default to Opus; switch when it lacks capability, when its options feel too similar, or when a finished change needs a confident ship decision.
Steal forteam-wide default model policy
How they asked for the click.
VERBAL ASK
42:00subscribe
“Let me know how y'all feel about this one. Should I do more videos like this?”
A soft feedback ask instead of a subscribe push; the only hard pitch is the mid-roll sponsor read.
MENTIONED ON CAMERA
Visual structure at a glance.
