My Experience With Fable 5

I've spent a good amount of time with Claude Fable 5 now, and am happy to have it back in my hands now after the global ban.

The best way I've found to use it isn't to let it write the code.

That sounds backwards, so let me explain. Fable 5 is impressive. On hard, multi-step problems it stays on track in a way older models don't. It's the kind of task where a lesser model starts strong and then quietly wanders off around step forty, and Fable just keeps its head. Point it at a messy refactor and it holds the whole shape of the problem at once. The vision side is strong too. Document parsing and turning a screenshot into a working front end come out cleaner than anything I'd used before.

But two things pushed me to change how I use it.

What it's good at, and where it stops

The first is that its real strength isn't typing. It's thinking.

Where Fable pulls ahead of Opus is reasoning and planning. Hand it a messy problem and ask it to work out the approach, what to build, in what order, what the tradeoffs are, where the risk hides, and it behaves like a strong architect. It picks a direction, argues with its own assumptions, and gives you a plan that holds up when you push on it.

The second thing is that it eats through my usage fast.

I'm on subscription Claude billing, not API billing, so I don't think about this as a per token cost. Fable burns that limit down about twice as fast as Opus for the same work, and a long agent run with subagents going in parallel can drain a whole window before I've finished my coffee. I've hit the limit several times in the middle of active feature development. So spending my usage to make it do the slow, heavy build work is the worst trade I can make.

Meanwhile Opus 4.8 is still a very good builder. Give it a clear plan and it implements cleanly and quickly, and it barely touches my limit by comparison.

So the two models have almost opposite shapes. One thinks better. One builds cheaper and leaves my usage alone.

The workflow that stuck

Once I saw that, the move was obvious.

I use Fable to plan, and Opus to build.

I give Fable the hard problem and ask for a plan, not code. The architecture, the order of operations, the edge cases, what "done" looks like. The output is small, so it barely dents my usage, but the thinking behind it is exactly what Fable is best at.

Then I hand that plan to Opus and let it do the actual work. The file edits, the tests, the loop of run it, read the failure, fix it. That's the heavy part, the part that would chew through my Fable window in minutes, and Opus does it for a fraction of the burn.

The result beats either model on its own. Opus alone does fine, but it's only as good as the plan it starts with, and left to plan for itself it makes more average calls. Fable alone gives you a great plan and then empties your usage crawling through the build. Split the job and you get Fable's judgment on the decisions that matter and Opus doing the volume without wrecking your limit.

I get more done inside the same subscription this way, and the output is often better, because the plan going in was sharper.

What I'd tell another engineer

If you're trying out Fable 5, don't just point it at your whole workflow and let it run. You'll blow through your usage in an afternoon, decide it's not worth it, and miss what it's actually for.

Use it where the thinking is the bottleneck.

Give it the problem you'd normally hand to your most senior engineer to scope. The migration nobody wants to own. The bug that's already beaten two people. The feature with the tricky tradeoffs. Ask for a plan. Read that plan like you'd read a senior engineer's, because it's good, not perfect, and you're still the one on the hook for it. Then let a cheaper model carry it out.

Treat Fable as the architect in the room, not the pair of hands.

The takeaway

The instinct with any new top model is to make it do everything. The better instinct is to figure out the one thing it's great at and use it for that.

For me, Fable 5 is the best planner I've used and an expensive way to write code. So I let it plan, I let Opus build, and I stopped spending my usage on the part it isn't even best at.

Think with the strong model. Build with the cheap one. Most of the value was in the thinking anyway.