THIS FEELS F*CKING ILLEGAL
you're paying opus to read files that haiku could read for pennies
it's built from features already in claude code and almost nobody sets it up:
sonnet, haiku and opus 5.5 in one session. one job each
→ haiku 5.5 does the grunt work: search, call sites, test runs. all in parallel
→ sonnet 5.5 writes the code
→ opus 5.5 sits there doing nothing. until it's needed
opus wakes up only 3 times:
1. before the plan locks
2. when the same error hits twice
3. before anything gets called "done"
#3 is where agents fake it
the cheapest model does the digging. the smartest one only says yes or no
one command and one prompt:
claude --model sonnet
then paste this:
"set up my claude code around 3 models:
1. create 3 subagents in .claude/agents on haiku 5.5: search (maps the repo, read-only), grep (finds call sites), tests (runs the suite)
2. create 1 subagent on opus 5.5: reviewer. it only reads the plan and the final diff and replies approve or reject
3. add a rule to CLAUDE.md: every repo search and test run goes to haiku. call the reviewer before a plan locks, after the same error twice, and before done
show me every change as a diff first. no edits until i say go"
the claude code team says claude writes and reviews about 90% of their code
what keeps it honest is a separate check before anything ships
in their internal tests a separate grader raised task success by up to 10 points
the full setup, every file and every prompt, is in the article below
who gets the final yes in your setup?
THIS FEELS F*CKING ILLEGAL
you're paying opus to read files that haiku could read for pennies
it's built from features already in claude code and almost nobody sets it up:
sonnet, haiku and opus 5.5 in one session. one job each
→ haiku 5.5 does the grunt work: search, call sites, test runs. all in parallel
→ sonnet 5.5 writes the code
→ opus 5.5 sits there doing nothing. until it's needed
opus wakes up only 3 times:
1. before the plan locks
2. when the same error hits twice
3. before anything gets called "done"
#3 is where agents fake it
the cheapest model does the digging. the smartest one only says yes or no
one command and one prompt:
claude --model sonnet
then paste this:
"set up my claude code around 3 models:
1. create 3 subagents in .claude/agents on haiku 5.5: search (maps the repo, read-only), grep (finds call sites), tests (runs the suite)
2. create 1 subagent on opus 5.5: reviewer. it only reads the plan and the final diff and replies approve or reject
3. add a rule to CLAUDE.md: every repo search and test run goes to haiku. call the reviewer before a plan locks, after the same error twice, and before done
show me every change as a diff first. no edits until i say go"
the claude code team says claude writes and reviews about 90% of their code
what keeps it honest is a separate check before anything ships
in their internal tests a separate grader raised task success by up to 10 points
the full setup, every file and every prompt, is in the article below
who gets the final yes in your setup?
THIS IS AN ACTUAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code.
The idea: give Claude a skill called verify that boots your app and runs the real user flow, so it proves the change works before it commits.
The Claude Code team says Claude writes and reviews about 90% of their code, and this is how they trust it. In their internal tests, a separate grader checking Claude's work raised task success by up to 10 points.
You just add one folder:
.claude/skills/verify/SKILL.md
and start Claude Code like this:
claude --model sonnet --advisor fable
this is how it splits:
→ Sonnet 5.5 writes the change
→ a Haiku 5.5 test-runner runs the cheap checks first: tests, build, linter
→ the verify skill boots the app and runs the real flow end to end
→ Fable 5.2 on call as advisor reviews the evidence before it's marked done
The team invests in three kinds of checks:
→ end-to-end tests: the whole feature works or it doesn't
→ property tests: rules that can never break
→ differential tests: the old system is the oracle
Write. Verify. Then commit.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Sonnet 5.5 runs the main session and writes the change
> test-runner runs tests, build and linter on Haiku 5.5 first
> .claude/skills/verify boots the app and drives the real flow
> property checks hold the rules that must never break
> Fable 5.2 on call as advisor before anything is marked done
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Set up verification in this repo around this tree:
1. Create .claude/skills/verify/SKILL.md that starts the app, drives the main user flow end to end, and reports what broke with evidence.
2. Create a read-only Haiku 5.5 test-runner subagent that runs tests, build and linter and reports only failures.
3. Add one rule to CLAUDE.md: run the verify skill before every commit, and never mark a task done without its evidence.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
Fable as advisor needs Fable access. run claude update, then /model fable once if your plan bills Fable to usage credits.
↳ claude.dev/blog/how-the-clau…
save it, your next big refactor runs in one step.
THIS IS AN ACTUAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code.
The idea: give Claude a skill called verify that boots your app and runs the real user flow, so it proves the change works before it commits.
The Claude Code team says Claude writes and reviews about 90% of their code, and this is how they trust it. In their internal tests, a separate grader checking Claude's work raised task success by up to 10 points.
You just add one folder:
.claude/skills/verify/SKILL.md
and start Claude Code like this:
claude --model sonnet --advisor fable
this is how it splits:
→ Sonnet 5.5 writes the change
→ a Haiku 5.5 test-runner runs the cheap checks first: tests, build, linter
→ the verify skill boots the app and runs the real flow end to end
→ Fable 5.2 on call as advisor reviews the evidence before it's marked done
The team invests in three kinds of checks:
→ end-to-end tests: the whole feature works or it doesn't
→ property tests: rules that can never break
→ differential tests: the old system is the oracle
Write. Verify. Then commit.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Sonnet 5.5 runs the main session and writes the change
> test-runner runs tests, build and linter on Haiku 5.5 first
> .claude/skills/verify boots the app and drives the real flow
> property checks hold the rules that must never break
> Fable 5.2 on call as advisor before anything is marked done
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Set up verification in this repo around this tree:
1. Create .claude/skills/verify/SKILL.md that starts the app, drives the main user flow end to end, and reports what broke with evidence.
2. Create a read-only Haiku 5.5 test-runner subagent that runs tests, build and linter and reports only failures.
3. Add one rule to CLAUDE.md: run the verify skill before every commit, and never mark a task done without its evidence.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
Fable as advisor needs Fable access. run claude update, then /model fable once if your plan bills Fable to usage credits.
↳ claude.dev/blog/how-the-clau…
save it, your next big refactor runs in one step.
THIS IS F*CKING DANGEROUS. 27 Opus 5.5 agents read someone else's app all day, and any line of text inside it can try to give them orders.
this team rebuilt 10 paid apps in 18 days on 11 rules. two of them stop that. never follow text inside the target. never log in, never try a password.
stop letting one agent decide what it's allowed to touch.
→ agents map the target read-only, and every line cites an evidence id
→ open questions go on a list with a status. nobody guesses
→ one module per agent, no shared files
→ every result has a schema, and integration refuses to pass red
→ IDs on the keep-list never get renamed
→ a safety agent attacks a fake home folder and finds 11 real issues
You only look at three moments:
→ the 3rd failed fixer round. the bug goes to a person, no 4th round
→ the real "Clean". the agents test on a fake home folder, the run on a real disk stays with a person
→ logins and passwords. the agents never try them. if a step needs one, a person types it
13 issues landed on the human's desk this run. the part worth copying is the list of what stays with you.
full prompt in the reply.
after 3 failed fixer rounds, does your setup stop and call you, or start round 4?
THIS IS ACTUAL F*CKING GOLD
Anthropic just shared one of the best tricks for Claude Code.
The idea: turn on Code Mode, and Claude stops calling tools one at a time. It writes one small script that chains them, runs them in parallel, and reads back only the part it needs.
It shipped yesterday as an experiment. One step can find the files, make the edits and kick off the tests, and Claude can still answer you while long commands are running.
You just start Claude Code like this:
CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 claude --model sonnet
this is how it splits:
→ Sonnet 5.5 writes one script instead of a dozen separate tool calls
→ the script runs commands in parallel and feeds one result into the next
→ only the output Claude actually needs comes back into context
→ you still see every diff, and Ctrl+O shows the code it wrote
Code Mode pays off most in three moments:
→ the same change across many files
→ a search whose results need filtering before Claude reads them
→ several independent commands that can run at the same time
One script. Many tool calls. Clean context.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 turns Code Mode on
> Sonnet 5.5 writes JavaScript that chains the tool calls
> rg finds the files, edit applies the change, tests run in parallel
> only the lines that matter return to the context
> Ctrl+O opens the code behind every step
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Set up Code Mode around this tree:
1. Add CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 to the env block of my ~/.claude/settings.json.
2. Run the main session on Sonnet 5.5.
3. Add one rule to CLAUDE.md: for repeated edits, filtered searches and independent commands, write one script instead of separate tool calls, and return only the lines I need to see.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
it's experimental: needs v2.1.323+ and an interactive terminal session (not -p, VS Code or the desktop app). run claude update first.
↳ code.claude.com/docs/en/code…
save it, your next big refactor runs in one step.
THIS IS ACTUAL F*CKING GOLD
Anthropic just shared one of the best tricks for Claude Code.
The idea: turn on Code Mode, and Claude stops calling tools one at a time. It writes one small script that chains them, runs them in parallel, and reads back only the part it needs.
It shipped yesterday as an experiment. One step can find the files, make the edits and kick off the tests, and Claude can still answer you while long commands are running.
You just start Claude Code like this:
CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 claude --model sonnet
this is how it splits:
→ Sonnet 5.5 writes one script instead of a dozen separate tool calls
→ the script runs commands in parallel and feeds one result into the next
→ only the output Claude actually needs comes back into context
→ you still see every diff, and Ctrl+O shows the code it wrote
Code Mode pays off most in three moments:
→ the same change across many files
→ a search whose results need filtering before Claude reads them
→ several independent commands that can run at the same time
One script. Many tool calls. Clean context.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 turns Code Mode on
> Sonnet 5.5 writes JavaScript that chains the tool calls
> rg finds the files, edit applies the change, tests run in parallel
> only the lines that matter return to the context
> Ctrl+O opens the code behind every step
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Set up Code Mode around this tree:
1. Add CLAUDE_CODE_EXPERIMENTAL_CODE_MODE=1 to the env block of my ~/.claude/settings.json.
2. Run the main session on Sonnet 5.5.
3. Add one rule to CLAUDE.md: for repeated edits, filtered searches and independent commands, write one script instead of separate tool calls, and return only the lines I need to see.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
it's experimental: needs v2.1.323+ and an interactive terminal session (not -p, VS Code or the desktop app). run claude update first.
↳ code.claude.com/docs/en/code…
save it, your next big refactor runs in one step.
by tomorrow everyone will be using this. ~90% of the Claude Code team's code is written and reviewed by Claude, and what lets them run dozens of Claudes at once is one skill called verify.
three things in it do most of the work: a 39-item checklist fired by the diff, a 3-round limit, and a REVIEW.md the PR can't touch.
stop letting one change edit the check that judges it.
the board below is that loop on 64 Claudes, demo numbers:
→ Claude reads the diff and runs only the checklist items it triggers, usually 3 to 10 of 39
→ Claude runs tests, build and lint before it opens a PR
→ the verify skill boots the app and clicks through it like QA. you get a screenshot, not "Timeout after 30 seconds"
→ the reviewer reads REVIEW.md from the base branch, never from the PR
→ a flaky test gets no sleeps and no retries. no root cause, it gets deleted and the reason written down
→ every commit is stamped with how it was verified, "none" included
You only look at three moments:
→ round 3. a check still fails after three fix rounds, Claude stops and pulls you in. that's your whole queue
→ observe mode. a new commit gate logs what it would have blocked. you read the false positives before you flip it to enforce
→ the miss. a pattern shows up in 2+ PRs, three agents try to disprove it, and you approve it in a PR before it becomes a rule
the part worth copying is the base branch rule. a check the change can edit isn't a check.
full prompt in the reply.
your last PR that Claude wrote: was it graded against a file that PR couldn't edit?
THIS IS AN ACTUAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code.
The idea: keep Opus 5.5 as your main model, and put Fable 5.2 on call as the advisor that checks its biggest decisions.
Fable 5.2 beat Opus 5.5 on FrontierSWE v2, 69.9% to 62.3%. You don't have to move your whole session to Fable to get that edge, it only steps in where the outcome is decided.
You just start Claude Code like this:
claude --model opus --advisor fable
this is how it splits:
→ Opus 5.5 runs the session and writes the code like it always does
→ Haiku 5.5 subagents search the repo and run the tests in parallel
→ Fable 5.2 reads the full transcript only at the decision points
→ Opus keeps its speed, Fable adds a second opinion from a stronger model
Fable only steps in at three moments:
→ before a plan gets locked
→ when the same error comes back twice
→ before Claude calls the task done
Opus works. Haiku digs. Fable checks.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Opus 5.5 runs the main session and edits the code
> search maps the repo on Haiku 5.5, read-only
> grep finds every call site on Haiku 5.5
> test-runner runs the suite on Haiku 5.5 and reports only failures
> Fable 5.2 on call as advisor, reads the full transcript when consulted
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Run the main session on Opus 5.5 with Fable 5.2 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), test-runner (runs the suite, reports only failures).
3. Add one rule to CLAUDE.md: consult the advisor before a plan locks, after the same error twice, and before a task is marked done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
Opus 5.5 accepts Fable as its advisor, it's in the docs pairing table. needs Fable access. run claude update, then /model fable once if your plan bills Fable to usage credits.
↳ code.claude.com/docs/en/advi…
save it, even Opus deserves a second opinion.
THIS IS AN ACTUAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code.
The idea: keep Opus 5.5 as your main model, and put Fable 5.2 on call as the advisor that checks its biggest decisions.
Fable 5.2 beat Opus 5.5 on FrontierSWE v2, 69.9% to 62.3%. You don't have to move your whole session to Fable to get that edge, it only steps in where the outcome is decided.
You just start Claude Code like this:
claude --model opus --advisor fable
this is how it splits:
→ Opus 5.5 runs the session and writes the code like it always does
→ Haiku 5.5 subagents search the repo and run the tests in parallel
→ Fable 5.2 reads the full transcript only at the decision points
→ Opus keeps its speed, Fable adds a second opinion from a stronger model
Fable only steps in at three moments:
→ before a plan gets locked
→ when the same error comes back twice
→ before Claude calls the task done
Opus works. Haiku digs. Fable checks.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Opus 5.5 runs the main session and edits the code
> search maps the repo on Haiku 5.5, read-only
> grep finds every call site on Haiku 5.5
> test-runner runs the suite on Haiku 5.5 and reports only failures
> Fable 5.2 on call as advisor, reads the full transcript when consulted
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Run the main session on Opus 5.5 with Fable 5.2 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), test-runner (runs the suite, reports only failures).
3. Add one rule to CLAUDE.md: consult the advisor before a plan locks, after the same error twice, and before a task is marked done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
Opus 5.5 accepts Fable as its advisor, it's in the docs pairing table. needs Fable access. run claude update, then /model fable once if your plan bills Fable to usage credits.
↳ code.claude.com/docs/en/advi…
save it, even Opus deserves a second opinion.
THIS IS ACTUAL F*CKING GOLD
Anthropic just shared one of the best tricks for Claude Code.
The idea: let Sonnet 5.5 do the typing and put Fable 5.2 on call as the advisor, the setup everyone is sharing this week.
The real win isn't a free Fable. Fable only reads the transcript at the decision points, so you get its judgment without running it on every turn.
You just start Claude Code like this:
claude --model sonnet --advisor fable
this is how it splits:
→ Sonnet 5.5 runs the session and writes every line
→ Haiku 5.5 subagents search the repo and run the tests in parallel
→ Fable 5.2 reads the full transcript only when it's consulted
→ Fable gets called a few times per task instead of on every turn
Fable only steps in at three moments:
→ before a plan gets locked
→ when the same error comes back twice
→ before Claude calls the task done
Sonnet writes. Haiku digs. Fable decides.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Sonnet 5.5 runs the main session and edits the code
> search maps the repo on Haiku 5.5, read-only
> grep finds every call site on Haiku 5.5
> test-runner runs the suite on Haiku 5.5 and reports only failures
> Fable 5.2 on call as advisor, reads the full transcript when consulted
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Run the main session on Sonnet 5.5 with Fable 5.2 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), test-runner (runs the suite, reports only failures).
3. Add one rule to CLAUDE.md: consult the advisor before a plan locks, after the same error twice, and before a task is marked done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
heads up: per the docs, advisor usage still counts toward your plan limits, and on some plans a Fable advisor bills to usage credits. run claude update, then /model fable once to accept.
↳ code.claude.com/docs/en/advi…
save it, and don't trust a meter that doesn't move.
THIS IS ACTUAL F*CKING GOLD
Anthropic just shared one of the best tricks for Claude Code.
The idea: let Sonnet 5.5 do the typing and put Fable 5.2 on call as the advisor, the setup everyone is sharing this week.
The real win isn't a free Fable. Fable only reads the transcript at the decision points, so you get its judgment without running it on every turn.
You just start Claude Code like this:
claude --model sonnet --advisor fable
this is how it splits:
→ Sonnet 5.5 runs the session and writes every line
→ Haiku 5.5 subagents search the repo and run the tests in parallel
→ Fable 5.2 reads the full transcript only when it's consulted
→ Fable gets called a few times per task instead of on every turn
Fable only steps in at three moments:
→ before a plan gets locked
→ when the same error comes back twice
→ before Claude calls the task done
Sonnet writes. Haiku digs. Fable decides.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Sonnet 5.5 runs the main session and edits the code
> search maps the repo on Haiku 5.5, read-only
> grep finds every call site on Haiku 5.5
> test-runner runs the suite on Haiku 5.5 and reports only failures
> Fable 5.2 on call as advisor, reads the full transcript when consulted
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Run the main session on Sonnet 5.5 with Fable 5.2 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), test-runner (runs the suite, reports only failures).
3. Add one rule to CLAUDE.md: consult the advisor before a plan locks, after the same error twice, and before a task is marked done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
heads up: per the docs, advisor usage still counts toward your plan limits, and on some plans a Fable advisor bills to usage credits. run claude update, then /model fable once to accept.
↳ code.claude.com/docs/en/advi…
save it, and don't trust a meter that doesn't move.
SpaceXAI engineer, Lauren Tan just dropped a free 1-hour masterclass on build team of GrokBot agents and loops from 0% to 100%:
“I’ve gotten to a point where i essentially have my agents merge their own pull requests”
10% → 3:36 - giving bots real jobs: own logins, budget
30% → 22:35 - the workflow behind 4,000 PRs a month
55% → 29:01 - building a personal software factory
80% → 40:13 - the smallest loop: teach agents to check their own work
100% → 47:33 - codebase guardrails that save tokens
most people are still babysitting one agent - Lauren runs a factory that ships 4,000 PRs a month and fixes bugs at 3 AM
bookmark & watch - then read the full playbook on GrokBot team below ↓
THIS IS STUPIDLY F*CKING GOLD. 16 agents, 398 traced calls, $1.12 on the meter, and Opus 5.5 never reads a single line of their raw output.
this board puts the REA loop from this article on one screen. Haiku reads, Sonnet rebuilds, a second Sonnet checks, Opus only signs.
stop letting one model read the binary, write the rebuild and grade its own match.
how the run splits:
→ Opus 5.5 at xhigh writes the script first: scan, trace, rebuild, verify, 7 steps
→ Haiku 5.5 reads each binary locally. 9 of 9 readers done, 0 binaries uploaded
→ Sonnet 5.5 rebuilds in 4 clean-room worktrees. no original code copied
→ Sonnet 5.5 runs lint, tests and match. 133 of 133 cases on the authenticator
→ back to Opus 5.5, which signs off on verified results only
You only look at three moments:
→ the evidence file. 3,080 items, each one tied to a function, a file and a call. a claim with no address is a guess, send it back
→ the match. the Touhou rebuild lands 696 of 697 exact. you decide if that last function ships or stays open
→ the sign-off. the log still says "residual unknowns: 1". Opus signs, but that line is yours to close before anything merges
the first line of my prompt on runs like this: "Show every diff first. Do not apply edits until I say go."
the part worth copying is one rule: the orchestrator never reads raw agent output, only what passed verify.
on your last rebuild, which one did you skip: the evidence file, the 697th function or the open unknown?
THIS IS AN ACTUAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code.
The idea: run Fable 5.2 on low effort for the everyday work, and only turn it up to high for the moments that decide the outcome.
On Humanity's Last Exam, Fable 5.2 on low effort matched Opus 5.5's top score for less than a tenth of the cost per task. On high, it matched Opus 5.5 on max in FrontierCode at about half the cost.
You just start Claude Code like this:
claude --model fable
then you switch effort mid-session:
/effort low for building and routine fixes
/effort high for the plan and the final review
this is how it splits:
→ Fable 5.2 builds on low effort, fast and cheap, while you steer
→ Haiku 5.5 subagents search the repo and run the tests
→ /effort high only for locking the plan and the final review
→ you get the newest model on every turn without paying max-effort prices
You switch to high at three moments:
→ before a plan gets locked
→ when the same error comes back twice
→ before Claude calls the task done
Low to build. High to decide. Haiku digs.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Fable 5.2 runs the main session on /effort low
> search maps the repo on Haiku 5.5, read-only
> test-runner runs the suite on Haiku 5.5 and reports only failures
> /effort high to lock the plan
> /effort high for the final review
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code workflow around this tree:
1. Run the main session on Fable 5.2.
2. Create two read-only Haiku 5.5 subagents: search (maps the repo) and test-runner (runs the suite, reports only failures).
3. Add one rule to CLAUDE.md: remind me to run /effort high before a plan locks, after the same error twice, and before a task is marked done, and to drop back to /effort low after.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
run claude update first. needs Fable access. if /model fable still shows 5.1, use /model claude-fable-5-2
↳ anthropic.com/news/claude-fa…
save it, max effort on every turn is how people burn their limits.
THIS IS AN ACTUAL F*CKING GOLDMINE
Anthropic just shared one of the best tricks for Claude Code.
The idea: run Fable 5.2 on low effort for the everyday work, and only turn it up to high for the moments that decide the outcome.
On Humanity's Last Exam, Fable 5.2 on low effort matched Opus 5.5's top score for less than a tenth of the cost per task. On high, it matched Opus 5.5 on max in FrontierCode at about half the cost.
You just start Claude Code like this:
claude --model fable
then you switch effort mid-session:
/effort low for building and routine fixes
/effort high for the plan and the final review
this is how it splits:
→ Fable 5.2 builds on low effort, fast and cheap, while you steer
→ Haiku 5.5 subagents search the repo and run the tests
→ /effort high only for locking the plan and the final review
→ you get the newest model on every turn without paying max-effort prices
You switch to high at three moments:
→ before a plan gets locked
→ when the same error comes back twice
→ before Claude calls the task done
Low to build. High to decide. Haiku digs.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Fable 5.2 runs the main session on /effort low
> search maps the repo on Haiku 5.5, read-only
> test-runner runs the suite on Haiku 5.5 and reports only failures
> /effort high to lock the plan
> /effort high for the final review
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code workflow around this tree:
1. Run the main session on Fable 5.2.
2. Create two read-only Haiku 5.5 subagents: search (maps the repo) and test-runner (runs the suite, reports only failures).
3. Add one rule to CLAUDE.md: remind me to run /effort high before a plan locks, after the same error twice, and before a task is marked done, and to drop back to /effort low after.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
run claude update first. needs Fable access. if /model fable still shows 5.1, use /model claude-fable-5-2
↳ anthropic.com/news/claude-fa…
save it, max effort on every turn is how people burn their limits.
THIS IS ACTUAL F*CKING GOLD
Anthropic just shared one of the best tricks for Claude Code.
The idea: let Haiku 5.5, the cheapest model, do all the typing, and put Fable 5.2 on call as the advisor for the decisions that actually matter.
Fable 5.2 just beat Opus 5.5 on FrontierSWE v2, 69.9% to 62.3%. As the advisor it only wakes up at the decision points, and Haiku pays for everything else.
You just start Claude Code like this:
claude --model haiku --advisor fable
this is how it splits:
→ Haiku 5.5 drives the session, edits the files and runs the tests
→ Haiku 5.5 subagents search the repo and pull the docs in parallel
→ Fable 5.2 waits on call and reads the full transcript only when it's consulted
→ you pay Haiku rates for the typing and Fable rates only for the thinking
Fable only steps in at three moments:
→ before a plan gets locked
→ when the same error comes back twice
→ before Claude calls the task done
Haiku types. Haiku digs. Fable decides.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Haiku 5.5 runs the main session and applies every fix
> search maps the repo on Haiku 5.5, read-only
> grep finds every call site on Haiku 5.5
> docs pulls the API reference on Haiku 5.5
> Fable 5.2 on call as advisor, reads the full transcript when consulted
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Run the main session on Haiku 5.5 with Fable 5.2 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), docs (pulls the API reference).
3. Add one rule to CLAUDE.md: consult the advisor before a plan locks, after the same error twice, and before a task is marked done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
run claude update first (v2.1.293+). needs Fable access, and on some plans Fable calls bill to usage credits. if /advisor still shows 5.1, use --advisor claude-fable-5-2
↳ anthropic.com/news/claude-fa…
save it, this is the cheapest seat next to Fable 5.2.
THIS IS ACTUAL F*CKING GOLD
Anthropic just shared one of the best tricks for Claude Code.
The idea: let Haiku 5.5, the cheapest model, do all the typing, and put Fable 5.2 on call as the advisor for the decisions that actually matter.
Fable 5.2 just beat Opus 5.5 on FrontierSWE v2, 69.9% to 62.3%. As the advisor it only wakes up at the decision points, and Haiku pays for everything else.
You just start Claude Code like this:
claude --model haiku --advisor fable
this is how it splits:
→ Haiku 5.5 drives the session, edits the files and runs the tests
→ Haiku 5.5 subagents search the repo and pull the docs in parallel
→ Fable 5.2 waits on call and reads the full transcript only when it's consulted
→ you pay Haiku rates for the typing and Fable rates only for the thinking
Fable only steps in at three moments:
→ before a plan gets locked
→ when the same error comes back twice
→ before Claude calls the task done
Haiku types. Haiku digs. Fable decides.
JEV engineering is the same idea one layer down: the forks that need no thinker (which file, which tool, retry or stop) get settled by JEV in milliseconds, and the big models only see the ones that actually split
the full tree
> Haiku 5.5 runs the main session and applies every fix
> search maps the repo on Haiku 5.5, read-only
> grep finds every call site on Haiku 5.5
> docs pulls the API reference on Haiku 5.5
> Fable 5.2 on call as advisor, reads the full transcript when consulted
> JEV routes micro-forks in milliseconds
paste the tree and this prompt into Claude Code ↓
"Rebuild my Claude Code setup around this tree:
1. Run the main session on Haiku 5.5 with Fable 5.2 as advisor.
2. Create three read-only Haiku 5.5 subagents: search (maps the repo), grep (finds call sites), docs (pulls the API reference).
3. Add one rule to CLAUDE.md: consult the advisor before a plan locks, after the same error twice, and before a task is marked done.
4. Route fast deterministic forks (tool choice, path selection, retries) through JEV.
Show me every change as a diff first. Nothing gets edited until I say go."
run claude update first (v2.1.293+). needs Fable access, and on some plans Fable calls bill to usage credits. if /advisor still shows 5.1, use --advisor claude-fable-5-2
↳ anthropic.com/news/claude-fa…
save it, this is the cheapest seat next to Fable 5.2.
















