fakenerd.ai

ninja nerdingDavid Ondrej's Fable 5.2 workflow

David Ondrej's Fable 5.2 workflow

David Ondrej spent three days and over $1,000 of usage on Anthropic's biggest model, then had it analyse his 1,631 prompts. What came out is a way of choosing models: the big model figures it out, the fast model does it, and a model from another company checks it.

Jump to the map, what goes where, or try it yourself.

The video

31 minutes, posted Nov 12, 2026, by David Ondrej. Model names and numbers are as of that week and will date fast. The video has no chapters, so these are ours. Every timestamp opens the video at that moment.

  1. 0:01 Three days, 1,631 prompts, $1,000+ on Fable 5.2
  2. 0:47 He's hiring (until 1:00)
  3. 1:06 His plans: four Claude, one Codex, one Cursor
  4. 1:40 The benchmarks, briefly
  5. 2:30 Six patterns from his own prompts
  6. 7:05 Which reasoning effort to use
  7. 9:25 His paid community, New Society (until 9:45)
  8. 9:50 Bigger models can cost less per task
  9. 11:50 Gemini 4 Carbon, the reviewer
  10. 12:56 /gemini-review, live
  11. 13:40 His app, Cloudroom (until 14:45)
  12. 16:20 Why a different company should review
  13. 18:10 Does he still use Opus 5.5? Yes
  14. 19:20 Fable plans, ten Opus subagents do the work
  15. 20:35 Where Fable stands out
  16. 22:10 Big model smell
  17. 23:00 The Fable to Opus switch
  18. 24:10 “This is your codebase”
  19. 25:00 Is OpenAI falling behind?
  20. 25:30 Which subscription to get
  21. 26:57 Loops still run on Opus
  22. 29:30 Not sure? Use Opus
  23. 29:55 New Society again (to the end)

Twelve signals

The whole video in twelve boxes. Each links to the part of this page that explains it.

  1. 015:23

    Big model to figure it out, fast model to do it

    When he doesn't know what he wants yet, or the problem is hard, he uses Fable 5.2. When the job is clear, he uses Opus 5.5. It's quicker, and it doesn't burn through his plan.

    How
  2. 025:10

    Pick the model when the thread starts

    Of his 185 threads, 103 used only Fable and 72 used only Opus. Only 10 mixed the two. He decides once, at the start.

    How
  3. 0323:00

    Switch once it's clear

    His newest habit: give Fable the first two or three messages, then switch the same thread to Opus to finish. He admits his own data shows only six switches so far.

    How
  4. 0419:20

    The big model manages, small ones do

    Fable plans and starts ten Opus 5.5 helpers, one per part of the code. Using Fable for everything wastes both tokens and time.

    How
  5. 0512:56

    A different company checks the work

    After a medium or large change he types run /gemini-review. Gemini 4 Carbon, made by Google, reads what Claude wrote. Small changes go straight live.

    How
  6. 0611:17

    Price per task, not per token

    Fable costs twice as much per token. On one coding test, though, Fable at high scored the same as Opus at max for about half the cost per task, because it took fewer steps.

    How
  7. 074:40

    Set effort on the dial, not in the prompt

    “Do not overthink this” no longer works on Fable 5.2. Anthropic's guide says to delete the line and lower the effort instead. His default for Fable is high.

    How
  8. 082:42

    Limits are the real cost

    53 failed Fable turns against 2 on Opus in three days, which he blames on usage limits. His Fable share fell from 88% to 61% to 26% of prompts. He runs four Claude plans.

    How
  9. 093:49

    Type it twice, save it

    34% of his prompts are 31 saved snippets. Commit and push alone was 123 of them. Bigger repeated jobs become skills.

    How
  10. 1024:10

    Tell it the code is its own

    Anthropic found that Fable acts like a guest in your repo unless you say the code is its own. He adds “this is your codebase” for code and “you are my co-founder” for business questions.

    How
  11. 1126:57

    Loops stay on the fast model

    72% of his loop runs use Opus 5.5 and only 3% use Fable. A third of runs find nothing to do, and an all-clear on Fable costs twice as much.

    How
  12. 1229:30

    Not sure? Use Opus

    His closing rule, and Anthropic's own advice: start on Opus 5.5 and step up to Fable only for the 10 to 20% of work that needs all of it.

    How

Words on this page

22 terms, in plain words. Skip this if you already switch models every day.

