Video yükleniyor...

Video Yüklenemedi

Bu video yüklenirken bir sorun oluştu. Bu geçici bir ağ sorunundan kaynaklanıyor olabilir veya video kullanılamıyor olabilir.

Ana Sayfaya Dön

Why is no one talking about this? Official Anthropic recommendation for Claude Code: stop wasting Opus 5.5 compute on tasks Haiku 5.5 can swarm, while Sonnet 5.5 handles core development. switch the architect model into standby using /advisor claude -> advisor opus -> subagents haiku Sonnet 5.5 powers the... main workflow at maximum effort, drafting code changes and executing test suites Haiku 5.5 subagents index the repository in parallel at 340 tokens/sec, discovering files and reviewing technical documentation Opus 5.5 remains on standby as an expert consultant, stepping in only during three key scenarios: -> prior to committing to a strategy: does the blueprint lack authentication edge cases or schema rules? -> when a test fails repeatedly: are we tackling the root issue or wasting time in a rabbit hole? -> before marking the task complete: did recent diffs introduce silent bugs, and are baseline checks satisfied? Opus 5.5 assesses. Sonnet 5.5 builds. Haiku 5.5 executes concurrently Jev engineering applies this identical structure one level down: automated logic requiring zero reasoning (selecting files, invoking tools, retrying or cancelling) completes in 16ms, so heavy models trigger only when execution paths split Plan at max power. Delegate at mid power. Keep Opus on standby On-call Opus 5.5 inspects overall session history and catches deep structural flaws Lead Sonnet 5.5 performs edits, writes core logic, and manages test environments Haiku 5.5 subagents run AST parsing, grep queries, and API doc analysis concurrently JEV micro-fork layer processes 1,500+ routing rules in under 16ms Expert model stays silent during basic terminal commands to preserve context window Configure my Claude Code workspace for hierarchical advisor orchestration: 1. Verify ~/.claude/settings.json and project-level configs for model role alignment (main, subagents, and advisor) Set main session model: sonnet with high effort level for primary execution Set subagents model: haiku with effortLevel: medium for parallel file discovery and doc gathering Set advisor model: opus on call for high-level analysis 2. Turn on the advisor tool inside ~/.claude/settings.json: Define advisorModel as claude-opus-5-5 Enable subagent parallel dispatcher pool (3x workers) 3. Establish automatic advisor review checkpoints in ~/.claude/CLAUDE.md: Call /advisor opus prior to finalizing multi-file architectural changes Trigger /advisor opus automatically whenever the same compiler or test error happens twice Require an advisor diff contract audit prior to completing tasks or staging git commits 4. Restrict subagent execution boundaries: Haiku subagents must return only structured AST summaries and doc snippets without bloating the primary session context Display all configuration diffs before applying changes. Do not commit modifications until confirmedshow more

Bober_smart

17,336 subscribers

15,632 görüntüleme • 2 gün önce •via X (Twitter)

Anya Rossi• Live Now

Private livecam show

45 Yorum

boan profil fotoğrafı

boan2 gün önce

opus on standby makes so much sense

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

The only thing that matters is seeing him

Madeactual profil fotoğrafı

Madeactual2 gün önce

We've been putting Opus on /advisor standby and letting Haiku swarm the grunt work while Sonnet owns the main branch. The bill drop is real once the architect stops rewriting every file itself.

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Yes, that is exactly how it works

Zentrix⌚️ profil fotoğrafı

Zentrix⌚️2 gün önce

People don't always want to hear the truth; they think someone is trying to deceive them

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Yes, that happens often

EugBass profil fotoğrafı

EugBass2 gün önce

really can't get why the fuck nobody is talking about this?

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Few people truly understood this

EugBass profil fotoğrafı

EugBass2 gün önce

yeah, it's a great wisdom

me_cool_off profil fotoğrafı

me_cool_off2 gün önce

smart setup fr

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Bro 👏

shmidt profil fotoğrafı

shmidt2 gün önce

u made something pretty useful bro

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Happy to be of service

Predict0r profil fotoğrafı

Predict0r2 gün önce

Cool! thanks for sharing!

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

I'm glad you found this useful

Dekos profil fotoğrafı

Dekos2 gün önce

This option looks really more economical.

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Yes, this contributes to significant savings

tenzo profil fotoğrafı

tenzo2 gün önce

smart model routing is the real win

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Truly smart people should use this

Andrii profil fotoğrafı

Andrii2 gün önce

Opus is only about complex solutions, while sonnets and haiku drag on routine

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

After all, every agent is busy with their own work

Ridark profil fotoğrafı

Ridark2 gün önce

You have a genuinely unique terminal with its own approach for real for sure honestly, how did you make it work?

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

I worked on this project for a long time

Alekzz profil fotoğrafı

Alekzz2 gün önce

Sonnet does the work, opus judges it. Just like my old job lol

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Everyone is busy with their own business

Mads profil fotoğrafı

Mads2 gün önce

Havent tried /advisor yet. Does Opus jump in by itself or do you have to call it ?

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

It does everything itself no additional actions are required

Mads profil fotoğrafı

Mads2 gün önce

Sounds interesting I will try it :)

BrainAI profil fotoğrafı

BrainAI2 gün önce

Bro, out of everything you've written, do you think Opus 5.5 would be the best choice for me? I need it for a very large project involving the automated generation of long, high-quality videos for YouTube.

RCOM profil fotoğrafı

RCOM2 gün önce

most of my spend goes on file discovery honestly, that part tracks

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

That is precisely why this option will help you save money

Gipp 🦅 profil fotoğrafı

Gipp 🦅2 gün önce

haiku subagents cut my file parse time by at least 2x

Bober_smart profil fotoğrafı

Bober_smart2 gün önce

Same here, buddy it's a shame I didn't know that sooner

Vlad profil fotoğrafı

Vlad2 gün önce

keeping routine file discovery separate from architectural judgment is a sensible way to preserve focus

Axel profil fotoğrafı

Axel2 gün önce

the three moments opus steps in make a lot of sense. have you noticed a big difference in cost since switching to this?

Insomnia profil fotoğrafı

Insomnia2 gün önce

it's what I need to see now

Amsterdam profil fotoğrafı

Amsterdam2 gün önce

Thx for sharing, us usual 🫱🏻‍🫲🏼

Phillip Karaya | Build With Phil profil fotoğrafı

Phillip Karaya | Build With Phil2 gün önce

Opus drafting buyer niceties while Haiku should have sorted the queue burned my Claude Code budget for a week. Sonnet on core replies and architect on standby fixed the mix. Swarm stays cheap now.

KKKKeF profil fotoğrafı

KKKKeF2 gün önce

cool

Alex Lee profil fotoğrafı

Alex Lee2 gün önce

Opus gets to be the boss while Haiku does all the digging 😂

Lutchyn profil fotoğrafı

Lutchyn2 gün önce

