Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

F*ck YES... Anthropic just released most INSANE cheat code for Claude Code: Fable 5.2 brain → while Sonnet 5.5 builds → Opus 5.5 checks → Haiku 5.5 swarms 1 min + /advisor command = up to 3.4x CHEAPER here's how to setup it: first understand how it works: •...

208,358 Aufrufe • vor 4 Tagen •via X (Twitter)

30 Kommentare

Profilbild von codila
codilavor 4 Tagen

Antrhopic's cheat code: full prompt: "Set up my Claude Code as a 4-model team, at user level so it works in every project: - Sonnet 5.5 = main session. It builds: writes code, runs tests. - Fable 5.2 = advisor, the brain. It only advises, never writes code. - Opus 5.5 = checker subagent. It tests finished work and tries to break it, never edits. - Haiku 5.5 = search and research. It replaces the built-in Explore agent and is the default for other subagents. Before you change anything, read Anthropic's official docs: https: //code.claude.com/docs/en/advisor https: //code.claude.com/docs/en/sub-agents https: //code.claude.com/docs/en/model-config Use only the settings, fields and file formats those pages describe. If something below doesn't match the docs, follow the docs and tell me what you changed. Steps: 1. Check my Claude Code version. Fable 5.2 needs v2.1.321 or later. If it's older, run claude update, or tell me to. 2. In ~/.claude/settings.json: main model sonnet, advisorModel fable, env CLAUDE_CODE_SUBAGENT_MODEL haiku. Merge, never delete my settings. If my settings lower the main model's effort below its default, tell me: at lower effort the main model consults the advisor far less. 3. Create ~/.claude/agents/checker.md with model opus. It runs the tests, reads the diff and tries edge cases. It never edits code. It reports each real problem with the file, the line or command, and what it saw. 4. Create ~/.claude/agents/Explore.md with name Explore, model haiku and read-only tools (no Write, no Edit). A user subagent named Explore replaces the built-in one, which otherwise runs on my main model and ignores CLAUDE_CODE_SUBAGENT_MODEL. It finds files, greps, reads docs and returns short structured results. 5. Add to ~/.claude/CLAUDE.md: "Consult the advisor before you commit to an approach, when the same error comes back twice, and before you say a task is done. Run the checker before you call any task done. Send search and docs lookup to Explore. If a subagent must write code, give it model sonnet, never haiku. For a small task that fits in this session, skip subagents and do it yourself." 6. Fable as advisor needs a one-time usage-credit consent on some plans. If mine needs it, stop and tell me: run /model fable once, accept, then switch back with /model sonnet. Back up every file before you edit it. Show me all changes as one diff and apply them only after my yes. Done means: after a restart, Claude Code starts on Sonnet, /advisor shows fable, and /agents lists checker (opus) and Explore (haiku). End with three headings: Changed, Needs me, How to check it works. Under the last one tell me: an "Advising" line appears when Fable is consulted, Ctrl+O shows its advice, and /usage shows what it cost. Anthropic's official advisor docs: https: //code.claude.com/docs/en/advisor"

Profilbild von bodila
bodilavor 4 Tagen

BRILLIANT. currently best way to use Claude Code right now, thank you for this! already send prompt to my Claude

Profilbild von codila
codilavor 4 Tagen

I've already test this setup and believe me, this is gold!

Profilbild von Yarchi
Yarchivor 4 Tagen

wild that one missing line can leave the smartest model sitting there unused

Profilbild von codila
codilavor 4 Tagen

true, and it's actually takes 1 min to setup

Profilbild von 0xRafy
0xRafyvor 4 Tagen

oh my, what a perfect find! sending to claude, thanks!

Profilbild von codila
codilavor 4 Tagen

I really think everyone should install this

Profilbild von vartekx
vartekxvor 4 Tagen

mega cool setup ngl, gonna send it tmrw to my claude, ty!

Profilbild von codila
codilavor 4 Tagen

tmrw? bro it takes literally 1 min, just send link + prompt to Claude and that's it

Profilbild von vartekx
vartekxvor 4 Tagen

aight aight, waking up from bed to test it

Profilbild von codila
codilavor 4 Tagen

yeah, that's right decision...XD

Profilbild von Oliver Hayes
Oliver Hayesvor 3 Tagen