Model
The AI brain itself: Fable 5.2, Opus 5.5, Gemini 4 Carbon. Same app, different brain.
Big model, fast model
A big model knows more and works things out better, but it's slower and uses up your plan faster. A fast model is quick and cheap, and fine for clear work.
Big model smell
The sense that a bigger model has sparks of judgement a smaller one lacks, even when the test scores are close. You notice it on vague or very hard problems.
Harness
The app that runs a model and lets it read files and run commands, such as Claude Code, Codex or Cursor's CLI. One model can run in several harnesses.
Thread
One conversation with an agent, from the first message to done.
Subagent
A helper agent that another agent starts and waits on. The agent that starts it is its parent.
Orchestrator
The agent that plans the work and hands it out to subagents instead of doing it all itself.
Reasoning effort
How hard the model thinks before it answers: low, medium, high, extra high (xhigh) or max. Higher is smarter and slower, and uses more of your plan.
Usage limit
How much a subscription lets you use before you have to wait. Claude plans reset every five hours and every week, and Fable has a limit of its own.
Subscription vs API price
A subscription is a flat monthly fee. API pricing charges for every token. He says a $200 Claude plan gives $1,000+ of use measured at API prices.
Token
A chunk of text, about three quarters of a word. Models are priced and limited in tokens.
Cost per task
What one finished job costs in total. A model that's pricier per token but takes fewer steps can cost less per task.
Benchmark
A fixed test that gives a model a score, so models can be compared.
Artificial Analysis
An independent site that runs the same tests on many models and ranks them on one combined index.
Review model
A second model that reads the first one's changes and reports problems. He wants it to come from a different company.
Snippet
A saved piece of text you paste by typing a short keyword. He keeps his in Raycast.
Skill
A saved instruction file (SKILL.md) that an agent loads by name, for a bigger repeated job like a review.
Loop
An agent job that runs on its own on a timer, like a security check every five minutes.
Script gate
Plain code that runs first in a loop, with no AI. A model starts only if the script finds a problem.
Push to prod
Put the change live for real users. Prod is short for production.
Cloud agent
An agent that runs on a computer in the cloud instead of your laptop, so dozens can run at once.
ACP
Agent Client Protocol, a standard way for one app to drive another coding agent. His review skill reaches Cursor's CLI through it.

What it is and what it does

It's model routing: choosing which AI model gets which job, instead of using one for everything. The models will change. The question stays the same: how clear is this job, and how much is a mistake worth?

Big model

Figures it out

Vague ideas, hard technical problems, decisions that cost weeks if wrong. Slow and limited, so you use it for the start of the job.

Fast model

Does it

Anything clear: the build, the bug ticket, the release, the loops. Most of the day happens here.

Other company's model

Checks it

Reads the changes after a medium or large job and reports what's wrong. Trained by different people, so it misses different things.

Three everyday examples

  1. 1A clear bug

    The Save button doesn't save. You know what's wrong and roughly where it is.

    Route: Fast model, then straight live. No review for a small fix.

  2. 2A business question you can't answer yet

    How should you price the new plan? You have opinions but no answer.

    Route: Big model, with “you are my co-founder” in the prompt.

  3. 3The fiftieth “make that shorter”

    You keep typing the same follow-up after every long answer.

    Route: A snippet. Type two letters and the whole line appears.

Three bigger ones

  1. 1The app feels slow and nobody knows why

    Too big for one agent, and unclear where to look.

    Route: The big model maps the code and starts ten fast helpers, one per area.

  2. 2A day of changes before a release

    Eighty commits landed across 700 files. Some of it you didn't read.

    Route: A review by a model from another company, on everything since yesterday.

  3. 3Something to watch around the clock

    Production health, new security alerts in your packages, open pull requests.

    Route: A loop: a script checks first, and the fast model starts only when something trips.

Everything named

Three models do almost all the work: Fable 5.2, Opus 5.5 and Gemini 4 Carbon. The rest are the apps that run them. Prices are per million tokens, input and output, as shown on his slides.