Parallel research keeps the main context clean

安叫兽|Bird🕊️ 🔶 BNB profil fotoğrafı

安叫兽|Bird🕊️ 🔶 BNB2 gün önce

低端活交给 Haiku，Opus 去待机，这资源分配确实挺务实。

Sevenup profil fotoğrafı

Sevenup2 gün önce

I can review your Claude Code configs, propose the Sonnet/Haiku/Opus hierarchy, and show all diffs before applying anything. No changes or commits until you confirm.

swapcherry profil fotoğrafı

swapcherry2 gün önce

NOBODY IS TALKING ABOUT IT BECAUSE IT'S MADE UP

J Huang profil fotoğrafı

J Huang2 gün önce

lol fair, opus doing grep was always a little embarrassing

Benzer Videolar

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.5 builds put the architect on call with /advisor claude --advisor opus --subagents haiku Sonnet 5.5 drives the primary session on high effort, writing diffs and running test suites Haiku 5.5 subagents swarm the repo in parallel at 340 tok/s, 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.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) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep Opus on call. - the full advisor setup > Opus 5.5 on call reads full session history and catches deep architectural traps > Sonnet 5.5 lead drives edits, writes core logic, and executes test harnesses > Haiku 5.5 subagents swarm AST parsing, grep scans, and API docs in parallel > JEV micro-fork layer resolves 1,500+ mechanical routing branches in under 16ms > advisor stays completely silent on routine bash execution to protect context 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 model: haiku with effortLevel: medium for parallel file discovery and docs retrieval > Pin advisor model: opus on call for strategic review 2. Enable the advisor tool in ~/.claude/settings.json: > Set advisorModel to claude-opus-5-5 > Enable subagent parallel dispatcher pool (3x workers) 3. Configure automatic advisor consultation checkpoints in ~/.claude/CLAUDE.md: > Consult /advisor opus before finalizing multi-file architecture plans > Automatically summon /advisor opus when the same test or compiler error fails twice > Enforce advisor diff contract audit before declaring tasks complete or staging git commits 4. Constrain subagent scopes: > Haiku subagents return structured AST summaries and docs snippets only without modifying main session context Show every configuration diff first. Do not apply edits until confirmed" ↳

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.5 builds put the architect on call with /advisor claude --advisor opus --subagents haiku Sonnet 5.5 drives the primary session on high effort, writing diffs and running test suites Haiku 5.5 subagents swarm the repo in parallel at 340 tok/s, 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.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) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep Opus on call. - the full advisor setup > Opus 5.5 on call reads full session history and catches deep architectural traps > Sonnet 5.5 lead drives edits, writes core logic, and executes test harnesses > Haiku 5.5 subagents swarm AST parsing, grep scans, and API docs in parallel > JEV micro-fork layer resolves 1,500+ mechanical routing branches in under 16ms > advisor stays completely silent on routine bash execution to protect context 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 model: haiku with effortLevel: medium for parallel file discovery and docs retrieval > Pin advisor model: opus on call for strategic review 2. Enable the advisor tool in ~/.claude/settings.json: > Set advisorModel to claude-opus-5-5 > Enable subagent parallel dispatcher pool (3x workers) 3. Configure automatic advisor consultation checkpoints in ~/.claude/CLAUDE.md: > Consult /advisor opus before finalizing multi-file architecture plans > Automatically summon /advisor opus when the same test or compiler error fails twice > Enforce advisor diff contract audit before declaring tasks complete or staging git commits 4. Constrain subagent scopes: > Haiku subagents return structured AST summaries and docs snippets only without modifying main session context Show every configuration diff first. Do not apply edits until confirmed" ↳

mirku

741,223 görüntüleme • 5 gün önce

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" ↳

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

16,551 görüntüleme • 3 gün önce

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.5 builds put the architect on call with custom subagents CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet Sonnet 5.5 drives the primary session on high effort, writing diffs and running test suites Haiku 5.5 subagents swarm the repo in parallel at 340 tok/s, handling file discovery and spec docs lookup Opus 5.5 stays on call in ~/.claude/agents/ as the code reviewer, 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.5 builds. Haiku 5.5 swarms Claude Code subagent architecture runs the identical pattern through isolated contexts: high-volume operations (reading 30 files, grepping AST, running test suites) execute in separate worktrees, so 400k+ tokens stay in subagents while the primary session keeps a pristine 14k context Plan on high. Delegate on medium. Keep Opus on call. - the full subagent swarm setup > Opus 5.5 on call in ~/.claude/agents/code-reviewer.md catches deep architectural traps > Sonnet 5.5 lead drives edits, writes core logic, and executes test harnesses > Haiku 5.5 subagents swarm AST parsing, grep scans, and API docs in parallel at 340 tok/s > isolation: worktree guarantees test runs and scratch edits never pollute your git tree > isolated context windows shield the primary session from 400k+ tokens of verbose output paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for hierarchical subagent orchestration: 1. Audit ~/.claude/settings.json and project config for model roles fitting lead, subagents, and reviewer: > Pin main session model: sonnet with effortLevel: high for primary execution > Set CLAUDE_CODE_SUBAGENT_MODEL to haiku in settings.json with CLAUDE_CODE_SUBAGENT_MODEL_FORCE to 1 > Pin custom code-reviewer model: opus with effort: high in ~/.claude/agents/code-reviewer.md 2. Create specialized subagent files in ~/.claude/agents/: > code-reviewer.md: model: opus, tools: Read, Grep, Glob, read-only review of plans and diffs > explorer.md: model: haiku, tools: Read, Grep, Glob, fast codebase search and AST discovery > researcher.md: model: haiku, tools: Read, WebFetch, external documentation and specification lookup 3. Configure automatic delegation checkpoints in ~/.claude/CLAUDE.md: > Invoke @ code-reviewer before finalizing multi-file architecture plans > Automatically summon @ code-reviewer when the same test or compiler error fails twice > Enforce @ code-reviewer diff contract audit before declaring tasks complete or staging git commits 4. Constrain subagent scopes: > Enable isolation: worktree for subagents making edits or running test harnesses > Return structured summaries only without flooding the main conversation context Show every configuration diff first. Do not apply edits until confirmed" ↳

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.5 builds put the architect on call with custom subagents CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet Sonnet 5.5 drives the primary session on high effort, writing diffs and running test suites Haiku 5.5 subagents swarm the repo in parallel at 340 tok/s, handling file discovery and spec docs lookup Opus 5.5 stays on call in ~/.claude/agents/ as the code reviewer, 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.5 builds. Haiku 5.5 swarms Claude Code subagent architecture runs the identical pattern through isolated contexts: high-volume operations (reading 30 files, grepping AST, running test suites) execute in separate worktrees, so 400k+ tokens stay in subagents while the primary session keeps a pristine 14k context Plan on high. Delegate on medium. Keep Opus on call. - the full subagent swarm setup > Opus 5.5 on call in ~/.claude/agents/code-reviewer.md catches deep architectural traps > Sonnet 5.5 lead drives edits, writes core logic, and executes test harnesses > Haiku 5.5 subagents swarm AST parsing, grep scans, and API docs in parallel at 340 tok/s > isolation: worktree guarantees test runs and scratch edits never pollute your git tree > isolated context windows shield the primary session from 400k+ tokens of verbose output paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for hierarchical subagent orchestration: 1. Audit ~/.claude/settings.json and project config for model roles fitting lead, subagents, and reviewer: > Pin main session model: sonnet with effortLevel: high for primary execution > Set CLAUDE_CODE_SUBAGENT_MODEL to haiku in settings.json with CLAUDE_CODE_SUBAGENT_MODEL_FORCE to 1 > Pin custom code-reviewer model: opus with effort: high in ~/.claude/agents/code-reviewer.md 2. Create specialized subagent files in ~/.claude/agents/: > code-reviewer.md: model: opus, tools: Read, Grep, Glob, read-only review of plans and diffs > explorer.md: model: haiku, tools: Read, Grep, Glob, fast codebase search and AST discovery > researcher.md: model: haiku, tools: Read, WebFetch, external documentation and specification lookup 3. Configure automatic delegation checkpoints in ~/.claude/CLAUDE.md: > Invoke @ code-reviewer before finalizing multi-file architecture plans > Automatically summon @ code-reviewer when the same test or compiler error fails twice > Enforce @ code-reviewer diff contract audit before declaring tasks complete or staging git commits 4. Constrain subagent scopes: > Enable isolation: worktree for subagents making edits or running test harnesses > Return structured summaries only without flooding the main conversation context Show every configuration diff first. Do not apply edits until confirmed" ↳

