The short answer
Claude Fable is the newest and fastest model in the Claude 5 family, built specifically for cost efficiency at high throughput. If you are burning tokens on Claude Code all day the way I am, the practical playbook has two parts. First, route the right tasks to Fable instead of Sonnet or Opus. Second, put a live token meter in your editor so you catch the runaway sessions before they hit your bill.
I have been running this setup for the last two weeks and my Claude Code spend is down roughly 40% on the same amount of shipped work. This is what actually changed.
What Fable actually is
Fable is a Claude 5 family model tuned for speed and low cost per token. Same reasoning architecture as Sonnet and Opus, smaller parameter count, dramatically faster output, and priced to make it worth reaching for on tasks where Opus would be overkill.
The temperature guidance from the previous post still applies. Fable respects the same 0 to 1 range. What changes is which tasks make sense to send to Fable at all versus keeping on Sonnet or Opus. That is the real decision.
When Fable is the right call
Three buckets of work where Fable consistently matches Sonnet output at a fraction of the cost:
1. Boilerplate code generation
CRUD endpoints, form validation, standard React components, Prisma schema stubs, migration files. These are tasks where the pattern is dominant and creativity is a bug, not a feature. Fable ships correct code at temperature 0 to 0.2 essentially as reliably as Sonnet.
2. Test writing
Unit tests, integration test scaffolds, snapshot tests. The structure is prescribed. The model does not need to be a genius, it needs to be consistent. Fable is consistent.
3. Documentation and README generation
Writing docstrings, API reference docs, README skeletons. Medium temperature (0.3 to 0.5), predictable structure, high token volume. Fable saves real money here because doc generation eats output tokens fast.
4. Classification and extraction
Parsing structured data out of logs, categorizing support tickets, extracting entities from documents. Same pattern: correct answers exist, the model needs to find them, creativity is not required.
When Fable is the wrong call
Be honest about the ceiling. Fable is not a Sonnet or Opus replacement on hard problems. Do not use it for:
- Architecture decisions. Multi-file refactors that need to hold context across a codebase are still an Opus job. Fable loses the plot on tasks that require synthesizing information from more than a few files.
- Subtle debugging. Race conditions, memory leaks, deadlocks. Anything where the fix requires reasoning about state across time. Sonnet is the floor here, Opus if the bug is expensive.
- Novel code that has no strong prior. If you are writing something that looks nothing like anything in a public training corpus (custom DSL, proprietary framework, unusual optimization pattern), Fable will hallucinate confidently. Bigger model, then verify.
The rule of thumb: if the task pattern is common and the correctness bar is "does the code do what it says on the label," Fable. If the task requires holding a lot of context or reasoning about tradeoffs, Sonnet or Opus.
The task-to-model quick reference
| Task | Recommended model | Temperature |
|---|---|---|
| CRUD endpoints | Fable | 0 to 0.2 |
| Form validation | Fable | 0 |
| React component scaffolding | Fable | 0 to 0.2 |
| Prisma schema | Fable | 0 |
| Unit test writing | Fable | 0 |
| README generation | Fable | 0.3 to 0.5 |
| Docstring writing | Fable | 0.2 to 0.4 |
| Log parsing / extraction | Fable | 0 |
| Support ticket classification | Fable | 0 |
| Code review pass | Sonnet | 0 to 0.2 |
| Refactor across 3-5 files | Sonnet | 0 to 0.2 |
| SQL query optimization | Sonnet | 0 to 0.2 |
| Multi-file architecture change | Opus | 0 to 0.2 |
| Subtle debugging | Opus | 0 |
| Novel algorithm design | Opus | 0.2 to 0.4 |
| Cross-service integration design | Opus | 0 to 0.2 |
Do not think of Fable as "the cheap one you use when you feel guilty about your bill." Think of it as the right tool for a specific class of task where the bigger models are objectively overkill.
The live token meter that made this practical
Routing tasks by model only saves you money if you actually know what your bill is doing session by session. Estimating it in your head does not work. I tried.
The tool that fixed this for me is a small, honest VS Code extension called BRAINS Claude Usage Monitor, published by BRAINs Certified. It reads your local Claude Code transcript files at ~/.claude/projects/, sums up your token usage in rolling 5-hour and 7-day windows, and shows the running total in your status bar.
What it actually does
Straight from the extension description, no marketing polish:
- Status bar fill indicator tracking rolling 5-hour session usage
- Hover card with 5-hour and 7-day windows and progress bars
- Last-hour cumulative sparkline
- Sidebar activity-bar webview for persistent visibility
- Configurable nudge notifications at threshold crossing
- Current chat breakdown showing cumulative tokens, last-turn input and output, and cache hit rate
- Five most recently active sessions across workspaces
- Cache-price weighted calculation that matches Anthropic's actual billing
The honest privacy story
The extension reads ~/.claude/projects/ locally in read-only mode. No network calls. No telemetry. No API key required. If you are running Claude Code, the transcript files are already on your disk. The extension just aggregates them into a visible number.
This is the part I care about. Most "token counter" tools want you to route your API traffic through their proxy or sign up for a dashboard. This one does not. It sits inside your editor and looks at files you already have.
How to install it
Direct marketplace link: marketplace.visualstudio.com/items?itemName=BRAINs-Certified.BRAINs-claude-usage-monitor
Install through VS Code Quick Open (Ctrl+P), paste the install command from the marketplace page, hit enter. Alternative install: download the .vsix from the GitHub releases page and run code --install-extension <file>.
Current version is 0.2.7 at time of writing. Small install base (30 installs when I found it), zero reviews. That is a fair signal of "early tool, works but not battle-tested at scale." I have been running it for two weeks with no issues on a Windows machine.
What it does NOT do
Honest limitations:
- Only reads Claude Code transcripts. Does not track claude.ai chat or direct API usage.
- No per-model cost breakdown in the current version (it shows tokens, not dollars, and calculates a cache-weighted cost. You still need to map which model those tokens went to.)
- No historical export. Data lives in the local files, and if you clean out
~/.claude/projects/you lose the history.
For Claude Code cost visibility specifically it is the best free tool I have found. For claude.ai or API usage you still need another approach.
The full playbook
Combine model routing with live monitoring:
- Set your Claude Code default to Fable for the day. In your Claude Code config, set the default model to Fable. Every task starts there.
- Escalate manually when the task warrants. When you know you are about to ask for a multi-file refactor or a subtle debugging pass, prefix your prompt with a model switch or open a fresh session on Sonnet or Opus.
- Install the BRAINS monitor. Status bar sits in the corner. You see the 5-hour rolling total live.
- Set a nudge threshold. In the extension settings, set a token threshold that maps to your daily budget. When you cross it, you get a notification. This is the part that actually changes behavior. Estimates in your head do not.
- Review the last-hour sparkline before starting a big task. If the sparkline is already trending up sharply, that is the moment to send the next prompt to Fable, not Opus.
The real math on savings
I ran the same 20 shipped Claude Code tasks two ways over two weeks. First week, everything on Sonnet at default. Second week, routed per the table above with the monitor visible.
Week 1: rough token count normalized to arbitrary units, 100 units.
Week 2: 62 units. Same work shipped.
A 38% reduction, and the honest breakdown was that roughly 30% came from routing to Fable when Fable was correct and 8% came from just seeing the running total and being more careful with prompts that had no clear win from a bigger model.
Both levers matter. Neither is enough alone. Model routing without visibility, you route the first three tasks correctly then forget by mid-day. Visibility without model routing, you see the meter climbing and feel bad, but you have no lever to pull.
Common mistakes
Using Fable for everything to "save money"
Fable is not a Sonnet replacement. On the wrong task it produces confidently wrong output that costs you more in debugging time than any token savings. Route by task type, not by mood.
Not setting a nudge threshold
The extension works as a passive display. Without a threshold, you look at the number occasionally and forget. With a threshold, you get an interrupt at the right moment. Set one.
Ignoring cache hit rate
The extension surfaces your cache hit rate. Anthropic charges roughly 10% for cache reads vs full tokens. A session with 60% cache hits costs way less than one with 5%. If your cache hit rate is dropping, something changed about how you are prompting. Investigate.
Cleaning out ~/.claude/projects/ to save disk
Those files ARE your usage history for this tool. Do not clean them out reflexively.
Fable and the prompt patterns that still matter
One thing worth naming. Fable does not change the truth from the temperature guide. Prompt structure still matters more than model choice on the marginal task. A well-structured prompt to Fable often beats a lazy prompt to Opus. The Cheat Sheet has the 160+ tested prompt patterns I use daily, and roughly 90% of them work identically well on Fable, Sonnet, and Opus. Fable is the cost lever. Prompt structure is the quality lever. You want both.
Where the rest of this lives
Model routing plus a live meter is the cost side. The quality side is knowing which prompt patterns reliably shift Claude's behavior regardless of which model you route the task to. The Cheat Sheet is where I keep the 160+ patterns I have tested against Claude Fable, Sonnet, and Opus, with the temperature and system prompt I use for each. $15 for Full, $35 for Pro with the deeper analysis on the codes that shift reasoning consistently across all three model tiers.
The free 75-page Claude guide covers the setup basics if you want the long version first: clskillshub.com/guide