Models

  • The big modelAnthropic

    Claude Fable 5.2

    Top of the Artificial Analysis index at 65 when he recorded. Slow: 10 to 40 minute turns are normal, and his longest ran 56 minutes. $8 in and $40 out per million tokens.

    In: rewrites, audits, redesigns, cost cuts, infrastructure calls, fuzzy plans, hiring and strategy. Out: anything clear, loops, all-clear checks.

    1:40 Site

  • The daily driverAnthropic

    Claude Opus 5.5

    Third on the index at 59, and much faster. He calls it the best deal in the world on a $200 Claude plan. $4 in and $20 out per million tokens. Most of his runs are at extra high.

    In: clear builds, releases, bug tickets, security sweeps, health alerts, 72% of his loops, every subagent Fable starts. Out: the hardest open questions.

    18:10 Site

  • The reviewerGoogle

    Gemini 4 Carbon

    Second on the index at 60. It reads lots of files and writes long reports, and ignores “be concise”. For a reviewer he likes that. $2 in and $10 out until Nov 30, 2026, then $4 and $20.

    In: reviewing what Claude built, at high effort. Out: building. He doesn't use it as his main model and doesn't buy Google's plan for it.

    11:50 Site

  • Smaller helperAnthropic

    Claude Sonnet 5.5

    A step down from Opus. Runs 8% of his loops, including his security sweep and daily supply-chain check.

    In: cheap loop work, subagents when limits are tight. Out: planning.

    20:29

  • OpenAI's pairOpenAI

    GPT-6.1 Sol and GPT-6 Astra

    Astra was his top model for three weeks in September, and his reviewer through /gpt-review, his seventh most-used skill. Sol runs 17% of his loops, mostly at max effort.

    In: some loops, the old review route. Out: he now prefers Gemini for review, because GPT and Claude “think alike”.

    8:15

  • Extra reviewersMoonshot AI · Meta

    Kimi K3.1 Pro and Muse Wonder

    In his effort table and his review skills. Kimi runs a nightly fuzz-and-fix loop and 1% of his loop runs. Muse Wonder is one of five reviewers in /total-review.

    In: second opinions, some loops. Out: daily building.

    9:00

Apps and harnesses

  • Main harnessAnthropic

    Claude Code

    Where he runs Fable and Opus, on four $200 plans. He says Claude's plans give far more use than tools that pay Anthropic the API price, like Cursor, Droid or Devin.

    In: nearly all building. Out: the Gemini reviewer, which needs a different harness.

    1:06 Site

  • Route to GeminiAnysphere

    Cursor and its CLI

    His backup when Claude limits run out, and the way he reaches Gemini 4 Carbon. A Cursor plan ($30, $100 or $200) includes Gemini, billed at API price against the plan.

    In: the Gemini review as a subagent. Out: main driver, because the usage is at API price.

    15:06 Site

  • OpenAI's harnessOpenAI

    Codex

    One $200 plan. Runs the GPT models for his loops and the old GPT review.

    In: GPT work. Out: not part of the Fable story.

    1:06 Site

  • Saved promptsRaycast

    Raycast snippets

    A Mac launcher with text snippets: type a short keyword and the saved prompt appears in any app. He has 31.

    In: any prompt you type more than twice. Out: long multi-step jobs, which belong in a skill.

    3:49 Site

  • The scoreboardIndependent

    Artificial Analysis

    His source for the model ranking, the effort chart, time per task and cost per task.

    In: comparing models and effort levels. Out: your own tasks, which only your own tests can measure.

    11:50 Site

  • His own appCloudroom, his company

    Cloudroom

    A free, open-source app for running many agents at once, local or in the cloud, with any harness. It switches models mid-thread, nests subagents and runs his 35 loops. Every number on this page comes from its analytics.

    One option among several. Everything on this page also works in Claude Code with Cursor's CLI, or in bb.

    13:40 Site

Also named, not part of the setup

  • New SocietyHis paid Skool community, $37 a month. He says his snippets, skills and data there update automatically.9:25
  • Droid, DevinOther coding tools he says get less usage per dollar, because they pay API prices.1:06
  • Google AI UltraGoogle's own plan. He says it's fine but the subsidy is nowhere near Claude's.26:26
  • Epoch AIA second ranking shown on screen: Fable 173, Carbon 170, Astra and Opus 169.25:00

The map

Eight steps for one job, plus three habits that run all the time. Darker boxes are decisions you make. Click any box to read it, or press Start and follow one job through.

One job, start to live · darker boxes are yours

Clear jobs skip from 01 to 05. Small changes skip from 06 to 08.

All the time, beside every job

Follow one job: the app feels slow

Seven beats, built on the job he runs on camera: ten Opus helpers hunting for speed. Watch which boxes light up, and which ones get skipped.

One job · step 1 of 8 · You

Watch at 5:23

Is it clear?

Before you type, ask one question: do I know what I want and how to get it? If yes, pick the fast model. If you need to figure things out, or it's deeply technical, pick the big one.

