How to master Fable 5 (Full Course)

Anthropic not only just released the best model ever built, they introduced us to a whole new world of possibilities…

Fable 5 is a category of its own right now -until GPT 5.6 Sol launches, there’s nothing on this earth capable of beating it

out of the box it’s an insanely powerful model, exceptional at long horizon tasks, manages goals and loops better than anything else, an excellent planner and orchestrator… well, it does it all

but if you know the methods, the tactics and the secrets to use it like the top 1% of engineers, there’s literally nothing you cannot achieve with this thing

people call it dangerous for a reason…

so this is the full course

what the model is truly exceptional at, how to run it as the leader of your own agent team, the secrets that pull the best results out of it, the goals and loops that keep it for hours, and the five workflows where it makes real money

one note: Fable leaves the Claude subscription on july 7 and becomes paid usage after

this week is the cheapest this course will ever be to run

what this model is exceptional at

before the methods, meet the machine… five things Fable does that nothing before it could:

it never loses the thread

give it a job that takes hours and it stays locked on

it once finished an 18,000-line code migration in a single 3-hour run with nobody watching… every earlier model needed a babysitter for work like that

the constraint you set three hours ago is as fresh to it as the one you just typed

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 spot what’s broken on your site just by looking

its computer-use scores are the highest ever recorded, and it even 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 deliverable: the report, the financial model, the plan

work that takes a professional analyst days comes back in hours, and 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 and it improves faster than any model before it

your notes become its memory, and that memory compounds run after run

it’s 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 the course starts

the cockpit: every control you need

sixty seconds of setup, then the controls

update Claude Code first, Fable only shows up in the model picker on recent versions

that’s the whole cockpit

the rest of this course is knowing which control to reach for, and when

the main event: run Fable as the leader, not the worker

the single biggest upgrade is a role change

stop typing tasks at Fable like it’s a worker… make it the manager of a team, because the smartest model on the market is worth more directing work than doing keystrokes

the setup:

Fable makes the plan: feed it Matt Pocock’s skills collection (

github.com/mattpocock/skills

), free planning skills that turn a rough idea into a clear, testable plan before any work starts

Fable delegates: the actual work goes to subagents, Opus and Codex workers, each owning one lane in parallel

Fable reviews: every finished piece comes back to the leader, gets checked against the plan, and goes back if it’s not right

you iterate with it: check in on a schedule, steer the plan, let it keep running

why this works: Fable dispatches parallel subagents more readily than any model before it, and it holds the whole workflow in its head for hours

it rarely forgets a constraint, a file, or a decision it made three hours ago… which is exactly what a leader needs and exactly what every model before it couldn’t do

and the economics work in your favor

the workers are cheaper models, so the expensive brain only spends tokens on planning, checking and deciding… operators running this exact shape report their token bill going down, not up

## build your workers

the leader setup needs a team, and a worker takes two minutes to create

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’s the entire mechanic… Fable reads the folder and knows who it can delegate to

a worker file, complete:

the verifier matters more than any worker

fresh eyes catch what the author can’t, and a checked stage never has to be redone three stages later

three rules that keep the team fast:

one worker, one lane… parallel lanes only when the tasks don’t touch the same files

workers run on Opus, the labor tier… Fable stays in the leader seat where the premium earns itself

everything a worker claims, the verifier confirms… no self-graded homework

and 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: don’t overguide it

everything you learned about prompting was built for weaker models

step-by-step instructions, long rule lists, detailed scripts… that scaffolding kept old models on track, and on Fable it does the opposite

skill files written for older models actively drag its output down, because you’re constraining a model that plans better than the script does

Fable is naturally very good at understanding context, planning for the long run, and remembering what matters

so 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’m 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

and 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 silently gets handled by a lesser model while you think you’re running Fable

never show it how many tokens or how much budget it has left… a visible countdown makes it wrap up early and suggest a new session instead of finishing

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 stuff it… resist that, because 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 tonight and delete half of it

the shorter file is the upgrade

secret 3: abuse loops and goals

this is where Fable stops being a chat and becomes a machine that works while you live your life

goals: in Claude Code, /goal lets you write one finish line, and a small judge model checks after every turn whether it’s crossed… if not, Fable keeps working, on its own, until it’s done

the craft is writing a finish line it can’t fake:

demand visible proof: “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 someone $960 on a single prompt

keep one honesty line in every brief: every progress claim must point to a real result from the run… this alone nearly eliminates fake “done” reports

loops do the same 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 numbers 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

you type 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 (shift+tab) and let it plan before it touches anything

if you installed the pocock skills collection (

github.com/mattpocock/skills

), say “use the planning skills”… the plan comes back staged, scoped and testable

read it, cut what you don’t 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’re 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’ll realize the sequence is the same for every project you’ve been postponing… which is exactly what the next chapter is about

the five workflows where it makes real money

now point the whole setup at something worth building

these five are where Fable makes a difference you can measure:

he 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 the top of this article as a permanent installation

team-scale output from one seat, and the architecture outlives this model… whatever ships next slots into the same seat

reference-driven frontend: a folder of screenshots from sites with the taste 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 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 out of it

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 and Codex workers for the labor, Fable reviews everything

don’t overguide: outcome + constraints + 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

point it at the five workflows: codebase, research, orchestrator, frontend, knowledge base

Fable leaves the subscription july 7… the setup you build this week keeps paying long after that

research and write by: https://x.com/EXM7777

I’m an Python developer building AI systems in public. Follow me on LinkedIn for daily AI build breakdowns.