# Fable 5.2 plans and reviews, Opus builds cheaper

> Source: <https://blog.hagebols.com/posts/fable-plans-and-reviews-opus-builds-cheaper/>
> Published: 2026-11-16 00:00:00+00:00

I have 7 or 8 Claude Code tabs open on a normal day, about 1 per project. Today I watched a video about Fable 5.2, set Fable as my default, and asked Claude how I should set up my day around it. The first thing it proposed was to put the default back on Opus.

It had a point. Running everything on Fable uses a lot of tokens, and for most of my work Opus 5.5 on high effort gets me there too. Fable is the smarter model. I want that intelligence in 2 places, the plan of a large task and the review of the result.

The video is [Fable 5.2 Is Insane... Only If You Use It Anthropic's Way](https://youtu.be/EFGvVCpW9zc) by AI LABS, and it collects advice from Anthropic's own guides. It quotes Fable at 2 times the price of Opus per token. When they built the same feature on both, the work was equally good and Fable cost about 58% more.

Their setup is 1 Fable session that leads and hands the building to cheaper models. On a small feature that cost them about 1.7 times what Opus alone did, so I'd have to pick that tab myself for every big job. Sometimes I don't know up front whether a job is big or small. I want that decided for me. I still want control, and a place to add what I know about the domain.

I asked for the tab to switch to Fable by itself when a task is big. That doesn't exist. `/model` is something only I can type.

So Opus stays in every tab. It weighs each task and says in 1 line which way it goes. A small task it does itself. For a large one it starts Fable as a subagent, through a skill I called dirigent, Dutch for conductor.

The weighing rule is 18 lines of text that a hook adds to every new session. This is the part that decides.

```
Weigh every new task before you start and say in one line, in the user's language, what you are doing. This is for the main session; a subagent that was handed a task just does it.

- **Small** (fits in one session, no independent parts): `Small: I'll do it myself.` and do it.
- **Large** (won't fit in one session, or three or more independent parts (parts that different workers could build at the same time), or touches several subsystems or repos, or a design choice with several serious routes): `Large: Fable plans, workers build, Fable reviews.`, then load the `dirigent` skill (listed as `dirigent:dirigent` when installed as a plugin) and follow it.
```

A large task starts with 1 round of questions, 4 at most, after Opus has read the code and the docs. The last question is always whether there's something it should know that isn't written down anywhere. That's where my domain knowledge goes. Another question offers a single upgrade from my [ambition skill](https://github.com/Kompas/ambition), with "no, just the task" as the first option.

After that round it doesn't ask me anything. Fable writes the plan as a table, with a pass or fail check for every task and the model that will build it. This is the table from the skill that Fable picks from.

| Work | Model | 
|---|---|
| Search, list files, read logs | haiku | 
| Clear and bounded: a doc, a rename, a test for specified behaviour, boilerplate | sonnet | 
| Default: implementation, debugging, anything needing judgment | opus | 
| The one hardest part, only when Opus failed its judge twice | fable | 

Opus runs each check itself, and a fresh Fable agent that never saw the plan reviews the result. Deploys, production data and messages to people still wait for my yes.

If Opus weighs a task wrong, 1 word from me flips it. Small, large, or fable.

I tested the rule in a fresh Opus session on 4 tasks from my own work.

| Task | Opus said | 
|---|---|
| Why does this test fail | small | 
| Move a whole family of endpoints to a new path, old paths keep working, docs and tests updated | large | 
| What is today's success rate per country | small | 
| Add 1 optional parameter, with a test and a line of docs | small | 

I agreed with all 4. Later the same day a normal session in another project opened with its 1-line verdict without being asked.

That project also gave me the first real run, a design job. Opus asked 3 questions in 1 round and Fable planned 9 steps. 7 Opus workers built the screens, 6 of them at the same time, and a Sonnet worker did the exports and the docs afterwards.

Each worker saw only its own screen, so it was Opus that caught 3 things that didn't match between screens. One was a night-time push notification saying the site was back up, 2 minutes before the log on another screen said so.

Then the fresh Fable agent went over all 8 screens. It found nothing wrong with how they were built, and 12 places where text or numbers contradicted each other. 2 of those were in the spec itself. A header said a site had been down for 14 minutes. It had been down for 6, and 14 was how long the bots had worked on it.

2 results don't flatter it. The mobile screens had a width check, the worker reported it couldn't measure widths, and Opus approved the task on a screenshot anyway. And a subagent is expensive in my setup. One that answered a single yes or no question, without using a tool, used 107,584 tokens. That project's `CLAUDE.md` is 143,084 characters long, and every subagent reads it before it reads the task.

It's a plugin now, in [Kompas/dirigent](https://github.com/Kompas/dirigent). This installs the skill and the hook.

```
claude plugin install dirigent --marketplace Kompas/ribbon
```

Then type `/model opus` once, start a new session and give it a task.
