Anthropic just released the strongest model it has ever built, and the benchmark jump is almost the least interesting part.
Claude Fable 5.1 feels less like a better chatbot and more like a new kind of operator. It can sit with a problem for hours, recover when a plan breaks, coordinate other agents, inspect its own output, and keep moving without needing somebody to rescue it every ten minutes.
The numbers back that up. On Anthropic's published evaluations, Fable 5.1 more than doubled Fable 5 on agentic scientific research, jumped from 17.1% to 31.4% on business automation, and reached 73.4% on CursorBench. It also led Fable 5, Opus 5, and GPT-5.6 Sol across most of the coding, automation, computer-use, and knowledge-work tests Anthropic reported.
https://x.com/claudeai/status/2094848581425377479
Out of the box, it is exceptional at difficult coding, long-horizon work, research, planning, computer use, and producing complete deliverables. But the larger opportunity is what happens when you stop using it as the person doing every task and put it in charge of the system doing the work.
That is what this course covers: where Fable 5.1 is genuinely different, how to put it in the leader seat, how to build the workers beneath it, how to prompt it without suffocating it, how to use goals and loops, and the five workflows where the difference can turn into actual money.
If you do not care about terminals, agent files, and orchestration and simply want to turn an idea into a working app, that is what we built Shipper for.
what this model is actually exceptional at
Before the methods, meet the machine. These are the five abilities that make Fable 5.1 feel different from the models before it.
it stays coherent for absurdly long runs
Give it a job that takes hours and it is much less likely to lose the plot halfway through.
One early tester reported an unattended 38-hour machine-learning run in which Fable diagnosed a bad earlier result, corrected it, launched six experiments in parallel, and returned with the findings and next steps. Another said it kept its own records, reprioritized when conditions changed, and resumed from where it had left off.
The 1-million-token context window helps, but context size is not the real upgrade. The upgrade is that the model can continue making useful decisions inside that context instead of merely remembering that the information exists.
it looks for the root cause, not the fastest patch
Previous agents often found the first fix that made an error disappear. Fable 5.1 is more willing to keep digging until it understands why the error existed.
In Anthropic's launch testing, Millennium gave it a crash that occurred roughly once in a million runs and had remained unexplained for four to five years. Fable 5.1 disassembled an outside library, connected it to the core dump, and traced the crash to the actual bug. Every other model they had tried, including Fable 5, missed it.
This matters far beyond debugging. The same instinct shows up in research, strategy, financial analysis, and operations: do not optimize the symptom when the underlying system is wrong.
it can see, act, and verify
Fable 5.1 can inspect screenshots, charts, PDFs, interfaces, and documents, then use what it sees to guide the next action.
That means it can rebuild an interface from references, read the figures buried inside a financial document, operate a browser, compare its implementation against the original design, and catch visual problems before it claims the work is finished.
Its OSWorld computer-use score rose above both Fable 5 and Opus 5 in Anthropic's testing. More importantly, the model is increasingly able to use vision as part of a verification loop, not just describe the image you gave it.
it returns the work, not a lecture about the work
Give it a folder of documents and ask for an investment memo, a deck, a working prototype, or an analysis, and it is much more likely to return the artifact itself.
Early testers reported Anthropic's best PowerPoint results to date, stronger citation recall over financial documents, more concise contract redlines, and better completion of complicated multi-part requests. A MongoDB engineer described a three-day prototype run where the model researched the existing services, designed the system, implemented it in unattended stages, and returned visual walkthroughs with evidence that each stage worked.
The practical difference is simple: you spend less time converting an answer into usable work.
it was built to lead
Fable 5.1 is most valuable when it is deciding what should happen next.
Claude Code can already give it subagents, background sessions, agent teams, dynamic workflows, goals, loops, browsers, terminals, and project files. Fable has enough planning depth and context to keep those pieces pointed at one finish line for much longer than earlier models could.
That is why the setup below works, and why the course starts by taking Fable out of the worker seat.
the cockpit: every control you actually need
Update Claude Code before doing anything else. According to the current model configuration docs, version 2.1.255 or later makes the fable alias resolve to Fable 5.1, and recent releases include the goal, loop, background-agent, and effort controls used below.
Then select the model and effort level:
/model fable
/effort high
High is the sensible default for substantial work. Drop to medium for cheaper, faster passes. Move to xhigh or max only when the problem is difficult enough to justify more thinking. Fable's adaptive thinking is always on, so effort is the control that matters.
The remaining controls are simple:
/plan or Shift+Tab: let it inspect and plan before changing files
/goal: keep working across turns until a testable condition is met
/loop: rerun a prompt on a schedule while the session remains active
/tasks: see what the background workers are doing
/context: see what is consuming the context window
That is the cockpit.
The rest of the course is knowing which control to reach for, and when.
the main event: make Fable the leader, not the worker
The single largest upgrade is a role change.
Stop giving Fable every keyboard task. Make it define the work, split it into clean lanes, send those lanes to cheaper agents, and judge what comes back.
The setup looks like this:
Fable shapes the plan:
put it in plan mode and let it inspect the project before it proposes changes. If the request is still vague, use Matt Pocock's
skills collection to interrogate the idea, turn the conversation into a spec, and split the spec into tickets.
Fable delegates the isolated work:
implementation goes to Opus or Sonnet subagents, with each worker owning one bounded lane. Codex can be another worker if you already use it, but it should follow the same file boundaries and evidence rules.
A separate agent verifies:
the worker does not grade its own homework. A fresh verifier reads the plan, inspects the diff, runs the checks, and either passes the stage or returns it with a concrete failure.
You steer at checkpoints:
approve the plan, review meaningful tradeoffs, and inspect the evidence at the end. You do not need to watch every command.
Why this works: the expensive model spends its tokens on architecture, prioritization, recovery, and judgment. The cheaper models spend theirs on bounded execution.
The economics only work when the lanes are truly independent. Under Anthropic's current API pricing, Fable 5.1 costs $10 per million input tokens and $50 per million output tokens, while Opus 5 is half that and Sonnet 5 is one fifth. Fable 5.1 also cut cache reads to $0.25 per million tokens, which makes long sessions with a stable project context much more practical.
Do not parallelize for theatre. Five agents editing the same files will create five bills and one merge problem. Parallelize research, isolated modules, tests, documentation, and other lanes that can finish without waiting on one another.
build your workers
The leader needs a small team, and a custom worker is only a Markdown file inside .claude/agents/.
Start with one implementation worker:
name: implementation-worker
description: Implements one isolated stage from an approved plan. Use only when the stage owns distinct files.
model: opus
tools: Read, Grep, Glob, Edit, Write, Bash
maxTurns: 25
You own only the stage assigned to you.
Before editing, identify the exact files and acceptance criteria in your lane.
Do not change files owned by another worker.
Implement the smallest complete solution, then run the relevant tests.
Return:
- files changed
- checks run and their real output
- anything still uncertain
Do not declare success without evidence from this run.
Then create the worker that matters most, the verifier:
name: verifier
description: Independently verifies a completed stage against its plan and acceptance criteria. Use after every implementation stage.
model: opus
tools: Read, Grep, Glob, Bash
maxTurns: 15
Treat the implementation summary as an untrusted claim.
Read the plan and inspect the actual diff. Run the relevant tests yourself.
Check correctness, regressions, scope, and every acceptance criterion.
Return PASS or FAIL.
For every failure, include the evidence and the smallest required correction.
Never modify the implementation you are grading.
Fresh eyes catch what the author normalizes. A stage checked immediately is much cheaper than a defect discovered after four more stages depend on it.
Four rules keep the team fast:
one worker, one lane, with explicit file ownership
parallel work only when the lanes do not depend on one another
Fable stays in the leader seat while Opus or Sonnet handles the labor
every completion claim gets checked against the files, tests, or live result
secret 1: do not prescribe the route
Most prompting advice was written to stop weaker models from wandering.
Long procedures, rigid step lists, and giant rule blocks helped when the model could not plan. With Fable 5.1, that same scaffolding can force it down a worse path than the one it would have found itself.
The trick is to be strict about the destination and loose about the route.
Give it four things:
the outcome:
what must exist when the work is done
the constraints:
what it cannot break, spend, expose, or change
the reason:
who this is for and what decision or job the result must support
the proof:
what observable evidence will count as finished
That last part changes everything. "Make the checkout work" invites a plausible claim. "Complete a test purchase in the sandbox and show the resulting order row" gives the model a finish line it cannot talk its way around.
Do not ask for a performance of hidden chain-of-thought. Ask for the plan, the important decisions, the evidence, and the remaining uncertainty. Fable's thinking is already always on. What matters to you is whether the result survives inspection.
And do not keep reminding it that the budget is disappearing. Put the boundary in the system instead: cap worker turns, define the allowed spend, and tell it what to do when the limit is reached.
secret 2: keep CLAUDE.md light
CLAUDE.md is loaded at the beginning of every Claude Code session. That makes it useful, but it also means every irrelevant line taxes every future task.
Anthropic now recommends keeping each file under 200 lines. In practice, yours can usually be much shorter.
Three sections cover most projects:
what this project is:
the product, architecture, and important boundaries
how to verify work:
the commands for build, test, lint, and local preview
what it repeatedly gets wrong:
project-specific conventions and recurring mistakes
Procedures that only matter sometimes belong in skills. Rules that apply only to certain files belong in path-scoped rules. Historical notes belong in documentation, not in the prompt of every session.
Open your CLAUDE.md tonight and challenge every line: if removing it would not cause a real mistake, remove it.
The lighter file is usually the stronger one.
secret 3: abuse goals and loops
This is where Fable stops being a conversation and becomes a process that can keep moving while you do something else.
Goals: /goal gives the session one testable completion condition. After each turn, a separate small model checks whether the condition is satisfied. If it is not, Fable begins another turn instead of handing control back to you. The goal ends when it passes, becomes impossible, hits an unrecoverable error, or you clear it.
The craft is writing a finish line it cannot fake:
demand observable proof: "all auth tests pass and the output is attached" is stronger than "fix auth"
define the failure path: if a real blocker makes the goal impossible, report the blocker and the evidence instead of inventing progress
cap the risky parts: use maxTurns for workers, spending limits for paid services, and explicit boundaries around deployments or production data
keep one honesty rule in every brief: every progress claim must point to a result produced or inspected during this run
Run goals in auto mode only inside boundaries you are comfortable leaving unattended. A smarter agent has a larger blast radius when the brief is wrong.
Loops: /loop reruns a prompt on an interval. Use /loop 15m check the deployment and investigate any failure for a fixed cadence, or omit the interval and let Claude choose when to check again.
Loops inside Claude Code are session-scoped and eventually expire. Use them for builds, pull requests, migrations, and temporary monitoring. Use a persistent routine or desktop scheduled task for work that needs to survive after the session or machine closes.
Between goals and loops, you can keep Fable working for as long as the job genuinely needs, with evidence waiting at the end instead of another confident paragraph.
how to one-shot a real project
Now assemble the entire system around one build.
The example is a landing page with a working waitlist. Replace the project and the same sequence holds.
step 1, write the brief
Send one message:
I am launching [product] for [audience]. They need a landing page that makes one clear promise and captures
emails.Build one responsive page with a working form that stores signups.Constraints: no framework I have to babysit, no paid dependency, fast on mobile, and no deployment until I approve it.Finished means the page runs locally, a test email appears in storage, the mobile layout is verified at 390px, and the result is shown with test output and screenshots.Inspect the project and plan first. Delegate only independent stages. Verify every completed stage.
The brief gives it a destination without designing the implementation on its behalf.
step 2, approve the plan
Enter plan mode with /plan or Shift+Tab before it changes anything.
If the idea is underspecified, install Matt Pocock's collection with /plugin install mattpocock-skills, run /setup-matt-pocock-skills once, and use /grill-with-docs before turning the result into a spec.
Read the plan. Cut the features you do not need. Make sure every stage has an observable pass condition. Then approve it.
step 3, let the team work
Fable assigns the first isolated stage to the implementation worker. The verifier checks the actual diff and test output. A dependent stage starts only after the earlier one passes.
You can leave the terminal. Use /tasks when you want to see what is still running.
step 4, set the finish line
Use a goal that names the state and the proof:
/goal the page runs locally, the form stores a test signup, and the layout works at 390px, proven by the real test output, the stored record, and a current screenshot. If a genuine blocker makes this impossible, stop and report the evidence instead of claiming success.
That condition is much harder to satisfy with words alone.
step 5, review the result
Come back to the diff, the test output, the stored signup, and the screenshots.
Review the product like a user, not like the model's manager. Ask for the changes you can actually see, run one final independent verification pass, and ship when the evidence matches the brief.
The first run will feel elaborate.
The second time, you will notice that the same sequence works for almost every project you have been postponing.
the five workflows where it makes real money
Now point the setup at work valuable enough to justify the model.
These are the five workflows where Fable 5.1 can create a measurable difference.
The codebase job nobody wants: the migration estimated at three weeks, the rare production failure, the performance problem spread across eight services. Fable maps the system, workers take isolated slices, the verifier checks every stage, and progress is tied to tests rather than optimism.
Decision-grade research: one question goes in, research workers gather from primary sources in parallel, a skeptical reviewer attacks every important claim, and the leader turns what survives into a memo. This can feed an acquisition, a launch, a market decision, or an investment thesis.
Business operations: give it access to the right tools and let it reconcile data, investigate anomalies, prepare reports, monitor a process, or work through an operational backlog. Fable 5.1 nearly doubled Fable 5's score on Anthropic's AutomationBench, which is one of the clearest practical jumps in the release.
Reference-driven product work: give it screenshots of the experience you want, the actual assets, and access to the running app. It can implement against the reference, open the result, compare the two, and continue until the visible gap closes. You supply the taste. It supplies the eyes, hands, and patience.
A compounding knowledge system: point it at everything worth preserving in your company and let it turn scattered documents into a maintained, linked source of truth. A copywriter can build one from great sales pages, an agency from its case studies, and a SaaS company from customer calls, decisions, experiments, and support history. Every future agent starts smarter because the useful context already exists.
Each of these used to be a someday project.
Fable 5.1 makes many of them this-week projects, provided you give the system a real finish line and a way to prove it crossed it.
the whole setup in one block
run Fable 5.1 as the leader: it plans, delegates, reviews, and decides
use Opus or Sonnet for bounded labor, with one worker per independent lane
give it outcome, constraints, reason, and proof, then let it choose the route
keep CLAUDE.md short and move occasional procedures into skills
use goals for verifiable completion and loops for scheduled checks
control cost with effort levels, cheaper workers, cached context, and hard boundaries
point the system at codebases, research, operations, product work, and knowledge that compounds
The model is the most visible part of the setup, but it is not the whole advantage.
The advantage is giving a model this capable a clear destination, a competent team, access to reality, and no way to confuse a convincing answer with finished work.