Incorrect frame: the expensive model does everything. Correct frame: it thinks, the cheap ones work. Delegation 101 😄

Profilbild von Carnage
Carnagevor 4 Tagen

Woow bro this is sick fr

Profilbild von codila
codilavor 4 Tagen

that's actually super useful man! glad to help

Profilbild von عبدالعزيز العتيبي
عبدالعزيز العتيبيvor 3 Tagen

ولكن ماذا عن الكاش اليس مفضل ان تبدأ جلسة جديدة عند كل وكيل او نموذج وتعطيه التقرير سواء كانت الخطة او التنفيذ ؟ كيف يعمل بالضبط

Profilbild von Mike Stoop
Mike Stoopvor 3 Tagen

the real cheat code is still a good rules file. same model, way better output when it knows how you work

Profilbild von Adam
Adamvor 3 Tagen

How would integrate with codex if you have both subscriptions?

Profilbild von illvminat
illvminatvor 3 Tagen

Great video! Is this a real Claude Code session with a custom mod drawing the agent tree and the cost chart above the prompt, or an edited animation? If it's a mod, would you share it?

Profilbild von Vector
Vectorvor 3 Tagen

What happens to that 3.4x saving when the reviewer sends the same patch back twice?

Profilbild von dengtao
dengtaovor 3 Tagen

hello world!!!

Profilbild von Meller
Mellervor 3 Tagen

has anyone measured quality, not just cost? for my bot's backtests the expensive part is a wrong answer that looks right, not the tokens.

Profilbild von xabz
xabzvor 3 Tagen

thanks for the writeup codila

Profilbild von Nathan
Nathanvor 3 Tagen

using fable as advisor with sonnet building saves tokens while keeping top-tier logic

Profilbild von Ackdepsn
Ackdepsnvor 3 Tagen

@grok analyse et dit moi si ça marche vraiment ?

Profilbild von Robin | Poker
Robin | Pokervor 3 Tagen

Three wake ups for Fable is a clever way to keep token usage cheap

Profilbild von Leendert Goedbloed
Leendert Goedbloedvor 3 Tagen

Thanks, I was searching for this setup. Gonna make it myself.

Profilbild von Fox
Foxvor 3 Tagen

fable only waking up for 3 checkpoints is a smart way to spend it

Profilbild von Crio Songo
Crio Songovor 3 Tagen

Nice trick—what’s the latency and failure rate?

Profilbild von Mansur
Mansurvor 3 Tagen

and for How can I set this up in the program, not with the terminal, but with the app?

Profilbild von Isra
Isravor 3 Tagen

3.4x cheaper and fable only wakes up 3 times thats the detail everyone misses

Ähnliche Videos

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku and Opus 5.5 together, each one doing only the job it's best at. Opus-level judgment on every big call, without paying Opus rates for every routine turn. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.5 runs the session and writes the code → Haiku 5.5 explores files and docs in parallel → Opus 5.5 stays on call as advisor for the big calls → you stop spending Opus on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet builds. Haiku explores. Opus reviews. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and edits code > search maps the repo on Haiku 5.5 > grep finds call sites on Haiku 5.5 > docs pulls the API reference on Haiku 5.5 > Opus 5.5 on call as advisor, reads the whole 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 Opus 5.5 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 locking a plan, after the same error twice, and before calling a task done. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll use this every single day.

xsmryze

194,505 Aufrufe • vor 10 Tagen

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku and Opus 5.5 together, each one doing only the job it's best at. Opus-level judgment on every big call, without paying Opus rates for every routine turn. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.5 runs the session and writes the code → Haiku 5.5 explores files and docs in parallel → Opus 5.5 stays on call as advisor for the big calls → you stop spending Opus on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet builds. Haiku explores. Opus reviews. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and edits code > search maps the repo on Haiku 5.5 > grep finds call sites on Haiku 5.5 > docs pulls the API reference on Haiku 5.5 > Opus 5.5 on call as advisor, reads the whole 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 Opus 5.5 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 locking a plan, after the same error twice, and before calling a task done. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll use this every single day.

delost