Why: He picks per thread, not per message. 103 of his threads were Fable only, 72 were Opus only, and just 10 used both.

What you see

The model picker in the message box, set before you send.

Watch out

Defaulting to the biggest model for everything. It's slower and eats limits on work Opus would finish in five minutes.

He never draws these steps as a row. They come from what he says and shows across the video, and the order is ours.

What goes where

Pick a kind of task. The examples marked “his real thread title” are read off his slide. Effort is his most-used setting for that model, not a per-task rule he gives. 6:05

A rewrite

Fable 5.2

effort: high

Lots of moving parts and decisions before any code.

his real thread titleaura plugin rewrite plan

Anthropic says the same

Read on screen from Anthropic's launch post: “For most coding and knowledge tasks, we recommend that users start with Claude Opus 5.5, our strongest daily driver, and then switch to a different model as required.” It also names Fable as an “Orchestrator (where it delegates simpler tasks to smaller models)”. 29:30

Review skills

Five skills from his public repo (MIT), the ones about models. The descriptions are summaries of each SKILL.md, read on Nov 12, 2026. The repo is a cleaned-up copy of his private one and changes often.

  1. /gemini-review

    12:56 SKILL.md

    Starts an independent code review on Gemini 4 Carbon, at high effort, through Cursor's CLI. It returns the reviewer's report word for word.

    When

    After a medium or large change, or one in code you don't know well. Not for small fixes.

    What you type

    run /gemini-review on the changes we've made in the last 24 hours

    What it does, in order

    1. Checks that Gemini 4 Carbon is on offer at high through Cursor, and never switches to another model or route.
    2. Writes a neutral brief: scope, paths, intended behaviour, base and head commits. It doesn't hint at suspected bugs.
    3. Asks for a senior-developer review: serious issues, fixes, merge readiness, verified versus unsure, and gaps it couldn't test.
    4. Adds the rating sentence: 1 to 10 for how often, 1 to 10 for how bad.
    5. Waits until the review has really finished, retries once if it dies, and returns it word for word with the route used.

    Watch out: Built on Cloudroom's room-cli. Outside Cloudroom, use the Cursor CLI version under Prompts. It bills your Cursor plan at API prices.

  2. /gpt-review

    16:00 SKILL.md

    The same review on GPT-6 Astra through Codex, at extra high on the fast tier.

    When

    His reviewer before Gemini. Still his seventh most-used skill over 90 days.

    What you type

    run /gpt-review

    What it does, in order

    1. Checks that Codex offers GPT-6 Astra at xhigh, and stops if not.
    2. Same neutral brief and rating sentence as gemini-review.
    3. Confirms the thread really runs that model, effort and tier.
    4. Returns the finished report word for word.

    Watch out: He now prefers Gemini for reviewing Claude's work, because he thinks GPT and Claude think alike.

  3. /fable-review

    SKILL.md

    A review by Fable 5.2 at high, through Claude Code. Useful when the code was built by a non-Claude model.

    When

    When you want the strongest reviewer and have Fable limit to spare.

    What you type

    run /fable-review

    What it does, in order

    1. Writes the brief to a file and starts exactly one review thread, never a test one.
    2. Uses model claude-fable-5-2 with effort high as a separate setting.
    3. Waits for Cloudroom to report the child finished, without polling.
    4. Returns the report word for word.

    Watch out: Spends Fable limit. Don't review Fable's own work with Fable if you can avoid it.

  4. /total-review

    SKILL.md

    Five reviewers at once, each at max effort: Fable 5.1, Opus 5.5, GPT-6 Astra, GPT-6.1 Sol and Muse Wonder. Merges their findings and fixes only what you approve.

    When

    Before something risky ships, when a single reviewer isn't enough.

    What you type

    run /total-review

    What it does, in order

    1. Starts five threads in parallel, all with the same neutral brief, none told about the others.
    2. Waits for all five, then deduplicates and drops style nits and theory.
    3. Shows one line per issue, tagged with who found it, most-reported first.
    4. Fixes and ships only after you approve the list.

    Watch out: Runs with full permissions and max effort on five models. Expensive. Agreement between reviewers doesn't prove an issue is real.

  5. /stop-overthinking

    4:40 SKILL.md

    Tells the agent to stop deliberating: point out critical issues, otherwise say it's fine to proceed and give next steps, briefly.

    When

    He used it a lot on Opus, and it's his 13th most-used skill. On Fable 5.2 a line like this no longer stops the thinking.

    What you type

    /stop-overthinking

    What it does, in order

    1. Stop overthinking and be practical.
    2. Name any critical or serious issues. Otherwise say we're good to proceed.
    3. Give next steps in short, plain English, like a practical entrepreneur.

    Watch out: On Fable, lower the effort to medium instead. The skill still shapes the answer's length and tone, which effort doesn't.

