Most people using Fable 5 are using it wrong. Not because they lack skill. Because they are treating the most capable model ever shipped like a slightly smarter version of everything that came before it.
Fable 5 is not a better Claude. It is a different category of tool. The prompting habits, the workflow assumptions, the instinct to over-instruct — all of it was built for weaker models, and most of it actively works against you on this one.
This is the full breakdown. What the model is genuinely exceptional at, how to run it as the leader of your own agent team, the three secrets that pull the best results out of it, and the five workflows where it creates measurable output. One note before you start: Fable 5 moved off the Claude subscription on July 7 and is now billed as paid usage. Everything in this guide applies regardless — the setup you build pays for itself in the work it produces.
What This Model Actually Does Differently
Before the methods, understand the machine. Five things Fable 5 does that nothing before it could do reliably.
It never loses the thread.
Give it a job that takes hours and it stays locked on. It has completed 18,000-line code migrations in a single three-hour run with nobody watching. The constraint you set three hours ago is as fresh to it as the one you just typed. Every model before it needed a babysitter for work at that scale. Fable does not.
It sees like a person.
Show it a screenshot and it can rebuild the working page behind it, read exact numbers off a chart, or identify what is broken on your site just by looking. Its computer-use scores are the highest ever recorded. It fixes blurry images on its own before reading them.
It delivers finished work, not answers.
Hand it raw files and it comes back with the actual deliverable. The report. The financial model. The plan. Work that takes a professional analyst days comes back in hours. On independent tests of real professional deliverables, it beats every other model by the widest margin ever measured.
It gets smarter from files.
Give it a folder of notes it can read and write to and it improves faster than any model before it. Your notes become its memory and that memory compounds run after run.
It is built to lead.
It spins up and manages teams of smaller agents more naturally than anything before it. Which is exactly why the setup below works, and exactly where this guide starts.
The Main Move: Run Fable as the Leader, Not the Worker
This is the single biggest upgrade you can make.
Stop typing tasks at Fable like it is a worker. Make it the manager of a team. The smartest model on the market is worth more directing work than doing keystrokes.
The setup has four parts:
Fable makes the plan. Feed it a planning skills collection before any work starts. Matt Pocock’s skills collection at github.com/mattpocock/skills is the standard reference — free planning skills that turn a rough idea into a clear, staged, testable plan before anything gets built.
You iterate with it. Check in on a schedule. Steer the plan when needed. Let it keeplighter models for high-volume parallel work. Each worker owns one lane. Each lane runs in parallel.
Fable reviews. Every finished piece comes back to the leader, gets checked against the original plan, and goes back if it does not pass. The leader does not accept self-reported completion.
You iterate with it. Check in on a schedule. Steer the plan when needed. Let it keep running.
This works because Fable dispatches parallel subagents more readily than any model before it, and it holds the entire workflow in its head for hours. It rarely forgets a constraint, a file, or a decision it made three hours ago. That is exactly what a leader needs and exactly what every model before it could not do consistently.
The economics also work in your favour. The workers are cheaper models, so the expensive brain only spends tokens on planning, checking, and deciding. Operators running this exact setup report their token bill going down, not up.
Build Your Workers
Every worker is one small file in .claude/agents/ inside your project. A name, the model it runs on, and a short job description. That is the entire mechanic. Fable reads the folder and knows who it can delegate to.
Three rules that keep the team fast:
One worker, one lane. Parallel lanes only when the tasks do not touch the same files.
Workers run on Opus, the labour tier. Fable stays in the leader seat where the premium earns itself. Everything a worker claims, a separate verifier confirms. No self-graded homework.
The verifier matters more than any individual worker. Fresh eyes catch what the author cannot, and a checked stage never has to be redone three stages later.
If you run Codex too, it slots in as a second pair of hands. Fable can drive it through the terminal like any other tool. Same rules. Same verifier.
Secret 1: Stop Overguiding It
Everything you learned about prompting was built for weaker models. Step-by-step instructions, long rule lists, detailed scripts — that scaffolding kept older models on track.
On Fable 5 it does the opposite.
Skill files written for older models actively drag its output down. You are constraining a model that plans better than your script does.
Give it three things and get out of the way:
The outcome you want. The constraints that must hold. The reason you need it — “I am preparing this for [who], they need [what], with that in mind: [request].”
That last line matters more than people expect. The reason reliably beats the bare request.
When Fable understands why it is doing something, not just what, the output quality jumps.
Two things to never do, because both break the model:
Never ask it to show or explain its reasoning. That request can trip a safety filter, and your work gets silently handled by a lesser model while you think you are running Fable. Never show it how many token or how much budget it has left. A visible countdown makes it wrap up early and suggest a new session instead of finishing the job.
Secret 2: Keep Your CLAUDE.md Light
CLAUDE.md is the file Fable reads before every task in Claude Code. Its standing memory of your project.
The instinct is to fill it with everything. Resist that. A light file outperforms a heavy one on this model.
Three sections are enough:
What this project is, in two lines. The commands you actually use. The mistakes it keeps making.
Open yours and delete half of it. The shorter file is the upgrade.
Secret 3: Abuse Goals and Loops
This is where Fable stops being a chat interface and becomes a machine that works while you live your life.
Goals — in Claude Code, /goal lets you write one finish line. A small judge model checks after every turn whether that finish line has been crossed. If not, Fable keeps working on its own until it is done.
The craft is writing a finish line it cannot fake. Demand visible proof rather than stated completion. “Run the tests and paste the output, it must pass” is better than “make the tests pass.” Add a brake — “or stop after 20 turns” — because there is no built-in limit, and a loose goal with no brake has billed people $960 on a single prompt. Keep one honesty line in every brief: every progress claim must point to a real result from the run. That single line nearly eliminates fake done reports.
Loops do the same thing on a schedule. Every night. Every hour. Every Monday. A loop that reviews yesterday’s work. A loop that updates your docs. A loop that watches your metrics and drafts the alert. Between goals and loops you can keep Fable working on something for as long as the job needs — hours of unattended work with proof waiting at the end instead of promises.
How to One-Shot a Real Project
Everything above, assembled once, on a real build. The example is a landing page with a working waitlist. Swap in your own project and the sequence holds.
Step 1: The brief. One message. “I’m launching [product] for [audience], they need a landing page that captures emails. Build it: one page, one clear promise, an email form that stores signups, looks premium. Constraints: no frameworks I have to maintain, works on mobile, loads fast. Plan first, then delegate, verify every stage.”
Step 2: The plan. Switch to plan mode with Shift+Tab and let it plan before it touches anything. If you have the Pocock skills collection installed, say “use the planning skills.” The plan comes back staged, scoped, and testable. Read it, cut what you do not want, approve.
Step 3: The team goes to work. Fable dispatches the builder on stage one. The verifier checks it cold. Stage two starts only after a pass. You are not watching any of this.
Step 4: The finish line. Set the goal and walk away. “/goal the page runs locally, the form stores a test signup, proven by pasting the server response and a screenshot of the page on mobile width, or stop after 25 turns.”
Step 5: The morning review. You come back to a run log where every claim has proof attached. Review the screenshots, request the changes you want, ship.
First time through takes an evening. The second time you will realize the sequence is the same for every project you have been postponing.
The Five Workflows Where It Makes Real Money
Now point the whole setup at something worth building.
The giant codebase job. The migration scoped at weeks that nobody volunteers for. The leader runs it in stages. A fresh reviewer checks every stage. Every progress claim ties to a real test result. The weeks-long job lands in days.
Deep research sprints. One goal in. Workers gathering in parallel. A checker attacking every claim. Structured files out. You come back to a dossier where every claim survived an attack, ready to feed a launch, a piece of content, or a market decision.
The orchestrator setup. The leader system from above as a permanent installation. Team-scale output from one seat. The architecture outlives this model — whatever ships next slots into the same seat.
Reference-driven frontend. A folder of screenshots from sites with the aesthetic you want. Real CSS pulled from devtools. Fable building against the references and comparing its output to them in a loop. You supply the taste. It supplies the eyes and the hands.
Knowledge base building. The longest run of all. Point it at everything worth knowing in your field and let it build an interlinked vault. A copywriter does this with the best sales pages ever written. A designer with design systems. An agency with case studies. The vault briefs every future model you ever run, forever.
Each of these was a someday project a month ago. Each one is a this-week project now.
The Whole Setup in One Block
Run Fable as the leader. Pocock skills for the plan, Opus workers for the labour, Fablereviews everything.
Do not overguide. Outcome plus constraints plus reason. Delete the scaffolding.
Keep CLAUDE.md light. What it is, the commands, the known mistakes.
Abuse goals and loops. Finish lines with pasted proof and a written brake on every goal.
Point it at the five workflows. Codebase, research, orchestrator, frontend, knowledge base.
Fable 5 is now billed as paid usage. The setup you build this week keeps producing long after the invoice.
Follow us at @TheAIColony
Join thousands of readers: https://theaicolony.beehiiv.com/