mirku

99,082 görüntüleme • 2 gün önce

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.

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

288,285 görüntüleme • 1 gün önce

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."

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

55,249 görüntüleme • 5 gün önce

Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle and stop burning Opus tokens on tasks Sonnet 5.5 can swarm put it on call with /advisor run /advisor fable Opus 5.5 plans and ships the code Sonnet 5.5 swarms the routine work at medium effort 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? Fable 5.1 reviews. Sonnet 5.5 executes. 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 model only sees the ones that split Plan on high. Delegate on medium. Keep Fable on call. - 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 at medium effort > 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: 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, 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." ↳

Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle and stop burning Opus tokens on tasks Sonnet 5.5 can swarm put it on call with /advisor run /advisor fable Opus 5.5 plans and ships the code Sonnet 5.5 swarms the routine work at medium effort 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? Fable 5.1 reviews. Sonnet 5.5 executes. 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 model only sees the ones that split Plan on high. Delegate on medium. Keep Fable on call. - 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 at medium effort > 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: 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, 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." ↳

mirku

421,711 görüntüleme • 13 gün önce

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." ↳

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,001 görüntüleme • 10 gün önce

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." ↳

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,494 görüntüleme • 9 gün önce

holy sh*t. Official Anthropic tip for Claude Code: Once Opus 5.5 is your main model, stop leaving Haiku 5.5 sitting idle and stop burning Opus tokens on sweeps Sonnet 5.5 and Haiku 5.5 can tear through turn mass-agent sweeps into deterministic code with /workflows claude --effort ultracode Opus 5.5 authors the workflow script and synthesizes the final PR Sonnet 5.5 executes precision refactors in isolated worktrees at medium effort Haiku 5.5 runs at 340 tok/s as the dedicated pipeline filter, cutting cognitive load at three critical bottlenecks: → before dispatch: sweeps the full codebase in parallel to extract AST candidates without context bloat → on schema validation: drops malformed tool calls and false positives before Sonnet touches them → before synthesis: verifies that every candidate strictly conforms to the target JSON schema Haiku 5.5 filters. Sonnet 5.5 refactors. 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) resolve in V8 in 16ms, and frontier models only wake up when execution paths actually split Author on high. Refactor on medium. Keep Haiku at 340 tok/s. - the full workflow architecture > Opus 5.5 on high drafts the workflow script in .claude/workflows/ > pipeline() fans out Haiku 5.5 at 340 tok/s across target files > parallel() schema fuzzers drop false positives before patch generation > Sonnet 5.5 refactors verified files in isolated git worktrees > intermediate state lives in V8 variables, keeping context drag at 0 tokens > 1h prompt cache prefix hold eliminates redundant system prompt processing paste the setup and this prompt into Claude Code ↓ "Configure my Claude Code workspace for dynamic workflows: 1. Audit ~/.claude/workflows and .claude/workflows for existing scripts: > Draft workflow definitions for codebase audits, parallel migrations, and schema validation > Pin model: haiku, effort: low for AST sweepers, and model: sonnet, effort: medium for refactor workers > Configure workers to operate in isolated git worktrees to eliminate edit conflicts 2. In ~/.claude/settings.json, enable dynamic workflows: > Set ultracode = true > Lock main session effortLevel to high > Set subagentPromptCacheTtl = '1h' to share prompt prefixes across parallel fan-outs 3. Set workflow runtime controls: > Set autoContinueAtUsageLimit = true so long batch runs automatically resume after limit resets > Set CLAUDE_CODE_WORKFLOW_PREFIX_STAGGER_MS = 5000 for prompt prefix caching > Set large workflow warning threshold to 25 agents 4. Add a rule to ~/.claude/CLAUDE.md: all multi-file refactors must pass an adversarial Haiku schema check before patches merge to main Show me every change as a diff first. No edits until I say go." ↳

holy sh*t. Official Anthropic tip for Claude Code: Once Opus 5.5 is your main model, stop leaving Haiku 5.5 sitting idle and stop burning Opus tokens on sweeps Sonnet 5.5 and Haiku 5.5 can tear through turn mass-agent sweeps into deterministic code with /workflows claude --effort ultracode Opus 5.5 authors the workflow script and synthesizes the final PR Sonnet 5.5 executes precision refactors in isolated worktrees at medium effort Haiku 5.5 runs at 340 tok/s as the dedicated pipeline filter, cutting cognitive load at three critical bottlenecks: → before dispatch: sweeps the full codebase in parallel to extract AST candidates without context bloat → on schema validation: drops malformed tool calls and false positives before Sonnet touches them → before synthesis: verifies that every candidate strictly conforms to the target JSON schema Haiku 5.5 filters. Sonnet 5.5 refactors. 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) resolve in V8 in 16ms, and frontier models only wake up when execution paths actually split Author on high. Refactor on medium. Keep Haiku at 340 tok/s. - the full workflow architecture > Opus 5.5 on high drafts the workflow script in .claude/workflows/ > pipeline() fans out Haiku 5.5 at 340 tok/s across target files > parallel() schema fuzzers drop false positives before patch generation > Sonnet 5.5 refactors verified files in isolated git worktrees > intermediate state lives in V8 variables, keeping context drag at 0 tokens > 1h prompt cache prefix hold eliminates redundant system prompt processing paste the setup and this prompt into Claude Code ↓ "Configure my Claude Code workspace for dynamic workflows: 1. Audit ~/.claude/workflows and .claude/workflows for existing scripts: > Draft workflow definitions for codebase audits, parallel migrations, and schema validation > Pin model: haiku, effort: low for AST sweepers, and model: sonnet, effort: medium for refactor workers > Configure workers to operate in isolated git worktrees to eliminate edit conflicts 2. In ~/.claude/settings.json, enable dynamic workflows: > Set ultracode = true > Lock main session effortLevel to high > Set subagentPromptCacheTtl = '1h' to share prompt prefixes across parallel fan-outs 3. Set workflow runtime controls: > Set autoContinueAtUsageLimit = true so long batch runs automatically resume after limit resets > Set CLAUDE_CODE_WORKFLOW_PREFIX_STAGGER_MS = 5000 for prompt prefix caching > Set large workflow warning threshold to 25 agents 4. Add a rule to ~/.claude/CLAUDE.md: all multi-file refactors must pass an adversarial Haiku schema check before patches merge to main Show me every change as a diff first. No edits until I say go." ↳