321,646 Aufrufe • vor 1 Monat

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku and Opus 5.5 together, each one doing only the job it's best at. Opus-level judgment on every big call, without paying Opus rates for every routine turn. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.5 runs the session and writes the code → Haiku 5.5 explores files and docs in parallel → Opus 5.5 stays on call as advisor for the big calls → you stop spending Opus on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet builds. Haiku explores. Opus reviews. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and edits code > search maps the repo on Haiku 5.5 > grep finds call sites on Haiku 5.5 > docs pulls the API reference on Haiku 5.5 > Opus 5.5 on call as advisor, reads the whole 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 Opus 5.5 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 locking a plan, after the same error twice, and before calling a task done. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll use this every single day.

xsmryze

193,736 Aufrufe • vor 21 Tagen

This workflow will save you thousands with Claude. Run Opus 5.5, Sonnet 5.5, Haiku 5.5, and Fable 5.1 together, and stop spending Opus tokens on work that doesn't need Opus. The entire idea in one line: Opus plans, Sonnet edits, Haiku reads, Fable reviews at decision points. Roles, broken down: - Opus 5.5, high effort, owns the plan and reviews the final code - Sonnet 5.5, medium effort, is the worker: edits files, runs tests - Haiku 5.5, low effort, splits into explorer (searches and reads the codebase) and researcher (pulls docs). it's the first Haiku with an effort setting - Fable 5.1, set with /advisor fable. Opus calls it at decision points, and it gets the full transcript each time Three moments Opus tends to call it: → before committing to a plan: is this the right approach? → the same error shows up again: is this going nowhere? → before marking the task done: did something get skipped? Why Haiku only reads: Anthropic's launch post says Sonnet 5.5 and Opus 5.5 are still the better choice for complex agentic coding (Terminal-Bench 4.0: 39.2% for Haiku 5.5, 70.6% for Sonnet 5.5) and that Haiku 5.5 fits narrowly scoped subagent work. so it gets the lookups, not the edits. Anyone still running one model for everything is paying $4 per million input tokens to check whether a file exists. Haiku 5.5 does it for $0.10. Drop this into Claude Code 👇 "Rebuild my Claude Code setup around this structure: Confirm Claude Code is v2.1.293 or later, so the haiku alias resolves to Haiku 5.5. If it isn't, stop and tell me to run claude update. Look through ~/.claude/agents and .claude/agents for subagents already covering explorer, worker, and researcher. Only create new ones for roles that are missing. Set model: haiku, effort: low on explorer and researcher, with no Edit or Write tools. Set model: sonnet, effort: medium on worker. If an existing subagent is locked to a different model, leave it as is and just list it. Name the explorer subagent Explore so it overrides the built-in one, which otherwise runs on my main model. In ~/.claude/settings.json, set advisorModel to fable, and set effortLevel to high for claude-opus-5-5 under modelSettings. A top-level effortLevel in user settings doesn't apply to Opus 5.5. Check for anything disabling the advisor: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, or anything blocking feature-flag fetches. Also check CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort settings, and CLAUDE_CODE_SUBAGENT_MODEL_FORCE, which makes Claude Code ignore subagent model fields. Report what you find. Don't change any of it yet. Add one line to ~/.claude/CLAUDE.md: consult the advisor before a big plan, when the same error shows up twice, and before marking a long task done. Show every change as a diff first. Wait for my go-ahead before touching anything."

Alvaro Cintas

58,450 Aufrufe • vor 1 Monat

THIS IS PURE F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku and Opus 5.5 at the same time, each one doing only what it's best at. Better results and way fewer tokens, because every task lands on the right model. You just start Claude Code like this: claude --model sonnet --advisor opus here's how it splits: → Sonnet 5 runs the session and writes the code → Haiku 5.5 explores files and docs in parallel → Opus 5.5 stays on call as advisor for the big decisions → you stop burning Opus context on tasks that don't need it Opus only steps in at three moments: → before a plan locks → when the same error hits twice → before calling it done Sonnet builds. Haiku explores. Opus reviews. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5 runs the main session and edits code > search maps the repo on Haiku 5.5 > grep finds call sites on Haiku 5.5 > docs pulls the API reference on Haiku 5.5 > Opus 5.5 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 ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Sonnet 5 with Opus 5.5 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 locking a plan, after the same error twice, and before calling a task done. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

delost

317,690 Aufrufe • vor 1 Monat