Why another company · his argument

All seven of Anthropic's co-founders came from OpenAI, so he reasons that GPT and Claude share habits and blind spots. Gemini's leaders all grew up inside Google. A reviewer that thinks differently finds different bugs. 16:20

What backs it · on screen, not said

A note on his board: on a real repo with 105 bugs, Fable found 58 for $140 and Gemini 4 Carbon found 57.3 for $31. No source is given for the test. The founders argument is his own reasoning, not a study. 11:52

Prompts

Three prompts he uses on camera, each as typed, with a fill-in version. “As typed” is read off the screen. Fill-ins and starters are FakeNerd's.

1. The big model manages19:30

Sent from Fable 5.2 at medium, though he says “high” aloud. Each child came up on Opus 5.5 at high. The “don't overthink it” line is his. On Fable it does nothing, which the effort section explains.

His prompt · as typed

Start 10 Opus 5.5 sub-agents below you, each one in the Claude Code harness, and have them analyze different parts of the code base for speed improvements and optimizations in terms of latency and speed. Don't overthink it, just launch them now. 10 different sub-agents below you, Opus 5.5, high as the model for each of them.

FakeNerd fill-in · any orchestrator

You are the orchestrator for this job. Don't do the work yourself.

Goal: [what you want, e.g. find why the app is slow and fix the worst 5 causes]

1. Look at the codebase and split it into [N] parts that don't overlap.
2. Start one subagent per part, each on [fast model] at [effort].
   Tell each one: its part, the goal, what "done" looks like,
   and to report back in under 15 lines.
3. Check that each subagent is running the model you asked for.
4. When they're done, merge their reports into one list,
   ranked by impact, and tell me which fixes to make first.

2. Another company reviews12:56

He switches the thread from Fable to Opus 5.5 before sending, to save Fable limit. The skill does the rest. The rating line in the fill-in is copied from his skill files.

His prompt · as typed

run /gemini-review
On the changes we've made in the last 24 hours.

FakeNerd starter · Cursor CLI, no Cloudroom

# FakeNerd starter: the same idea without Cloudroom.
# Run in your own terminal, in the repo. Needs Cursor's CLI and a Cursor plan.
git diff HEAD~10 > /tmp/review.diff
cursor-agent -p --model gemini-4-carbon "Review the diff in /tmp/review.diff for serious bugs, \
regressions and security issues. Review only, change nothing. For each issue give file, line, \
a concrete scenario and a fix. During your final answer, Rate each issue you find from 1 to 10 \
on how often it would happen, and 1-10 on how bad it would be. End with: safe to merge, yes or no."

FakeNerd fill-in · any harness with subagents

Start a reviewer subagent on a model from a different company than the one that wrote this code ([e.g. Gemini 4 Carbon], effort high).

Give it neutral context only: the scope ([the last 24 hours on main / this branch]), the base and head commits, and what the change is meant to do. Don't tell it what you suspect.

Ask it to review only, not edit. It should report serious or critical issues with file and line, a fix for each, and whether this is safe to merge. It should mark what it verified versus what it's unsure of.

Include this sentence word for word: "During your final answer, Rate each issue you find from 1 to 10 on how often it would happen, and 1-10 on how bad it would be"

Wait until the review has actually finished. Then show me its full report.

The Cursor CLI starter uses the model name from his skill file, gemini-4-carbon. Run cursor-agent models to check what your plan calls it.

3. Tell it whose code it is24:10

Without the sentence

Fable treats the code as someone else's. It adds to what's there, even if that repeats code, and reports nearby problems instead of fixing them. It merged repeated code in under 1 in 10 tries in Anthropic's tests.

With it

It cleans up as it goes and fixes related things unasked. The rate was about half on his slide and about 75% in Anthropic's current guide. It also wrote more and made changes nobody asked for, so review the diff.

His line · as said

By the way, this is your codebase and you are my co-founder.

Anthropic's sentence · current guide

You are the owner and long-term maintainer of this codebase, and its design is up to you.

FakeNerd fill-in