mirku

17,367 görüntüleme • 3 gün önce

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." ↳

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

27,459 görüntüleme • 11 gün önce

holy f*ck. Official Anthropic tip for Claude Code: stop running agent teams on Opus and Sonnet 5.5 alone when Haiku 5.5 can swarm the bus at 340 tok/s spin up an autonomous team with /teams claude --teammate-mode auto Opus 5.5 acts as the lead architect, scoping architecture and validating pull requests Sonnet 5.5 teammates take isolated git worktrees and hammer out implementations at medium effort Haiku 5.5 swarms the peer-to-peer bus as a dedicated scout and fuzzer, only stepping in at three critical moments: → before a contract locks: does the frontend payload match the backend schema? → when a test breaks twice: are we patching the bug or just hiding the symptom? → before calling done: what attack surface or edge race did everyone overlook? Sonnet 5.5 builds. Haiku 5.5 swarms. Opus 5.5 merges and ships 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) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep Haiku 5.5 on P2P call. - the full team setup > Opus 5.5 on high coordinates the session and synthesizes PRs > teammate-ux builds client state inside a separate git worktree > teammate-back writes endpoints and handles Redis atomic locks > teammate-scout runs invariant fuzzing and AST parsing on Haiku 5.5 at 340 tok/s > all teammates communicate directly over peer-to-peer messaging without coordinator drag > tasks.json manages file-level mutex locks so nobody steps on another worktree paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for autonomous agent teams: 1. Enable experimental agent teams in ~/.claude/settings.json: > Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS to 1 in env block > Set teammateMode to auto > Pin main lead model: opus with effortLevel: high 2. Audit ~/.claude/agents and create teammate profiles fitting ux, backend, and scout: > teammate-ux: model: sonnet, effort: medium, isolation: worktree > teammate-back: model: sonnet, effort: medium, isolation: worktree > teammate-scout: model: haiku, tools: Read, Grep, Glob, SendMessage 3. Configure shared task coordination in ~/.claude/CLAUDE.md: > Initialize tasks.json for task dependencies and atomic file mutexes > Teammates resolve contracts directly over peer-to-peer messaging without lead intervention > Enforce Haiku scout schema verification before teammates mark tasks completed 4. Quality gate: > Opus lead reviews synthesized worktree diffs and validates test suites before final merge Show every configuration diff first. Do not apply edits until confirmed" ↳

holy f*ck. Official Anthropic tip for Claude Code: stop running agent teams on Opus and Sonnet 5.5 alone when Haiku 5.5 can swarm the bus at 340 tok/s spin up an autonomous team with /teams claude --teammate-mode auto Opus 5.5 acts as the lead architect, scoping architecture and validating pull requests Sonnet 5.5 teammates take isolated git worktrees and hammer out implementations at medium effort Haiku 5.5 swarms the peer-to-peer bus as a dedicated scout and fuzzer, only stepping in at three critical moments: → before a contract locks: does the frontend payload match the backend schema? → when a test breaks twice: are we patching the bug or just hiding the symptom? → before calling done: what attack surface or edge race did everyone overlook? Sonnet 5.5 builds. Haiku 5.5 swarms. Opus 5.5 merges and ships 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) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep Haiku 5.5 on P2P call. - the full team setup > Opus 5.5 on high coordinates the session and synthesizes PRs > teammate-ux builds client state inside a separate git worktree > teammate-back writes endpoints and handles Redis atomic locks > teammate-scout runs invariant fuzzing and AST parsing on Haiku 5.5 at 340 tok/s > all teammates communicate directly over peer-to-peer messaging without coordinator drag > tasks.json manages file-level mutex locks so nobody steps on another worktree paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for autonomous agent teams: 1. Enable experimental agent teams in ~/.claude/settings.json: > Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS to 1 in env block > Set teammateMode to auto > Pin main lead model: opus with effortLevel: high 2. Audit ~/.claude/agents and create teammate profiles fitting ux, backend, and scout: > teammate-ux: model: sonnet, effort: medium, isolation: worktree > teammate-back: model: sonnet, effort: medium, isolation: worktree > teammate-scout: model: haiku, tools: Read, Grep, Glob, SendMessage 3. Configure shared task coordination in ~/.claude/CLAUDE.md: > Initialize tasks.json for task dependencies and atomic file mutexes > Teammates resolve contracts directly over peer-to-peer messaging without lead intervention > Enforce Haiku scout schema verification before teammates mark tasks completed 4. Quality gate: > Opus lead reviews synthesized worktree diffs and validates test suites before final merge Show every configuration diff first. Do not apply edits until confirmed" ↳

mirku

84,274 görüntüleme • 4 gün önce

$this is pure f*cking treasure Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle and stop burning Opus tokens on tasks Sonnet 5.5 can swarm put it on call with /goal claude --auto-mode "/goal all tests pass and lint is clean" Opus 5.5 keeps writing the code in auto mode Sonnet 5.5 swarms the routine work at medium Fable 5.1 inspects the full transcript and only speaks up at the turn boundary: → not yet met: am I drifting from acceptance criteria? → met: do the tests, diffs, and lint hold? → impossible: am I chasing an unreachable state? Fable grades. Opus ships JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or halt) go to JEV in under 16ms, and the big models only see the ones that split — the full tree > Opus 5.5 on high runs the main session > worker edits and patches code on Sonnet 5.5 > explorer indexes AST maps and call sites on Sonnet 5.5 > verifier runs tests and linters on Sonnet 5.5 > all three subagents on medium effort > Fable 5.1 on call as the Stop hook evaluator > JEV routes micro-forks under 16ms paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Set the main session to Opus 5.5 on high effort with auto mode enabled. 2. Put Fable 5.1 on call as a session-scoped evaluator attached to the Stop hook: - Read-only transcript evaluation with zero tool calls - Three structured outcomes: not yet met (with steering notes), met (auto-clear), and impossible (abort early) 3. Spawn Sonnet 5.5 subagents on medium effort for worker, explorer, and verifier roles. Defer goal checks while background tasks run. 4. Route fast deterministic forks (tool resolution, path selection, auto-retries) through JEV. 5. Add one rule to CLAUDE.md: run long tasks with: claude --auto-mode \"/goal \" Show me every configuration change as a diff first. No edits until I say go." ↳$

