Big Idea

The argument in one line.

Most of the cost and usage-cap pain from a frontier coding model comes from using its highest reasoning effort and having it do low-value work itself, both of which can be dialed back with almost no quality loss.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code (or a similar agentic coding tool) regularly enough that weekly usage limits or API cost are a real constraint.
You default to the highest effort/reasoning setting without having tested whether a lower setting performs just as well for your task type.
You're building workflows with multiple AI models and want a mental model for which model should plan versus which should execute.
You're curious about practical techniques (not internals) for stretching a fixed usage allowance further.

SKIP IF…

You don't use an agentic coding assistant with tiered effort/reasoning settings or usage caps — the specific tips won't transfer.
You're looking for benchmark methodology rigor — the cost/accuracy numbers are read off on-screen charts, not independently verified.

TL;DR

The full version, fast.

The video argues that most people overpay for frontier coding models by defaulting to the highest effort/reasoning setting when a much cheaper one performs nearly as well on most tasks. It walks through five levers: (1) lower the effort level for anything short of genuinely complex work, since benchmark data shows an 80% cost drop for only a few points of accuracy loss; (2) use the expensive model only to plan, and delegate execution to cheaper models suited to the sub-task; (3) apply token-reduction skills/guidelines that cut output verbosity by roughly 20% at similar quality; (4) let cheaper models do web research and fact-gathering, then hand a distilled brief to the expensive model for planning; (5) use 'advisor mode,' where the expensive model coaches a cheaper executor model only when it gets stuck, rather than doing the work itself. Together these aim to keep users under weekly usage caps while preserving most of the quality of the top-tier model.

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 →

Chapters

Where the time goes.

00:00 – 00:30

01 · Cold open + stakes

States the 80%-cheaper claim and frames the urgency: usage caps and looming API-price exposure make cost efficiency important now.

00:30 – 04:09

02 · Tip 1 — Lower the effort level

Walks through DeepSWE and Anthropic's own frontier-code-accuracy-vs-cost charts showing low/medium effort nearly matching high/max effort at a fraction of the cost; recommends matching effort to task complexity.

04:09 – 04:37

03 · Sponsor break

Self-promotes a paid Claude Code course.

04:37 – 06:00

04 · Tip 2 — Architect, don't executor

Recommends using the top-tier model only to produce a plan and delegating execution to cheaper models chosen per sub-task, including other vendors' models via a Codex plugin.

06:00 – 07:30

05 · Tip 3 — Token-reduction skills

Introduces a 'Ponytail' skill for reducing verbosity/token count; shows a benchmark table comparing baseline vs skill-assisted runs, citing about 22% cost savings on the new model.

07:30 – 09:59

06 · Tip 4 — Let cheaper models do research