[Your question, e.g. give me four different designs for how to solve this, and pick one.]

This is your codebase: how it's built is your call, and you'll keep building on it.
You are my co-founder. Tell me what you'd actually do, not the safe answer.

“This is your codebase” is for code. “You are my co-founder” is for business questions like pricing and product, and it's his own tip: Anthropic's guide doesn't mention it. The video shows an older wording of Anthropic's sentence. The one above is from the live guide on Nov 12, 2026. Leave both out when you want the smallest possible change.

Snippets: 34% of his prompts

His six most-repeated prompts over three days, read off his slide, with the keyword where one is shown. His median prompt is 95 characters. 3:49

  • stage ALL files in this project, write a clear git commit, and push to github, to the 'main' branch.key: stge (blurry)123×
  • rewrite your last message to be more concise & clearkey: hh68×
  • run /self-archive59×
  • now get to work and execute this plan, like 10x engineer would, in a simple, modular and efficient way.key: pp52×
  • give /state39×
  • run /rename36×

His rebase snippet · as typed, shown at 4:12

rebase off of 'main' branch, and check the underlying code again to see if this has been fixed, or not yet
answer in short, in plain english

FakeNerd starter · five snippets to save

;;short   rewrite your last message to be shorter and clearer. plain words.
;;go      the plan is clear. now build it, in a simple, modular way. test what you change.
;;ship    stage all files, write a clear commit message, and push to the main branch.
;;check   rebase on main, then check whether this is fixed yet. answer in two lines, plain english.
;;own     this is your codebase. you are my co-founder. what would you do?

Keywords come from a blurry card at the end of the video, so treat them as examples. His usage card says 31 snippets, while his community card says 18. When something gets too long for a snippet, it becomes a skill.

Effort: set it on the dial, not in the prompt

Five settings: low, medium, high, extra high, max. His share of each, per model, from his own chats and the chats his agents start, Sep 30 to Nov 11. He never used low, so it's left out. 8:15

His effort level share per model
Modelmediumhighxhighmax
Opus 5.51%21%46%31%
Fable 5.21%63%34%2%
GPT-6.1 Sol5%11%10%74%
GPT-6 Astra6%5%59%30%
Kimi K3.1 Pro–26%–74%
Muse Wonder–73%–27%
Gemini 4 Carbon22%78%––

The pattern: fast models (Opus, Sol) run high settings, because extra thinking costs them little time. Big models (Fable, Astra) run lower, because each step is already slow. Gemini 4 Carbon has no setting above high.

His rules for Fable 5.2 7:05

  • highThe default for Fable. Use it if you don't know what to pick. Anthropic says the same.
  • mediumIf you're short on limits and still want Fable. The drop from high is real: Opus at xhigh beats it.
  • xhighHard, long jobs. On his chart it barely beats high and costs more.
  • maxOnly deep investigations that are worth a lot to you, when you have limit to spare.
  • lowAvoid on Fable. At that point use Opus 5.5 at high or xhigh.

Why “do not overthink this” stopped working 4:40

He had the line in 128 prompts. Anthropic's guide, as shown on his slide and still in the live guide:

“On Claude Fable 5.2, this addition doesn't stop the model from thinking at medium and above. Remove such lines and lower the effort level.”

The captions say “doesn't help”. The screen and the guide say “doesn't stop”. His slide also points to the guide's “Finish the whole task” prompt for when Fable stops early at lower effort.

Cost per task, not price per token

Fable costs twice as much per token as Opus. On some jobs it still costs less, because a smarter model takes fewer steps. 9:50

His analogy

Hire Jensen Huang for a week and you might get a billion-dollar company. Hire an average person for decades and you never will. The expensive hire is cheaper per result. 10:00

The chart he uses · FrontierCode 2.0

Fable 5.2 at high scored 45.3%, against Opus 5.5's best of 45.5% at max, for roughly half the cost per task: about $6 against about $12 by his reading. That's Anthropic's own chart. 11:17

The other side · also on his screen

  • Slower per stepIn his own data Fable takes 16.5 seconds a step against Opus's 11.8, about 40% slower.
  • Slowest on the indexArtificial Analysis times Fable at 46.7 minutes per task, the slowest model listed. Opus is 25.2.
  • Priciest on the indexAcross that index's tasks, Fable at max averages $26.54 per task, the highest shown.

So “sometimes cheaper” is right, and it depends on the task, as he says. On a hard task a big model can win on cost. On easy ones it's just slower and pricier. That's the case for the router.