this is pure f*cking treasure Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle and stop burning Opus tokens on tasks Sonnet 5.5 can swarm put it on call with /goal claude --auto-mode "/goal all tests pass and lint is clean" Opus 5.5 keeps writing the code in auto mode Sonnet 5.5 swarms the routine work at medium Fable 5.1 inspects the full transcript and only speaks up at the turn boundary: → not yet met: am I drifting from acceptance criteria? → met: do the tests, diffs, and lint hold? → impossible: am I chasing an unreachable state? Fable grades. Opus ships JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or halt) go to JEV in under 16ms, and the big models only see the ones that split — the full tree > Opus 5.5 on high runs the main session > worker edits and patches code on Sonnet 5.5 > explorer indexes AST maps and call sites on Sonnet 5.5 > verifier runs tests and linters on Sonnet 5.5 > all three subagents on medium effort > Fable 5.1 on call as the Stop hook evaluator > JEV routes micro-forks under 16ms paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Set the main session to Opus 5.5 on high effort with auto mode enabled. 2. Put Fable 5.1 on call as a session-scoped evaluator attached to the Stop hook: - Read-only transcript evaluation with zero tool calls - Three structured outcomes: not yet met (with steering notes), met (auto-clear), and impossible (abort early) 3. Spawn Sonnet 5.5 subagents on medium effort for worker, explorer, and verifier roles. Defer goal checks while background tasks run. 4. Route fast deterministic forks (tool resolution, path selection, auto-retries) through JEV. 5. Add one rule to CLAUDE.md: run long tasks with: claude --auto-mode \"/goal \" Show me every configuration change as a diff first. No edits until I say go." ↳

mirku

41,562 görüntüleme • 6 gün önce

Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle put it on call with /advisor run /advisor fable Opus 5.5 keeps writing the code 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? 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 model only sees 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 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: opus, 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, 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." ↳

Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle put it on call with /advisor run /advisor fable Opus 5.5 keeps writing the code 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? 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 model only sees 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 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: opus, 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, 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

697,625 görüntüleme • 14 gün önce

Claude Code tip: once Opus 5.5 runs your main session, stop leaving Fable 5.1 on the bench put it on call with /advisor run /advisor fable Opus 5.5 keeps writing the code Fable 5.1 reads the whole session, every tool call included, and only speaks up at three moments: → 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? 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 model only sees 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 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: opus, 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, 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." ↳

Claude Code tip: once Opus 5.5 runs your main session, stop leaving Fable 5.1 on the bench put it on call with /advisor run /advisor fable Opus 5.5 keeps writing the code Fable 5.1 reads the whole session, every tool call included, and only speaks up at three moments: → 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? 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 model only sees 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 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: opus, 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, 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." ↳

Hanako

52,065 görüntüleme • 12 gün önce

Official Anthropic tip for Claude Code: stop burning Opus 5.5 context on tasks Sonnet 5.5 can swarm, while Fable 5.1 sits idle spin up an autonomous team with /teams claude --teammates ux,backend,adversary Opus 5.5 acts as the lead architect, scoping architecture and validating pull requests Sonnet 5.5 teammates take isolated git worktrees and hammer out implementations at medium effort Fable 5.1 monitors the peer-to-peer bus as a dedicated adversary, only stepping in at three critical moments: → before a contract locks: does the frontend payload match the backend schema? → when a test breaks twice: are we patching the bug or just hiding the symptom? → before calling done: what attack surface or edge case did everyone overlook? Sonnet 5.5 builds. Fable 5.1 challenges. Opus 5.5 merges and ships 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) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep the adversary on peer-to-peer call. - the full team setup > Opus 5.5 on high coordinates the session and synthesizes PRs > teammate-ux builds client state inside a separate git worktree > teammate-back writes endpoints and handles Redis atomic locks > teammate-adv runs invariant fuzzing and catches replay vulnerabilities > all teammates communicate directly over peer-to-peer messaging without coordinator drag > tasks.json manages file-level mutex locks so nobody steps on another worktree paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for autonomous agent teams: 1. Audit ~/.claude/teams and .claude/teams for teammate profiles fitting ux, backend, and adversary > Generate definitions only for missing roles > Pin model: sonnet, effort: medium for workers, and model: fable for adversary > Assign each worker an isolated git worktree branch to eliminate file conflicts 2. Enable agent teams in ~/.claude/settings.json: > Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 > Lock main session effortLevel to high 3. Initialize tasks.json in repo root with atomic file locking, allowing teammates to claim subtasks and resolve contracts directly over inter-agent messaging without coordinator intervention 4. Add a team rule to ~/.claude/CLAUDE.md: teammates must request an adversary security review before opening a pull request for the lead session Show every configuration diff first. Do not apply edits until confirmed" ↳

Official Anthropic tip for Claude Code: stop burning Opus 5.5 context on tasks Sonnet 5.5 can swarm, while Fable 5.1 sits idle spin up an autonomous team with /teams claude --teammates ux,backend,adversary Opus 5.5 acts as the lead architect, scoping architecture and validating pull requests Sonnet 5.5 teammates take isolated git worktrees and hammer out implementations at medium effort Fable 5.1 monitors the peer-to-peer bus as a dedicated adversary, only stepping in at three critical moments: → before a contract locks: does the frontend payload match the backend schema? → when a test breaks twice: are we patching the bug or just hiding the symptom? → before calling done: what attack surface or edge case did everyone overlook? Sonnet 5.5 builds. Fable 5.1 challenges. Opus 5.5 merges and ships 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) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep the adversary on peer-to-peer call. - the full team setup > Opus 5.5 on high coordinates the session and synthesizes PRs > teammate-ux builds client state inside a separate git worktree > teammate-back writes endpoints and handles Redis atomic locks > teammate-adv runs invariant fuzzing and catches replay vulnerabilities > all teammates communicate directly over peer-to-peer messaging without coordinator drag > tasks.json manages file-level mutex locks so nobody steps on another worktree paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for autonomous agent teams: 1. Audit ~/.claude/teams and .claude/teams for teammate profiles fitting ux, backend, and adversary > Generate definitions only for missing roles > Pin model: sonnet, effort: medium for workers, and model: fable for adversary > Assign each worker an isolated git worktree branch to eliminate file conflicts 2. Enable agent teams in ~/.claude/settings.json: > Set CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 > Lock main session effortLevel to high 3. Initialize tasks.json in repo root with atomic file locking, allowing teammates to claim subtasks and resolve contracts directly over inter-agent messaging without coordinator intervention 4. Add a team rule to ~/.claude/CLAUDE.md: teammates must request an adversary security review before opening a pull request for the lead session Show every configuration diff first. Do not apply edits until confirmed" ↳