Official Anthropic tip for Claude Code: stop burning Opus 5.5 on work Sonnet 5.5 can do, while Fable 5.1 sits idle hand the grunt work to Sonnet 5.5 subagents and put Fable 5.1 on call run /advisor fable Opus 5.5 plans and merges Sonnet 5.5 subagents read, edit and run the tests Fable 5.1 reads the full session and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Sonnet 5.5 builds. Fable 5.1 reviews. Opus 5.5 ships Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big models only see the ones that split - the full tree > Opus 5.5 on high runs the main session > explorer reads the code on Sonnet 5.5 > worker edits and runs tests on Sonnet 5.5 > researcher pulls the docs on Sonnet 5.5 > all three on medium > Fable 5.1 on call for main and every subagent paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: sonnet, effort: medium > Skip any that pin a different model and list them 2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

delost

44,284 Aufrufe • vor 1 Monat

THIS IS AN ACTUAL F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku 5.5 and Opus 5.5 at once, each one doing only the job it's best at. Better results and way fewer tokens, because every task lands on the right model. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.5 runs the session, writes the code and applies the fixes → Haiku 5.5 swarms the repo in parallel: search, grep and diff audits → Opus 5.5 stays on call as advisor for the big calls and signs off on the diff → you stop burning Opus context on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet builds. Haiku swarms. Opus reviews. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and coordinates the work > search maps the repo on Haiku 5.5, read-only > grep finds call sites on Haiku 5.5 in its own context > audit checks the diff on Haiku 5.5 in a throwaway worktree > Opus 5.5 on call as advisor, reviews the synthesized diff before sign-off > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Sonnet 5.5 with Opus 5.5 as advisor. 2. Create three Haiku 5.5 subagents in .claude/agents: search (maps the repo), grep (finds call sites), audit (checks the diff). 3. Set isolation: worktree on audit so its checks never touch my working branch. 4. Add one rule to CLAUDE.md: delegate every repo search and test run to the Haiku 5.5 subagents to keep the main context small. 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

xsmryze

128,843 Aufrufe • vor 11 Tagen

This is f*cking insane. This Claude Code tip saved me thousands of dollars. once Opus 5.5 is your main model, stop burning it on work Sonnet 5.5 can do, while Fable 5.1 sits idle hand the grunt work to Sonnet 5.5 subagents and put Fable 5.1 on call run /advisor fable Opus 5.5 plans and ships the final code Sonnet 5.5 subagents read, edit and run the tests Fable 5.1 reads the full session, every tool call included, and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Sonnet 5.5 builds. Fable 5.1 reviews. Opus 5.5 ships Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big models only see the ones that split anyone still running one model for everything is paying Opus prices to decide whether a file exists - the full tree > Opus 5.5 on high runs the main session > explorer reads the code on Sonnet 5.5 > worker edits and runs tests on Sonnet 5.5 > researcher pulls the docs on Sonnet 5.5 > all three on medium > Fable 5.1 on call for main and every subagent paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: sonnet, effort: medium > Skip any that pin a different model and list them 2. Set the main session to high via effortLevel in ~/.claude/settings.json, and set advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

delost

48,964 Aufrufe • vor 1 Monat

THIS IS AN ACTUAL F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: run Sonnet, Haiku 5.5 and Opus 5.5 at once, each one doing only the job it's best at. Better results and way fewer tokens, because every task lands on the right model. You just launch Claude Code like this: claude --model sonnet --advisor opus here's the split: → Sonnet 5.5 runs the session, writes the code and applies the fixes → Haiku 5.5 swarms the repo in parallel: search, grep and diff audits → Opus 5.5 stays on call as advisor for the big calls and signs off on the diff → you stop burning Opus context on work that doesn't need it Opus only steps in at three moments: → before a plan locks → when the same error shows up twice → before calling it done Sonnet builds. Haiku swarms. Opus reviews. JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and coordinates the work > search maps the repo on Haiku 5.5, read-only > grep finds call sites on Haiku 5.5 in its own context > audit checks the diff on Haiku 5.5 in a throwaway worktree > Opus 5.5 on call as advisor, reviews the synthesized diff before sign-off > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Sonnet 5.5 with Opus 5.5 as advisor. 2. Create three Haiku 5.5 subagents in .claude/agents: search (maps the repo), grep (finds call sites), audit (checks the diff). 3. Set isolation: worktree on audit so its checks never touch my working branch. 4. Add one rule to CLAUDE.md: delegate every repo search and test run to the Haiku 5.5 subagents to keep the main context small. 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳

delost

105,706 Aufrufe • vor 26 Tagen

Claude Code tip, and it's absolute free f*cking gold: run Opus 5.5, Sonnet 5.5 and Fable 5.1 as one team and stop burning Opus tokens on routine work the setup in one line: plan on high, delegate on medium, keep Fable on call • who does what > Opus 5.5 on high - plans and ships the code > Sonnet 5.5 on medium - explorer reads code, worker edits and runs tests, researcher pulls docs > Fable 5.1 via /advisor fable - reads the whole session and speaks up only when it matters • when Fable 5.1 steps in -> before a plan: is this the right approach? -> when an error repeats: am I digging in the wrong place? -> before "done": what did I miss? Jev engineering takes it one layer lower: which file, which tool, retry or stop all go to Jev in under half a second, so the big models only see the real forks paste this into Claude Code ↓ "Rebuild my Claude Code setup: 1. Find subagents in ~/.claude/agents and .claude/agents that fit explorer, worker and researcher. Draft only the missing ones. Set each to model: sonnet, effort: medium. List any that pin a different model and leave them 2. In ~/.claude/settings.json set effortLevel to high and advisorModel to fable. 3. Report anything that disables the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, flag-fetching blockers) and CLAUDE_CODE_EFFORT_LEVEL. Change nothing. 4. Add to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done. Show every change as a diff. No edits until I say go." ↳

Mr. Buzzoni

144,764 Aufrufe • vor 1 Monat

THIS IS ACTUAL F*CKING GOLD Anthropic just quietly dropped one of the best setups for Claude Code The rule: orchestrate Sonnet, Haiku and Opus 5.5 simultaneously, locking every model into the exact lane it dominates Opus-grade intelligence on critical architectural calls, zero Opus burn on routine terminal iterations Launch Claude Code with this flag pair: claude --model sonnet --advisor opus how the workload divides: → Sonnet 5.5 leads the main session and cuts the actual code → Haiku 5.5 swarms repos, greps call sites, and parses docs concurrently → Opus 5.5 remains on standby as advisor for high-leverage checkpoints → you eliminate token waste on work that never required frontier reasoning Opus only gets triggered on three specific events: → right before locking an architectural plan → the second an identical error hits twice → right before marking a complex task complete Sonnet builds · Haiku explores · Opus reviews JEV engineering applies the exact same logic one layer deeper: deterministic branches (file selection, tool dispatch, fast retry vs abort) clear in sub-milliseconds, so the frontier models only handle genuine forks the architecture tree: > Sonnet 5.5 drives the primary terminal session and edits code > search crawls repo structure on Haiku 5.5 > grep locates call signatures on Haiku 5.5 > docs fetches API specs and schemas on Haiku 5.5 > Opus 5.5 stands on call as advisor, ingesting full context when pinged > JEV resolves instant deterministic routing feed this tree and prompt directly into Claude Code ↓ "Configure my Claude Code environment around this multi-model tree: 1. Run the primary session on Sonnet 5.5 with Opus 5.5 as advisor 2. Spawn three read-only Haiku 5.5 subagents: search (repo mapping), grep (call sites), docs (API references) 3. Enforce one rule in CLAUDE.md: ping advisor before locking any plan, upon repeating any error twice, and before final task handoff 4. Route instantaneous deterministic forks (tool choice, path check, retries) through JEV Show every file update as a diff first, make zero changes without confirmation" ↳ bookmark this, you'll run it every single day

mirku

82,667 Aufrufe • vor 1 Monat