Limits and plans

Usage limits, not price, decide how much Fable he can use. His slide says a $200 Claude plan gives $1,000+ of usage at API prices, while tools that pay Anthropic the API price give about $200 to $400. 1:06

His plans

  • Claude (Claude Code)4 × $200 / moTwo were enough on Opus. Fable needs four, maybe five or six.
  • Codex (ChatGPT)1 × $200 / moSaid aloud; not shown on screen.
  • Cursor1 × $200 / moSaid aloud. His route to Gemini, at API price.

Fable's share of his prompts, by day 2:42

  • Nov 1088%
  • Nov 1161%
  • Nov 1226%

The rest went to Opus 5.5. In the same three days, 53 Fable turns failed against 2 on Opus. The errors he could read were all limit messages. He says 35 to 40% would be ideal, if he had a fifth plan.

Which plan to get · his advice 25:30

  1. Everyone needs at least one Claude plan. Even with no money, he says, buy the $20 one.
  2. Get the $200 plan if you can. It's the biggest multiple of value for the price.
  3. Need more? Buy more plans, not API credit. Avoid API prices at all costs.
  4. Already paying for Cursor? Use what's left on it for Gemini reviews.
  5. Google AI Ultra is fine, but not nearly as subsidised as Claude.
  6. Self-hosting a small model is fine if you do it on purpose for privacy. Otherwise, use the best model you can.

Loops stay on the fast model

He has 35 loops running, 1,432 runs a day, 82% finished with no human. Since Fable launched, almost none of them use it. 26:57

Which model runs his loops · Nov 9 to 12

  • Opus 5.572%
  • GPT-6.1 Sol17%
  • Sonnet 5.58%
  • Fable 5.23%
  • Kimi K3.1 Pro1%

What each loop run did · Oct 26 to Nov 12

  • Found nothing37%
  • Acted34%
  • Needs him15%
  • Failed7%
  • No report7%

An all-clear on Fable costs twice what it costs on Opus, and a third of runs are all-clears. So the cheapest loop doesn't start a model at all: 63% of his script checks stop before any agent starts. Loops are for things you already know how to check, like reviews, bugs and security. He says loops that build new features just ship slop.

