Everything on this site about specs, playbooks and finishing still applies with Claude Fable 5.1. What changes is how much you can hand over at once, and how you should hand it over.

Give it the hard problem first

The teams that got the most out of Fable 5.1 in early access did the opposite of the cautious approach. Instead of starting with something small to build trust, they gave it their hardest unsolved problem — and had it scope the problem, ask its questions, then execute.

If your game has a physics bug you've never cracked, or your app has a data model you've rewritten three times, start there.

hard-problem-first.txt
I've been stuck on <the problem> for <how long>. Here's everything I
know: <paste the code, what you've tried, what happens>.

Before building anything: scope this. What do you think the real
problem is? What do you need to know that I haven't told you? Ask me.

Then, once you have what you need, fix it properly. Run <how to verify>
after. Don't stop to check in unless you hit a genuine decision I
haven't covered.

Specify the whole thing

Fable 5.1 handles large, complete specifications well. Instead of building a game feature by feature over twenty sessions, write the full spec — the one-sentence pitch, the screens, the mechanics, what's out of scope, how you'll know it's done — and hand it over. The spec snippet and first project guide still describe how to write one.

What's different is that you can then say "build this" and mean all of it.

Let it verify as it goes

For anything that runs long, ask it to build its own checking harness and use it. For a game, that might be a script that loads the level and checks it's completable. For an app, the test suite. Separate fresh-context verifier sub-agents tend to outperform the model critiquing its own work — if your tool supports sub-agents, use them.

verify-as-you-build.txt
Establish a way of checking your own work as you build — a test suite,
a smoke script, a level validator, whatever fits — and run it every
time you complete a piece. Check against the spec, not against what you
happened to build.

If your tool supports it, delegate verification to a separate sub-agent
with fresh context. Keep working while it runs.

Delegate

Earlier models needed to be discouraged from spawning sub-agents. Fable 5.1 handles them dependably. For a game, one agent on the level generator while another tunes the movement. For an app, one on the API while another builds the interface. Give explicit guidance on when to delegate and let it get on with it.

Then play it, or use it

None of this replaces the part where a human uses the thing. Fable 5.1 can build a complete, working, tested game in a long session. It cannot tell you whether it's fun. Watch one person play for two minutes before you build anything else.

What stays the same

Commit before every run. Read the whole diff after. Keep a project brief and a memory file. Cut scope ruthlessly. Ship before it's polished. The model got much better; the discipline around it didn't get less necessary.

The mistake is using Fable 5.1 like a faster version of what you had — small tasks, constant check-ins. Its advantage is finishing large things. Give it large things.