holy sh*t. Official Anthropic tip for Claude Code: stop burning Opus 5.5 context on tasks Haiku 5.5 can swarm, while Sonnet 5 builds put the architect on call with /advisor claude --model sonnet --advisor opus Sonnet 5 drives the primary session on high effort, writing diffs and running test suites Haiku 5.5 subagents swarm the repo in parallel, handling file discovery and spec docs lookup Opus 5.5 stays on call in the background as the advisor, only stepping in at three critical moments: → before a plan locks: does the implementation plan miss auth invariants or schema contracts? → when a test breaks twice: are we fixing the root cause or falling into a recursive rabbit hole? → before calling done: did the full diff introduce hidden regressions or break pre-flight rules? Opus 5.5 reviews. Sonnet 5 builds. Haiku 5.5 swarms Jev engineering runs the identical pattern one layer down: mechanical decisions that need no reasoning (which file to open, which tool to invoke, retry or abort) resolve in milliseconds, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate to Haiku. Keep Opus on call. - the full advisor setup > Opus 5.5 on call reads the full session transcript and catches deep architectural traps > Sonnet 5 lead drives edits, writes core logic, and executes test harnesses > Haiku 5.5 subagents swarm grep scans, file discovery, and API docs in parallel > subagents inherit the advisor automatically, no extra config > toggling the advisor mid-session never invalidates the prompt cache paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for hierarchical advisor orchestration: 1. Audit ~/.claude/settings.json and project config for model roles fitting lead, subagents, and advisor: > Pin main session model: sonnet with effortLevel: high for primary execution > Pin subagents to model: haiku in ~/.claude/agents for parallel file discovery and docs retrieval > Pin advisorModel: opus for strategic review 2. Draft read-only subagent definitions in ~/.claude/agents: > file-search and docs-lookup, model: haiku, read-only tools > return structured summaries and docs snippets only, never edit > skip any that already exist and list them 3. Configure advisor consultation checkpoints in ~/.claude/CLAUDE.md: > Consult the advisor before finalizing multi-file architecture plans > Consult the advisor when the same test or compiler error fails twice > Consult the advisor for a diff audit before declaring tasks complete or staging git commits 4. Find anything that would override this setup: > CLAUDE_CODE_SUBAGENT_MODEL, CLAUDE_CODE_DISABLE_ADVISOR_TOOL, CLAUDE_CODE_EFFORT_LEVEL > Report it, change nothing Show every configuration diff first. Do not apply edits until confirmed" ↳

delost

17,319 Aufrufe • vor 1 Monat

Claude Code tip that's pure f*cking treasure: Opus 5.5 + Sonnet 5.5 + Fable 5.1 as one team plan on high, delegate on medium, keep Fable on call the team: • Opus 5.5 (high) - plans and ships • Sonnet 5.5 (medium) - explores, edits, runs tests, pulls docs • Fable 5.1 (/advisor fable) - watches the session, speaks up when it counts Fable wakes up 3 times: 1. before a plan - is this the right approach? 2. when an error repeats - am I digging in the wrong place? 3. before "done" - what did I miss? Jev engineering goes one layer lower: which file, which tool, retry or stop go to Jev in under half a second, so the big models only see the real forks paste this into Claude Code 👇 "Rebuild my Claude Code setup around one team. 1. Subagents - reuse anything in ~/.claude/agents and .claude/agents that fits explorer, worker or researcher, draft the rest - all on model: sonnet, effort: medium - explorer and researcher read-only (Read, Grep, Glob, WebFetch), only worker gets Edit and Bash - each returns under 15 lines with file:line refs 2. Main session - in ~/.claude/settings.json set effortLevel to high and advisorModel to fable - report anything that overrides this (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, CLAUDE_CODE_EFFORT_LEVEL) and change nothing 3. Add to ~/.claude/CLAUDE.md - consult the advisor before a plan touching 3+ files, when the same error shows up twice, and before calling a long task done - never let two subagents edit the same file Run /agents to confirm, then show everything as one diff. No edits until I say go." ↳

Annatar.md

19,580 Aufrufe • vor 1 Monat