Five of his loops, read off the screen

  • CVE watchOpus 5.5 · xhighevery 5 min
  • PR review (three teammates' pull requests)Opus 5.5 · highevery 15 min
  • System health watchScript, then an agentevery 10 min
  • Security sweepSonnet 5.5 · mediumevery 3 hours
  • Supply-chain securitySonnet 5.5 · lowdaily

His script gate · top of the file, as shown at 27:30

#!/usr/bin/env python3
"""System health gate: the Local loop "system health watch" runs this
every 10 minutes, with no AI.
It reads production, applies the red-flag rules in rules(), and prints
nothing while all is fine, so no agent starts. When a rule trips it
starts one alert thread with the numbers, and updates that thread while
the incident lasts. Once a morning, if nothing is flagged, it starts a
summary thread, so silence is never a broken watch. Read only.

  watch.py              the loop's run
  watch.py --dry-run    print what it would send; start nothing, save nothing
"""

FakeNerd starter · a script gate in bash

#!/usr/bin/env bash
# FakeNerd starter: a script gate for a loop. Runs with no AI.
# Exit quietly when all is fine; start an agent only when a check trips.
set -euo pipefail

URL="https://your-app.example/health"     # your health endpoint
MAX_MS=800                                  # slower than this = a problem

read -r code secs < <(curl -s -o /dev/null -w "%{http_code} %{time_total}\n" --max-time 10 "$URL" || echo "000 10")
ms=$(awk -v s="$secs" 'BEGIN { printf "%d", s * 1000 }')

if [[ "$code" == "200" && "$ms" -lt "$MAX_MS" ]]; then
  exit 0   # all clear: no agent, no tokens
fi

# Something tripped: hand the numbers to the fast model.
claude -p --model claude-opus-5-5 \
  "Health check failed: HTTP $code in ${ms}ms on $URL. Find the cause, read only. \
Report what broke, since when, and the smallest safe fix. Do not change anything."

Run the starter from cron, a Cloudroom loop or bb every 10 minutes. It needs Claude Code installed for the claude -p line. More on how he builds loops: Ondrej's mini software factory.

Try it, smallest version first

Seven steps, cheapest first. Steps 1 to 4 work with one plan and the agent you already use. Works in Claude Code, Codex, Cloudroom or bb.

  1. 01

    Save your three most-typed prompts

    Open your last week of chats and find the lines you keep typing. Save each one as a snippet with a two-letter keyword. Raycast does it on a Mac. macOS text replacements or any text expander work too.

    Raycast snippets
  2. 02

    Delete “don't overthink” from your prompts and skills

    Search your snippets, CLAUDE.md, AGENTS.md and skills for lines that tell the model to think less. Remove them. Set effort with the dial instead: high by default, medium when you're short on limits.

    grep -rniE "overthink|without deliberating|think less" ~/.claude ./AGENTS.md ./CLAUDE.md 2>/dev/null
  3. 03

    Pick the model before the first message

    One question: is this clear? Clear goes to your fast model, unclear or high-stakes goes to your big one. Use the picker on this page until it's a habit.

    What goes where
  4. 04

    Try the switch once

    Start one fuzzy task on the big model. After two or three messages, when there's a plan, switch the same thread to the fast model and say “now build it”. In Claude Code that's /model. Cloudroom and bb have a picker in the message box.

    /model
  5. 05

    Add a reviewer from another company

    Install his review skills, or run a one-off review through Cursor's CLI with the starter under Prompts. Use it on your next medium-sized change and see what it finds that your main model missed.

    npx skills add davidondrej/skills --skill gemini-review -a claude-code
    gemini-review SKILL.md
  6. 06

    Let the big model manage once

    On a job that splits cleanly, give the big model the orchestrator prompt. Check each helper runs the fast model you named.

    The prompt
  7. 07

    Put one loop behind a script

    Pick a check you do by hand, such as is the site up. Write it as a script that exits quietly when all is fine and starts the fast model only when it isn't. Run it on a timer: cron, Cloudroom loops, or bb.

    The script gate

FakeNerd starter · paste into your agent

I want to work the way David Ondrej does with big and fast models. Set this up with me, one step at a time:

1. Look at my recent prompts (or ask me for 10) and find the 3 I repeat most. Suggest a short keyword for each.
2. Search my CLAUDE.md, AGENTS.md and skills for lines like "don't overthink" or "answer without deliberating". List them so I can delete them.
3. Write me a one-screen rule card: which tasks go to [big model], which to [fast model], and which get reviewed by [a model from another company].
4. Draft a review skill: neutral brief, review only, serious issues with file and line, merge verdict, and each issue rated 1-10 on how often and how bad.

Ask before you change any file.

Next to the others

Other pages on this site that sit next to this one.

FakeNerd's take

The routing rule is the keeper

Unclear goes to the big model, clear goes to the fast one, and a different company checks the big changes. It fits on a sticky note and outlives every model name on this page.

His numbers are one heavy user's three days

Four $200 plans and 1,631 prompts. His Fable share fell to 26% because of limits, not choice. He even says his own data shows only six switches, against his switch advice. Copy the reasoning, not the percentages.

The review idea is sound, the demo isn't proof

A second model from another lab is a cheap check worth trying. But “same founders, same habits” is his hunch, and the review he started on camera was cut off before it reported.

It's also a Cloudroom showcase

Every chart is Cloudroom data and every demo runs in his app. Nothing here needs it: Claude Code's /model, Cursor's CLI, a text expander and cron cover the whole workflow.

Attribution

  • David Ondrej, “My $1,000 Fable 5.2 Workflow (just copy me)” (posted Nov 12, 2026). The workflow, the advice and every usage number are his, from his own Cloudroom data, in our words. Numbers, prompts, thread titles, loop names and quotes are read off the screen. Where the captions disagreed with the screen, the screen won.
  • Disclosures, from the video: Cloudroom is his company, and every demo and data card comes from it. New Society is his paid community ($37 a month). The video opens with a hiring ad for his team. No outside sponsor.
  • Skill summaries are from davidondrej/skills (MIT), read on Nov 12, 2026.
  • Quotes from Anthropic's “Prompting Claude Fable 5.2” are from the live page on Nov 12, 2026. Benchmark charts on his screen are Anthropic's, Google DeepMind's and Artificial Analysis's, as he shows them. Nobody has checked his own numbers.
  • The eight-step map, the seven-beat walkthrough, the picker wording, every fill-in and starter (the orchestrator and review prompts, the Cursor CLI review, the snippet set, the bash script gate, the setup prompt), the examples and the takes are FakeNerd's. Not sponsored by anyone on this page.
↑↓ move enter openBrowse every card