mirku

177,891 görüntüleme • 11 gün önce

Claude Code tip: stop burning Opus 5.5 context on tasks Sonnet 5.5 can swarm, while Fable 5.1 sits idle spin up an autonomous team with --agent claude --agent architect Opus 5.5 acts as the lead architect, scoping the work and validating every worktree before it merges Sonnet 5.5 teammates take isolated git worktrees and hammer out implementations at medium effort Fable 5.1 sits on the team as a dedicated adversary, only stepping in at three critical moments: → before a contract locks: does the frontend payload match the backend schema? → when a test breaks twice: are we patching the bug or just hiding the symptom? → before the merge: what attack surface or edge case did everyone overlook? Sonnet 5.5 builds. Fable 5.1 challenges. Opus 5.5 merges and ships 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) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep the adversary on peer-to-peer call. - the full team setup > architect runs the main session on Opus 5.5 at high effort > teammate-ux builds client state inside its own git worktree > teammate-back writes endpoints and migrations inside a separate worktree > teammate-adv runs on Fable 5.1, read-only, and attacks every diff > teammates message each other by name without routing through the lead > tools: Agent(ux, backend, adversary) locks the architect to spawning only its own team paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for an autonomous agent team: 1. Audit ~/.claude/agents and .claude/agents for definitions fitting architect, ux, backend and adversary > Generate definitions only for missing roles > Pin model: sonnet, effort: medium, isolation: worktree for ux and backend, and model: fable with read-only tools for adversary > Give architect model: opus, effort: high and tools: Agent(ux, backend, adversary) 2. Check ~/.claude/settings.json and my env: > Report CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS if it's set, since it turns named subagents into teammates without worktrees > Report CLAUDE_CODE_SUBAGENT_MODEL_FORCE and CLAUDE_CODE_EFFORT_LEVEL, which can override the pinned models and effort 3. Write each role's prompt so ux and backend own separate folders, message each other by name when a contract changes, and hand every diff to adversary before reporting back 4. Add a team rule to ~/.claude/CLAUDE.md: no worktree merges until adversary has reviewed it Show every configuration diff first. Do not apply edits until confirmed" save it

Claude Code tip: stop burning Opus 5.5 context on tasks Sonnet 5.5 can swarm, while Fable 5.1 sits idle spin up an autonomous team with --agent claude --agent architect Opus 5.5 acts as the lead architect, scoping the work and validating every worktree before it merges Sonnet 5.5 teammates take isolated git worktrees and hammer out implementations at medium effort Fable 5.1 sits on the team as a dedicated adversary, only stepping in at three critical moments: → before a contract locks: does the frontend payload match the backend schema? → when a test breaks twice: are we patching the bug or just hiding the symptom? → before the merge: what attack surface or edge case did everyone overlook? Sonnet 5.5 builds. Fable 5.1 challenges. Opus 5.5 merges and ships 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) execute in 16ms, so the frontier models only wake up when execution paths actually diverge Plan on high. Delegate on medium. Keep the adversary on peer-to-peer call. - the full team setup > architect runs the main session on Opus 5.5 at high effort > teammate-ux builds client state inside its own git worktree > teammate-back writes endpoints and migrations inside a separate worktree > teammate-adv runs on Fable 5.1, read-only, and attacks every diff > teammates message each other by name without routing through the lead > tools: Agent(ux, backend, adversary) locks the architect to spawning only its own team paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for an autonomous agent team: 1. Audit ~/.claude/agents and .claude/agents for definitions fitting architect, ux, backend and adversary > Generate definitions only for missing roles > Pin model: sonnet, effort: medium, isolation: worktree for ux and backend, and model: fable with read-only tools for adversary > Give architect model: opus, effort: high and tools: Agent(ux, backend, adversary) 2. Check ~/.claude/settings.json and my env: > Report CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS if it's set, since it turns named subagents into teammates without worktrees > Report CLAUDE_CODE_SUBAGENT_MODEL_FORCE and CLAUDE_CODE_EFFORT_LEVEL, which can override the pinned models and effort 3. Write each role's prompt so ux and backend own separate folders, message each other by name when a contract changes, and hand every diff to adversary before reporting back 4. Add a team rule to ~/.claude/CLAUDE.md: no worktree merges until adversary has reviewed it Show every configuration diff first. Do not apply edits until confirmed" save it

Khairallah AL-Awady

32,018 görüntüleme • 6 gün önce

This is f*cking insane. This tip saved me thousands of dollars. run Opus 5.5, Sonnet 5.5, and Fable 5.1 together, and stop burning Opus on work it was never needed for. the whole idea in one line: the strong model plans, the mid-tier model executes, Fable stays quiet until it's actually needed. roles, broken down: Opus 5.5, high effort, owns the plan and ships the final code Sonnet 5.5, medium effort, splits into explorer (reads the codebase), worker (edits files, runs tests), researcher (pulls docs) Fable 5.1, called through /advisor fable, reads everything happening in the session but stays silent unless something's actually wrong three moments where Fable speaks: → a plan goes out: is this actually the right call? → the same failure shows up again: is the search going nowhere? → the task gets marked finished: did something get skipped? Jev engineering does the same thing one level down. the forks that don't need real thought, which file, which tool, keep going or stop, go straight to Jev and come back in under half a second. the big models only ever see the forks that genuinely need a decision. anyone still running one model for everything is paying Opus prices to decide whether a file exists. drop this into Claude Code: "Rebuild my Claude Code setup around this structure: 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: sonnet, effort: medium on each. If an existing subagent is locked to a different model, leave it as is and just list it. In ~/.claude/settings.json, set effortLevel to high and advisorModel to fable. Check for anything disabling the advisor, CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, or anything blocking feature-flag fetches, plus CLAUDE_CODE_EFFORT_LEVEL, which can override subagent effort settings. Report what you find. Don't change any of it yet. Add one line to ~/.claude/CLAUDE.md: check in with 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."

