How to Use Claude Fable 5 Without Going Bankrupt

How to reduce your Fable 5 token cost by 50%+

Claude Fable 5 is the best AI model I've ever used. Full stop.

The problem is, it's insanely expensive.

In the first few hours of testing it, I nearly burned through my entire usage limit - and I wasn't even doing anything crazy.

Fable is exactly twice the cost of Opus 4.8, and because it's so smart, it actually overthinks, running loops and burning tokens in ways no previous Claude model has.

Learning how to use this new model properly is more important than ever.

In this guide, I'll cover the exact 10-80-10 system I've developed to significantly reduce my Fable token costs, and this advice comes straight from Anthropic engineers themselves.

At the very end of the article, I've created a document that you can drop directly into Fable that summarises my entire framework.

This document will immediately reduce your token spend.

Stick around until the end, and I'll share it with you directly.

My framework \document\

I: 10-80-10 System Explained

The 10-80-10 system is a simple framework for using Fable efficiently only where it is actually needed.

This is the exact framework that Anthropic engineers use themselves.

Here's how it breaks down:

The first 10%: Planning

Before you tackle any AI project, you want to use Fable to define the structure, approach, success criteria, and constraints.

Think about if you were to build a house. The most important part is actually getting the architecture and planning right. Or else the builders will just execute a crap plan.

Fable 5 is an excellent architect; use it as such.

The middle 80%: Execution

Most tokens are burned in the back-and-forth, the iteration, the minor fixes, the grunt work of actually completing tasks.

For the execution layer of your AI projects, you should use a cheaper model, such as Opus 4.8 for standard work or Haiku for light tasks.

You get the benefit of Fable's architecture without paying Fable prices for every token of execution (which is overkill anyway).

The final 10%: Review

Once execution is complete, bring Fable back in. Have it review the output against the original architecture.

Does the result match the plan? Are there gaps? Does anything need fixing before it ships?

This final pass is where Fable's intelligence catches what cheaper models miss, and because it's reviewing a finished output rather than generating from scratch, it uses far fewer tokens than it would if it had done the whole task itself.

10-80-10 system

This is the entire 10-80-10 framework that allows you to get all the benefits of Fable, without the downsides of token cost.

Models like Opus 4.8 are just as capable at handling the execution layer, and this system avoids Fables' desire to get everything "perfect" with multiple loops, deep research, etc.

II: Loops Explained

I will do an in-depth article on this, but I want to briefly cover /loop, as it's the most powerful way to use Fable 5 right now.

Lance Martin ( @RLanceMartin ), an engineer at Anthropic, published a guide on designing loops for Mythos-class models.

I highly recommend reading this article, but I'll summarise it below.

https://x.com/RLanceMartin/status/2064397389189071163

The Old Way vs The New Way of Prompting

The old way of prompting looked like this:

You prompt → Claude responds → You review → You reprompt → Repeat

In that model, you are the loop.

You manually verify every verification step, every correction, and every follow-up.

Loops automate this entire process and remove you as the bottleneck.

With loop engineering, you give Fable a goal upfront, and it will then spin up subagents to work toward that goal.

Design the loop → Fable spins up verifying subagents → Agents prompt themselves to complete the goal

Prompt engineering versus loop engineering

/goal and /loop explained

These two commands are the practical implementation of loop engineering inside Claude Code.

/goal is the starting point.

PROMPT STRUCTURE

/goal [task] until [measurable end state] without [constraints]

/loop takes this one step further.

Instead of a single run, /loop reruns the prompt at a predetermined interval.

/loop [your prompt here] --interval 30m --expires 8h

/goal versus /loop

The combination is extremely powerful.

Use /goal to define the task once, and use /loop to have it run automatically on whatever schedule makes sense for the work.

Practically using loop engineering for cheaper token spend

This is where the 10-80-10 system works its magic.

With the 10-80-10 framework, Fable handles the 10% planning upfront by architecting the loop; the cheaper model handles the 80% execution; and Fable only comes back in when the loop closes or when needed.

You can even use GPT-5.5 in the execution layer, which can reduce token spend by 50% or more.

III: General Token Saving Tips

The 10-80-10 system and loops handle the big picture efficiency - these are the smaller adjustments that can also make a difference.

1. Effort Selection

Start on medium effort, not max.

Fable on medium beats Opus on extra high. Only move up if you're genuinely hitting quality issues. Defaulting to max on everything is one of the fastest ways to burn your limit.

Some people even report using Fable on Low effort and getting amazing outputs.

1. Delete old skills and instructions

Prompts built for earlier models often perform worse in Fable.

Shorter, cleaner instructions perform better and cost less inside Fable (Fable will just figure things out on its own anyway).

1. Give Fable the why of everything

Fable gets things right the first time more often when it understands the intent behind the request.

Fewer corrections and iteration rounds also mean way fewer tokens burned.

Note that this model is built for fully autonomous work, and if you don't give the "why" behind things, it has to think harder to come up with the next steps.

1. /usage

Monitor your usage actively. Run /usage in Claude Code regularly. Once Fable moves to pay-per-token on July 7th, this will become essential.

I wrote an entire Fable 5 prompting guide here - many of the tips mentioned here will also cut your token spend

https://x.com/aiedge_/status/2065064961999847849

IV: Expensive Fable Mistakes

These are the two mistakes worth calling out specifically because they're easy to miss and can be expensive if you don't address them.

Mistake 1: Accidentally running Fable when you don't mean to.

When you open Claude Code or the Claude app, it now defaults to Fable.

Anthropic is actively incentivising people to test the model right now.

Simple advice: Check the model selector before every session. I've already caught myself running Fable accidentally in normal chats.

Mistake 2: No spending cap

On July 7th, Fable moves off standard subscriptions.

If you want to keep using it beyond your plan limit, you'll need to add a credit card and pay per token.

The trap is having no hard cap on your credit card.

Fable burns tokens fast on autonomous runs and long sessions. Without a limit, you can rack up a significant bill before you even realize what happened.

You can set your monthly spend in Settings → Usage → Adjust Limit

Set monthly spend

Closing

So, there you have it.

My entire framework for significantly reducing Fable token costs.

I hope you found this article valuable.

If you did, be sure to follow me @milesdeutscher and @aiedge_ - every single week I post practical AI guides to keep you ahead in this crazy space.

As promised, I created a document that you can send directly to Fable to reduce token spend ASAP.

10-80-10 system document \sneak peek\

To access the full document:

1. Sign up for the free AI Edge newsletter
2. Join my free Instagram community so I can send it to you

Get started here.👇

https://www.aiedgehq.co/

https://www.aiedgehq.co/

Thank you for reading if you made it this far.💙