THIS IS A PURE F*CKING DIAMOND Anthropic just documented one of the best setups for Claude Code The idea: run Opus 5.5, Sonnet 5.5, and the new Haiku 5.5 together in a tight tripartite loop, each doing only what it was built for Opus-level planning on every big architectural decision, without paying Opus rates for routine code edits or repo searches You just start Claude Code like this: CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model opusplan here's how it splits: → Opus 5.5 runs plan mode: architects the system blueprint, locks contracts, and signs off on the diff → Sonnet 5.5 executes the plan in the main session: writes the code, applies patches, and runs test suites → Haiku 5.5 swarms the repository in parallel: maps the AST, greps call sites, and parses docs at 340 tok/s with native 1M context → you stop burning Opus context on routine files and keep your main session under 10k tokens Opus only steps in at three moments: → before a plan locks (architectural design) → when the same test fails twice (debugging deadlocks) → before calling it done (signing off on git diff) Opus plans, Sonnet builds, Haiku swarms JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) resolve in code in 15ms, and the frontier models only see the ones that split the full tree > Opus 5.5 architects the implementation plan (opusplan mode) > Sonnet 5.5 runs the main execution session and writes code > search maps the repo AST on Haiku 5.5 (340 tok/s, 1M context) > grep locates token call sites on Haiku 5.5 (isolated subagent) > docs pulls API specifications on Haiku 5.5 (0.05x cost) > Opus 5.5 verifies synthesized diff before final sign-off > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run with model 'opusplan' so Opus 5.5 plans the architecture and Sonnet 5.5 implements the code 2. Set CLAUDE_CODE_SUBAGENT_MODEL=haiku so all search, grep, and documentation subagents swarm on Haiku 5.5 with its native 1M context 3. Configure fallbackModel to ['sonnet', 'haiku'] in settings.json to guarantee 100% session availability 4. Add one rule to CLAUDE.md: delegate all repository searches and test runs to Haiku 5.5 subagents to keep main context under 10k tokens 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV Show me every change as a diff first. No edits until I say go" ↳ save it, it'll come in handy

mirku

38,620 Aufrufe • vor 26 Tagen

Claude Code tip: keep Opus 5.5 as your main model, but stop paying Opus prices for your subagents move them to Sonnet 5.5 Opus 5.5 plans and decides Sonnet 5.5 subagents do the heavy reading, editing and testing at half the price ($2 / $10 vs $4 / $20 per 1M tokens) Fable 5.1 stays on call with /advisor and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Opus thinks. Sonnet does. Fable checks Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big models only see the ones that split - the full tree > Opus 5.5 on high runs the main session > explorer reads the code > worker edits and runs tests > researcher pulls the docs > all three on Sonnet 5.5, medium > Fable 5.1 on call as the advisor paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: claude-sonnet-5-5, effort: medium > List any that pin a different model before changing them 2. Keep the main session on Opus, set effortLevel to high in ~/.claude/settings.json and advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable that stops feature-flag fetching) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

delost

28,222 Aufrufe • vor 1 Monat

This is f*cking insane. I spent thousands of dollars before I split my work across three models put Opus 5.5 on the plan, Sonnet 5.5 on the legwork and Fable 5.1 on call, and you stop spending Opus money on jobs it was never needed for who does what: Opus 5.5, high effort: makes the plan and owns the final diff Sonnet 5.5, medium effort, three jobs: explorer reads the code, worker edits files and runs tests, researcher pulls the docs Fable 5.1, through /advisor fable: reads the whole session, but only when it gets called Fable is consulted at three points: → before a plan ships: is this the right approach? → when an error comes back twice: is the search stuck in the wrong place? → before a long task counts as done: what got missed? Jev engineering applies the same split to the smallest decisions. which file to open, which tool to run, retry or stop need no reasoning, so Jev answers them in under half a second and the big models only get the real forks run Opus on everything and you pay it to check whether a file exists paste this into Claude Code: "Rebuild my Claude Code setup around three tiers. Look in ~/.claude/agents and .claude/agents for subagents that already cover explorer, worker and researcher. Create only the missing ones, each with model: sonnet and effort: medium. If an existing one is pinned to another model, list it and leave it alone. In ~/.claude/settings.json, set advisorModel to fable. Set high effort for Opus inside modelSettings for claude-opus-5-5, because a top-level effortLevel does not apply to Opus 5.5. Report, without changing anything: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY or anything blocking feature-flag fetches, CLAUDE_CODE_EFFORT_LEVEL, which can override subagent effort, and whether Fable as advisor needs a one-time billing consent. If you can't tell, say so. Add one line to ~/.claude/CLAUDE.md: consult the advisor before a big plan, when the same error shows up twice, and before marking a long task done. Show every change as a diff first. Touch nothing until I say go."

Ryven

49,239 Aufrufe • vor 1 Monat