This is f*cking insane. This tip saved me thousands of dollars. run Opus 5.5, Sonnet 5.5, and Fable 5.1 together, and stop burning Opus on work it was never needed for. the whole idea in one line: the strong model plans, the mid-tier model executes, Fable stays quiet until it's actually needed. roles, broken down: Opus 5.5, high effort, owns the plan and ships the final code Sonnet 5.5, medium effort, splits into explorer (reads the codebase), worker (edits files, runs tests), researcher (pulls docs) Fable 5.1, called through /advisor fable, reads everything happening in the session but stays silent unless something's actually wrong three moments where Fable speaks: → a plan goes out: is this actually the right call? → the same failure shows up again: is the search going nowhere? → the task gets marked finished: did something get skipped? Jev engineering does the same thing one level down. the forks that don't need real thought, which file, which tool, keep going or stop, go straight to Jev and come back in under half a second. the big models only ever see the forks that genuinely need a decision. anyone still running one model for everything is paying Opus prices to decide whether a file exists. drop this into Claude Code: "Rebuild my Claude Code setup around this structure: 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: sonnet, effort: medium on each. If an existing subagent is locked to a different model, leave it as is and just list it. In ~/.claude/settings.json, set effortLevel to high and advisorModel to fable. Check for anything disabling the advisor, CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, or anything blocking feature-flag fetches, plus CLAUDE_CODE_EFFORT_LEVEL, which can override subagent effort settings. Report what you find. Don't change any of it yet. Add one line to ~/.claude/CLAUDE.md: check in with 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."

rvaniaaa

251,711 görüntüleme • 10 gün önce

Official Anthropic tip for Claude Code: don't exhaust Opus 5.5 context on repetitive multi-file routines when Sonnet 5.5 can swarm them in parallel and Fable 5.1 can verify the result turn mass-agent sweeps into deterministic code with dynamic workflows claude --effort ultracode /workflows Opus 5.5 acts as the lead architect, drafting the workflow script, setting input schemas, and synthesizing final verified reports Sonnet 5.5 workers swarm the execution pipeline across dozens of files, handling bulk refactors and migrations at medium effort Fable 5.1 stands by as the dedicated verifier, entering the pipeline at three decisive moments: → before a fan-out: does this workload justify a 50-agent script or can a tight 5-step pipeline solve it? → on worker failure: can the step replay from cache or does the pipeline branch need a clean rerun? → before reporting: did every reported finding survive adversarial cross-checking and voting? Sonnet 5.5 executes. Fable 5.1 cross-examines. Opus 5.5 authors and reports Jev engineering runs the identical pattern one layer down: mechanical choices that need no cognitive reasoning (which file to inspect, which tool to invoke, retry or stop) resolve in 16ms, so frontier models only wake up when execution paths actually split Plan on high. Delegate on medium. Keep Fable on call. - the full workflow architecture > Opus 5.5 on high drafts the orchestration script inside .claude/workflows/ > pipeline() fans out Sonnet 5.5 workers across target paths concurrently > each worker operates inside an isolated working copy to eliminate file collisions > Fable 5.1 cross-checks claims and votes down unverified findings > intermediate state lives in script variables, leaving Claude's context 100% clean > 1h prompt cache prefix hold eliminates redundant system prompt processing paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for dynamic workflows: 1. Audit ~/.claude/workflows and .claude/workflows for existing scripts: > Draft workflow definitions for codebase audits, parallel migrations, and adversarial verification > Pin model: sonnet, effort: medium for pipeline workers, and model: fable for verifier agents > Configure workers to operate on isolated copies to eliminate edit conflicts 2. In ~/.claude/settings.json, enable dynamic workflows: > Set ultracode = true > Lock main session effortLevel to high > Set subagentPromptCacheTtl = '1h' to share prompt prefixes across parallel fan-outs 3. Set workflow runtime controls: > Set autoContinueAtUsageLimit = true so long batch runs automatically resume after limit resets > Set CLAUDE_CODE_WORKFLOW_PREFIX_STAGGER_MS = 5000 for prompt prefix caching > Set large workflow warning threshold to 25 agents 4. Add a rule to ~/.claude/CLAUDE.md: all multi-file audits must pass an adversarial Fable cross-check before findings are reported to the lead session Show every configuration diff first. Do not apply edits until confirmed" ↳

Official Anthropic tip for Claude Code: don't exhaust Opus 5.5 context on repetitive multi-file routines when Sonnet 5.5 can swarm them in parallel and Fable 5.1 can verify the result turn mass-agent sweeps into deterministic code with dynamic workflows claude --effort ultracode /workflows Opus 5.5 acts as the lead architect, drafting the workflow script, setting input schemas, and synthesizing final verified reports Sonnet 5.5 workers swarm the execution pipeline across dozens of files, handling bulk refactors and migrations at medium effort Fable 5.1 stands by as the dedicated verifier, entering the pipeline at three decisive moments: → before a fan-out: does this workload justify a 50-agent script or can a tight 5-step pipeline solve it? → on worker failure: can the step replay from cache or does the pipeline branch need a clean rerun? → before reporting: did every reported finding survive adversarial cross-checking and voting? Sonnet 5.5 executes. Fable 5.1 cross-examines. Opus 5.5 authors and reports Jev engineering runs the identical pattern one layer down: mechanical choices that need no cognitive reasoning (which file to inspect, which tool to invoke, retry or stop) resolve in 16ms, so frontier models only wake up when execution paths actually split Plan on high. Delegate on medium. Keep Fable on call. - the full workflow architecture > Opus 5.5 on high drafts the orchestration script inside .claude/workflows/ > pipeline() fans out Sonnet 5.5 workers across target paths concurrently > each worker operates inside an isolated working copy to eliminate file collisions > Fable 5.1 cross-checks claims and votes down unverified findings > intermediate state lives in script variables, leaving Claude's context 100% clean > 1h prompt cache prefix hold eliminates redundant system prompt processing paste the setup and this prompt into Claude Code below: "Configure my Claude Code workspace for dynamic workflows: 1. Audit ~/.claude/workflows and .claude/workflows for existing scripts: > Draft workflow definitions for codebase audits, parallel migrations, and adversarial verification > Pin model: sonnet, effort: medium for pipeline workers, and model: fable for verifier agents > Configure workers to operate on isolated copies to eliminate edit conflicts 2. In ~/.claude/settings.json, enable dynamic workflows: > Set ultracode = true > Lock main session effortLevel to high > Set subagentPromptCacheTtl = '1h' to share prompt prefixes across parallel fan-outs 3. Set workflow runtime controls: > Set autoContinueAtUsageLimit = true so long batch runs automatically resume after limit resets > Set CLAUDE_CODE_WORKFLOW_PREFIX_STAGGER_MS = 5000 for prompt prefix caching > Set large workflow warning threshold to 25 agents 4. Add a rule to ~/.claude/CLAUDE.md: all multi-file audits must pass an adversarial Fable cross-check before findings are reported to the lead session Show every configuration diff first. Do not apply edits until confirmed" ↳

mirku

18,389 görüntüleme • 9 gün önce