Argues deep-research fan-outs (built-in dynamic workflow, ~109 sub-agents in this video's own prep) should run on cheaper models, with only the final synthesis/planning handed to the expensive model.

09:59 – 11:40

07 · Tip 5 — Advisor mode

Explains advisor mode (cheap executor + expensive advisor consulted only when stuck), shows the official 'advisor strategy' diagram and a prior-generation benchmark chart, and gives the exact terminal commands to set it up.

11:40 – 12:01

08 · Wrap + CTA

Recaps the five tips and repeats the course pitch.

Atomic Insights

Lines worth screenshotting.

Dropping a frontier coding model from max to low effort cut average cost per task from about $22 to about $3.76 in one benchmark, a reduction of more than 80%.
At low effort level, the model scored 60% pass rate on a long-horizon agentic benchmark, beating a competing top-tier model's max-effort score of 59%.
On a frontier-code-accuracy-versus-cost chart, the model at low effort scored roughly 11% at just over $5, while a competing top-tier model needed about $11 to hit the same score at max effort.
At medium effort the model outperformed a rival top-tier model while still costing less than that same model's second-highest setting.
The suggested default workflow is complexity-matched: simple tasks like web design belong on medium or low effort, not high or max.
A token-reduction skill tested on the newest model produced roughly 22% cost savings at medium effort, higher than the savings previously reported for that skill on a smaller model.
The core delegation principle: use the most expensive, highest-reasoning model only to produce a plan, then route execution work to whichever cheaper model fits each sub-task, including other vendors' models.
Research and fact-gathering work is proposed as a job for cheaper models, since a frontier reasoning model's advantage is architectural judgment, not web-scale information retrieval.
A single deep-research run for this video's own preparation spawned about 109 sub-agents, illustrating why running that fan-out on the most expensive model would burn through a usage allowance quickly.
'Advisor mode' pairs a cheap executor model that does all the tool calls, reads, and writes with an expensive advisor model that is only consulted when the executor gets stuck, rather than doing continuous work itself.
In a prior generation of this advisor-mode pairing, the cheaper executor model performed better for less cost than running the expensive model alone, according to a chart the creator cites from the model vendor.

Takeaway

Match model effort to task complexity, not to habit

COST DISCIPLINE

The biggest usage-cost lever with a metered AI model isn't a secret trick, it's simply not defaulting to the highest setting for tasks that don't need it.

Benchmark data can show an 80%+ cost drop for only a few percentage points of accuracy loss when a task doesn't require maximum reasoning effort.
Splitting work so the most capable (and expensive) resource only plans, while cheaper resources execute, is a transferable pattern beyond just AI coding tools.
Verbosity has a real cost: trimming unnecessary output can save a meaningful percentage of cost without changing the quality of the result.
Fact-gathering and research don't require your most expensive resource — reserve premium capacity for judgment and synthesis, not retrieval.
A 'consult only when stuck' pattern (advisor mode) can outperform having a single expensive resource handle everything continuously, both on cost and on outcome.

Glossary

Terms worth knowing.

Effort level: A setting in agentic coding tools that controls how much reasoning/compute the model spends per task, typically ranging from low to max; higher levels cost more and take longer but aren't always more accurate for simpler tasks.
Advisor mode: A workflow where a cheaper 'executor' model does all the actual work (reading, writing, running tools) and only consults a more expensive 'advisor' model when it gets stuck, instead of having the expensive model do the work directly.
Architect/executor delegation: A workflow pattern where the most capable (and expensive) model is used only to produce a plan, and the actual implementation work is handed off to cheaper models chosen per sub-task.
Deep research (dynamic workflow): A built-in mode that spawns many parallel sub-agents to gather and cross-check information from the web before handing a synthesized brief to the main model.
Token-reduction skill: A set of guidelines/instructions given to a coding model so it produces the same functional output using less generated text, lowering both cost and time.

Resources

Things they pointed at.

00:49toolDeepSWE benchmark

03:10productClaude Code Masterclass (chase.ai plus)

05:21toolCodex plugin for Claude Code

06:00toolPonytail (token-reduction skill)

07:03toolCaveman (alternative token-reduction skill)

08:00toolDeep research dynamic workflow

09:59linkAdvisor strategy (Anthropic blog post)

Quotables

Lines you could clip.

00:00

“What if I told you we could reduce Fable five's cost by 80% while still beating Opus 4.8?”

cold-open hook with a specific, testable claim→ TikTok hook↗ Tweet quote

03:20

“If nothing else, I want you to try doing a task on medium with Fable. Try doing a task on low and see how well it does.”

single, concrete, low-effort-to-try recommendation→ IG reel cold open↗ Tweet quote

05:49

“Let the lower level peons like Opus and Sonnet gather all that context and then hand it to Fable.”

punchy, memorable phrasing of the delegation principle→ newsletter pull-quote↗ Tweet quote

The Script

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.

metaphoranalogy

What if I told you we could reduce Fable five's cost by 80% while still beating Opus 4.8? Well, that is just one of five tricks I'm gonna show you today that are all about reducing Fable five's usage and token cost without losing what makes this model great. Because we all know the clock is ticking.

We just got a few days left until Fable five is kicked off the pro and the max plan, and we are stuck paying API prices. And on top of that, we're also usage capped, so it is imperative that we figure out quickly how to get the best bang for the buck with this new model.

So that is exactly what we are gonna talk about today, and let's dive in. So tip number one. This is the easiest one and arguably the highest leverage.

It is changing the effort level. It is reducing the effort level with Claude Fable five. Now by default, we are on high, and some of you are crazy out there, and I see you pushing it to extra high or even max.

And the truth is you probably do not need that. First of all, what are we looking at here? Well, we're looking at a benchmark.

This is deep suite. This is one of my favorite benchmarks. It's all about long horizon, long running agentic tasks, and we see Fable five here, Opus 4.8, as well as GPT 5.5.

Now I said in the intro, I said you could reduce cost by 80%. When we look at the max effort level, which, by the way, doesn't give you that much of an upgrade in terms of, you know, pass percentage from extra high, it's costing us $22, our average cost per task when looking at Deep Suite.

If we compare that to low, it's $3.76, more than an 80% reduction in cost.

Yet at low effort level with Cloud Fable five, we're doing better than max at Opus 4.8. So we're at 60% at Fable five low, and we're at 59% with max Opus 4.8.

And Opus, this case, is $13 versus $3.76.

That's crazy. Like, you could argue that's crazier than the jump from 59 to 70 is the fact we're doing this so much more efficiently. And when we pop up to medium, we're going up from 60% to 65% pass rate, and we go up to high, we're at 69%.

And on extra high, we're at 70 versus 59%. But at low, again, we're getting really solid outputs that are extremely cheap even compared to GPT 5.5, which honestly is such a sleeper model.

It's so good. I'm super excited to use 5.6 when it comes out. It's still doing better than medium, slightly more expensive, but not by a ton.

Now we see this reflected in other benchmarks as well. Here's a look at frontier code accuracy versus cost, and this is coming from Anthropic itself. So in the orange, have Fable.

In the green, we have Opus 4.8, and then down here at the bottom, we have 5.5. Look at low. Alright.

Just a shade over $5 and the score is about 11%. If we look at Opus 4.8 on max, it's, call it, $11, and it's the same exact score percentage.

So I'm getting the same pass rate as Opus 4.8 on max at half the cost.

And if I go up to medium, I'm blowing Opus 4.8 out of the water while still being less expensive than extra high, which is where a lot of people sit for just default Opus settings. So with that in mind, does it make sense for us to sit on the default high level with Fable five? I think when you look at both of these benchmarks, the answer is probably no.

And we look at deep suite, deep suite is rather complicated tasks. Are you doing something very complicated?

The less complicated of the task you're doing, if you're doing web design, you probably should be on medium or low. And that right away is going to reduce your costs and reduce your usage substantially, substantially.

So out of everything you see today, if nothing else, I want you to try doing a task on medium with Fable. Try doing a task on low and see how well it does.

I think you would be surprised, and you're not gonna get to that 50% of your weekly limit nearly as quickly as you would otherwise. And, of course, to change the effort level, all you have to do is go into the terminal, do forward slash effort, and then set it where you want to.

Now before we jump into tip number two, quick word from today's sponsor, me. So I just released my Cloud Code Masterclass, and it is the number one way to go from zero to AI dev, especially if you don't come from a technical background.

We focus on real use cases. It's updated every single week, and it also includes a Codex masterclass and an AgenTic OS masterclass.

So if you're someone who's really trying to level up your AI game, wanna get serious about this, make sure to check it out. It's inside of chase.aiplus. There's a link to that in the pinned comment.

Now tip number two when it comes to reducing fables, usage is also pretty straightforward, and that is stop using fable to both plan everything and execute everything. Instead, make Fable the architect.

Have it come up with a plan, and then depending on the complexity of the plan, have it divvy up the work to the appropriate model, whether that is Opus, whether that's Sonnet, or it's an outside model. It could be GPT 5.5. It could be something local.

Fable's also smart enough to know which model is best for the job. And you can have Fable five explicitly call out those models in the plan. So Fable five does the plan, and then it says, hey.

For the first part, I want Opus. For the second part, Sonnet makes sense. And for the third part, let's send that to OpenAI and bring in GPT 5.5.

This is a perfect use case for something like the Codex plug in within Cloud Code. And if you haven't used that before, I highly suggest you do. You can totally bring in something like the Codex rescue function and have Fable call on that to give features to GPT 5.5, which, again, awesome model.

But if all that's too complicated and having it call out all these agents, you can do something as simple as simply throwing it in plan mode, you know, having it come up with the plan, having it create some sort of markdown file, set the stage for your code base, and then simply spinning up another session with Opus and having it execute the plan that Fable laid out.

You don't need to overcomplicate it, but that stops Fable from burning a bunch of tokens on low level tasks that are gonna be necessary for, you know, whatever you're creating. Now tip number three is to bring in outside tools and skills like Ponytail that are all about reducing token count. Now if you don't know what Ponytail is, I did a full video on it, and its thing is like, hey, Claude's pretty verbose.

What if we gave it a set of guidelines to follow so that we still get the same outputs? It's still just as effective. It just writes less code to get there.

Now the thing with Ponytail is it gives us a bunch of benchmarks. The thing with the benchmarks are they've only been tested on Haiku 4.5, and Fable five is a different beast entirely.

In my last video, I tested the numbers using Opus 4.8 and found that using Opus 4.8, these numbers were actually even better.

It actually wrote less code. It consumed less tokens, and it was faster. And so I went ahead and I ran some of the same benchmarks using Fable.

So these numbers on the left right here that are underlined, this is the baseline, and then these over here on the right is what Fable five got using Ponytail, and this was on a medium setting.

So across the board, essentially, it put out less tokens. And in terms of cost, which is what we really care about because, you know, the tokens, like, we do care if they're input versus output, at the end of the day, it was essentially 22% cheaper, which funny enough is actually even better than what they claim for Haiku.

Now there's other skills like caveman that claim to do the same thing, but the big picture with this tip is this is an expensive model. If there's stuff out there that can give us a 20% boost, it's worth experimenting with.

So even if something like this is sort of like suspect to you, I think we shouldn't dismiss it out of hand because 20% is a lot of money when we're talking about thousands of dollars. Now on the surface, tip number four is the exact opposite of what I told you in tip number two. Remember tip number two?

I said, hey. Fable doesn't need a plan and execute. Just have it planned.

Well, this tip, I'm saying, let's not have a plan. Let's actually have Opus plan for Fable.

Now what I mean by this isn't every plan should be done by Opus, and we have Fable actually create everything. I'm saying for a lot of our plans, they require research. And one of the best ways to research these days is with UltraCode and dynamic workflows.

Specifically, I'm talking about deep research. So for those of you who don't know, forward slash deep dash research is a built in dynamic workflow you can use, and it's gonna spawn a ton of sub agents.

I used deep research in preparation for this video, and it spawned a 109 sub agents. First of all, would I wanna run deep research with Fable five as every one of those sub agents?

Absolutely not. I would blow through my limits. That makes no sense.

But the real point here is I wanna use a lower level model like Opus for deep research because research isn't something that requires some, like, super high intellect reasoning level like Fable. However, Fable five doesn't necessarily have all the context of today. Its knowledge cutoff wasn't yesterday.

We still need something to go out there on the web, gather information, do some baseline adversarial work to make sure that information even makes sense, and then hand that to Fable.

And then Fable makes the plan. Right? If we're gonna plan something, we need information to start.

And so I don't think it makes a lot of sense to have Fable go out and gather all the information. Let the lower level peons like Opus and Sonnet gather all that context and then hand it to Fable. And then Fable creates the plan, then they can hand it off.

So Fable doesn't have to do everything in the planning stage. We can kind of give it a leg up, let it do the high level intellectual architecture work, and let these dumber models do everything else.

And in that sense, dynamic workflows, ultra code, deep research is perfect for these low level models and saves that Fable usage for the more important things. Now tip number five is something that actually came out a few months ago, and that is advisor mode. Advisor mode was originally shown with Opus and Sonnet working together.

The idea is, this should sound familiar, is we have a smart model that is the adviser, that is the planner. It is handing off its plan to an executor, a lower level model, in this case, Sonnet.

It is executing tools. It is reading. It is writing.

But anytime it gets stuck, what does it do? Well, it shares its context with the adviser. The smarter model says, hey.

Here's what's going on. I'm stuck. What should I do?

And if this sounds like a more sophisticated version of everything we've been talking about up until this point, you would be correct. Now Anthropic hasn't put out any official numbers of what this looks like with Fable as the adviser and having Opus be the executor or Sonnet, but we can make a few assumptions. What you see here is a graph from Opus and Sonnet 4.6.

This is one of the all time graphs from Anthropic. I mean, just look at these axes. But what you got using Advisor mode was a Sonnet that performed better for cheaper.

So it was overall, it was just more effective. And you see that reflected here as well across multiple benchmarks. Now to actually use Advisor in this way, you can't have your model set to Fable five because whatever model you have set, that is the model that is the executor.

That's the model that's actually writing the code. So if I want Fable five as the adviser and I want Opus actually doing everything, then I need to make sure my model is set to Opus. Then I just need to do forward slash adviser, and then that's when you set the adviser model.

So I do forward slash adviser, Fable. Now Fable is the one that's gonna be essentially telling Opus what to do.

So if you're someone who really loves the idea of Fable purely acting as the architect, the conductor, and letting the lower level models do everything, this is definitely a path you should try out. So those are five quick tips for reducing your Fable five usage while still getting the most you can out of this amazing model.

Hopefully, Anthropic is nice to us and they just keep it on the pro and max plan. That would be great.

And also, by the way, if you give us more than 50% of the weekly limit, that would be awesome too. But until then, we're gonna work with what we have. So as always, let me know what you thought.

Make sure to check out chase.ai plus if you wanna get your hands on my Cloud Code Masterclass. And besides that, I'll see you around.

The Hook

The bait, then the rug-pull.

The claim up front is blunt: an 80% cost cut on the newest frontier coding model while still out-scoring a top competing model. What follows is less a hack and more a case for matching model effort and delegation to task complexity, backed by benchmark charts the creator reads live on screen.

Frameworks

Named ideas worth stealing.

00:30list

Five usage-reduction tips

Lower the effort level to match task complexity
Use the top model only as architect/planner, delegate execution to cheaper models
Apply token-reduction skills (e.g. Ponytail)
Offload research/fact-gathering to cheaper models before planning
Use advisor mode (cheap executor + expensive advisor on-demand)

A structured checklist for reducing both dollar cost and weekly usage-cap consumption of a frontier coding model.

Steal forAny workflow using a metered/capped premium AI model where task complexity varies

09:59model