I don't understand why everyone isn't doing this yet. Anthropic's own Claude Code docs show how to run a whole team of Claudes, while Opus 5.5 only touches the plan and the merge the whole idea: agent teams in Claude Code one lead, separate teammates in their own context windows, one shared task list, and they message each other directly the lead: Opus 5.5 on high, splits the work, writes the tasks, merges at the end the builders: Sonnet 5.5, one owns client/, one owns api/, never the same file the adversary: Fable 5.1, never writes code, only shows up at three points: → before an interface locks: do both sides agree on the contract? → when a test fails twice: is it fixed or just hidden? → before a task is marked done: what breaks it? Sonnet 5.5 builds. Fable 5.1 attacks. Opus 5.5 merges 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 team only argues about the ones that split turn it on, then start the team in plain English: "Spawn three teammates: ux and backend on Sonnet, an adversary on Fable" - the full team > Opus 5.5 on high leads the session > ux on Sonnet 5.5, owns client/ > backend on Sonnet 5.5, owns api/ > adversary on Fable 5.1, owns nothing, reviews everything > shared task list with file locking, direct messages, no lead in the middle paste the team and this prompt into Claude Code ↓ "Set up agent teams for this repo: 1. In ~/.claude/settings.json add CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 under env and set effortLevel to high 2. In ~/.claude/agents, draft three subagent definitions for the teammates > ux and backend with model: sonnet, each limited to its own folder > adversary with model: fable and read-only tools, whose only job is attacking contracts, repeated test failures and done claims > Skip any that already exist and list them 3. Add a TaskCompleted hook that blocks completion until the adversary signs off, and one rule to CLAUDE.md: no two teammates edit the same file 4. Find anything that would override this (CLAUDE_CODE_SUBAGENT_MODEL, CLAUDE_CODE_SUBAGENT_MODEL_FORCE, CLAUDE_CODE_EFFORT_LEVEL). Report it, change nothing Show me every change as a diff first. No edits until I say go." ↳

I don't understand why everyone isn't doing this yet. Anthropic's own Claude Code docs show how to run a whole team of Claudes, while Opus 5.5 only touches the plan and the merge the whole idea: agent teams in Claude Code one lead, separate teammates in their own context windows, one shared task list, and they message each other directly the lead: Opus 5.5 on high, splits the work, writes the tasks, merges at the end the builders: Sonnet 5.5, one owns client/, one owns api/, never the same file the adversary: Fable 5.1, never writes code, only shows up at three points: → before an interface locks: do both sides agree on the contract? → when a test fails twice: is it fixed or just hidden? → before a task is marked done: what breaks it? Sonnet 5.5 builds. Fable 5.1 attacks. Opus 5.5 merges 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 team only argues about the ones that split turn it on, then start the team in plain English: "Spawn three teammates: ux and backend on Sonnet, an adversary on Fable" - the full team > Opus 5.5 on high leads the session > ux on Sonnet 5.5, owns client/ > backend on Sonnet 5.5, owns api/ > adversary on Fable 5.1, owns nothing, reviews everything > shared task list with file locking, direct messages, no lead in the middle paste the team and this prompt into Claude Code ↓ "Set up agent teams for this repo: 1. In ~/.claude/settings.json add CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 under env and set effortLevel to high 2. In ~/.claude/agents, draft three subagent definitions for the teammates > ux and backend with model: sonnet, each limited to its own folder > adversary with model: fable and read-only tools, whose only job is attacking contracts, repeated test failures and done claims > Skip any that already exist and list them 3. Add a TaskCompleted hook that blocks completion until the adversary signs off, and one rule to CLAUDE.md: no two teammates edit the same file 4. Find anything that would override this (CLAUDE_CODE_SUBAGENT_MODEL, CLAUDE_CODE_SUBAGENT_MODEL_FORCE, CLAUDE_CODE_EFFORT_LEVEL). Report it, change nothing Show me every change as a diff first. No edits until I say go." ↳

delost

70,168 görüntüleme • 8 gün önce

Jev + Opus 5.5: Anthropic's new model beats GPT-6 Astra for 1/5 the cost, and 4 API changes will 400 your agent before it writes a single line I pulled these 10 steps from the migration docs so you don't learn them in production step 1 → $4 / $20 per 1M. Opus 5 was $5 / $25. cache reads dropped from $0.50 to $0.20 step 2 → 66.4% on Terminal-Bench 4.0 vs GPT-6 Astra 57.9% and Opus 5 52.3%. +14.1 points in one release, and on FrontierCode it beats Astra at default effort for 1/5 the cost step 3 → thinking can't be turned off anymore. send thinking: disabled and you get a 400. drop the field, set effort step 4 → tool_choice any and tool are gone. 400. switch to auto + strict step 5 → edit anything above a thinking block and the request dies. append only, or opt into drop_block step 6 → computer_20251124 is dead on the API. 400. move to computer_toolset_20260801 step 7 → the quiet one: default effort fell from high to medium. your agent thinks less than you set it up to and nothing tells you step 8 → hop Opus 5.5 → Sonnet 5 → Opus 5.5 and you pay 4.36 instead of 3.32. +31%, the cache dies and Sonnet can't read Opus's reasoning step 9 → change effort at the top of the request and the cache is gone. Jev sets it per message and the cache stays step 10 → switch fast - standard mid-session and it's a full cache miss. Jev picks speed once, on turn one one model, three knobs, zero 400s. that is Jev + Opus 5.5 send this to your Claude Code before you touch the model ID, then read my full Jev deep dive in the article below ↓

Jev + Opus 5.5: Anthropic's new model beats GPT-6 Astra for 1/5 the cost, and 4 API changes will 400 your agent before it writes a single line I pulled these 10 steps from the migration docs so you don't learn them in production step 1 → $4 / $20 per 1M. Opus 5 was $5 / $25. cache reads dropped from $0.50 to $0.20 step 2 → 66.4% on Terminal-Bench 4.0 vs GPT-6 Astra 57.9% and Opus 5 52.3%. +14.1 points in one release, and on FrontierCode it beats Astra at default effort for 1/5 the cost step 3 → thinking can't be turned off anymore. send thinking: disabled and you get a 400. drop the field, set effort step 4 → tool_choice any and tool are gone. 400. switch to auto + strict step 5 → edit anything above a thinking block and the request dies. append only, or opt into drop_block step 6 → computer_20251124 is dead on the API. 400. move to computer_toolset_20260801 step 7 → the quiet one: default effort fell from high to medium. your agent thinks less than you set it up to and nothing tells you step 8 → hop Opus 5.5 → Sonnet 5 → Opus 5.5 and you pay 4.36 instead of 3.32. +31%, the cache dies and Sonnet can't read Opus's reasoning step 9 → change effort at the top of the request and the cache is gone. Jev sets it per message and the cache stays step 10 → switch fast - standard mid-session and it's a full cache miss. Jev picks speed once, on turn one one model, three knobs, zero 400s. that is Jev + Opus 5.5 send this to your Claude Code before you touch the model ID, then read my full Jev deep dive in the article below ↓

Carnage

16,674 görüntüleme • 20 gün önce