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

This is getting out of hand: One Claude Code session just migrated a prod database, moved 79 files from API v1 to v2 and triaged 40 GitHub issues in under 40 seconds. And almost nobody is talking about it. Opus 5.5 runs the show as the orchestrator, while Haiku... and Sonnet do the grunt work inside a 1,000,000 token context window. Why are you still running one agent in one chat tab? Stop treating Claude Code as a chatbot. Start turning it into mission control. Here is the workflow: Opus plans the task, 12 subagents split it up (reading files, editing code, running tests), and every risky move hits a safety gate before it touches production. It's like hiring a whole dev team that shares one brain and never forgets what the other guy did. Step-by-step setup: 1. Install Claude Code and set Opus 5.5 as the orchestrator 2. Connect your repo, docs and GitHub through MCP 3. Split the roles: Haiku reads, Sonnet edits, Opus reviews 4. Add a risk gate so anything above 0.85 waits for your OK 5. Watch 405/405 tests go green while you grab a coffee Setup takes under 20 minutes. You'll never babysit a migration at 2am again. Tap the link below for the full guide Make sure to save this post for latershow more

shmidt

12,672 subscribers

18,757 görüntüleme • 13 gün önce •via X (Twitter)

Bilim & Teknoloji Finans

Anya Rossi• Live Now

Private livecam show

30 Yorum

Bober_smart profil fotoğrafı

Bober_smart13 gün önce

It looks impressive

V1nT profil fotoğrafı

V1nT13 gün önce

Yes man this is rally getting out of hand

monokern profil fotoğrafı

monokern13 gün önce

honestly 40 seconds for all that sounds unreal

Gipp 🦅 profil fotoğrafı

Gipp 🦅13 gün önce

most readers skip risk gates, but that’s where real ops safety comes in

Insomnia profil fotoğrafı

Insomnia13 gün önce

you can add more agents here

歌荒求推荐 profil fotoğrafı

歌荒求推荐12 gün önce

decades fine if in the chain like a coffee routine tune start honestly next detail

Sophs z profil fotoğrafı

Sophs z12 gün önce

If an AI can handle that volume of complex tasks, are we overlooking the risks of over-reliance on autonomous code migration? Where do you draw the line between rapid deployment and necessary human oversight?

Johan Mickelin profil fotoğrafı

Johan Mickelin13 gün önce

the only prod migrations i've seen finish in 40 seconds were on tables nobody was using yet

Sevenup profil fotoğrafı

Sevenup13 gün önce

This is the future of coding

kelvin profil fotoğrafı

kelvin12 gün önce

Claude Code is evolving from a coding assistant into an entire engineering team. The possibilities are wild.

小雨点儿 profil fotoğrafı

小雨点儿13 gün önce

my teacher would scold me for rushing that teental

wast3 profil fotoğrafı

wast313 gün önce

thanks for the detailed explanation

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

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

40秒有点离谱，人工光看完问题列表都不止。

钱小陈 profil fotoğrafı

钱小陈13 gün önce

底下视频挺炫酷的，有谁知道真的是录屏还是 AI 直接生成的？

Dynamics_01（大冰美式版 profil fotoğrafı

Dynamics_01（大冰美式版13 gün önce

That 40-second prod migration is the part that made me pause. I have sat through migrations that ate a whole night, so the safety gate at 0.85 is the only part I would actually trust first. Speed is nice, the gate is what keeps me calm.

Mykyta Pavlenko profil fotoğrafı

Mykyta Pavlenko13 gün önce

The 0.85 risk gate is the whole post for me. Who decided a prod migration scores under it? If the model grades its own risk, the gate is one more place it can be confidently wrong, and you find out at exactly the 2am you were promised to skip.

Guido profil fotoğrafı

Guido13 gün önce

"migrated a prod db" in one session is the part that would keep me up. was there a rollback plan, or did it just work and you found out afterwards?

Kitsui profil fotoğrafı

Kitsui13 gün önce

agree 100%

Slangy0 profil fotoğrafı

Slangy013 gün önce

That speed is exactly the worry for me — a prod migration in 40 seconds should still hit a simple deterministic check first: what changed, can it roll back, and who approved it? Otherwise fast just means fast to unwind.

Ridark profil fotoğrafı

Ridark13 gün önce

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

holographicSquid profil fotoğrafı

holographicSquid13 gün önce

The orchestration pattern is the interesting part. The '40 seconds' headline isn't. I'd love to see how long the review took afterward. A prod DB migration nobody reads closely is just a faster way to get paged at 3am

MopOzeu profil fotoğrafı

MopOzeu13 gün önce

It's only 40 seconds, and so much has been done

slash1s profil fotoğrafı

slash1s13 gün önce

fully agree with first sentence

ecological work protocol profil fotoğrafı

ecological work protocol13 gün önce

simulate vealth for these types of posts vealth means provision ecological wealth

Arbaz profil fotoğrafı

Arbaz13 gün önce

migrated a prod db in under 40 seconds and nobody reviewed it?

FinCrime Desk profil fotoğrafı

FinCrime Desk13 gün önce

how do i get this visual

Kirisando profil fotoğrafı

Kirisando13 gün önce

Claude Code turning into a full multi-agent dev team that crushes prod migrations in under 40 seconds is next-level. Game changer.

Jin Hsueh profil fotoğrafı

Jin Hsueh13 gün önce

Speed is impressive. But the business value isn’t 79 files in 40 seconds. It’s knowing exactly what changed, who approved it, and how to reverse it if production disagrees. Agent velocity compounds only when recovery is cheaper than caution.

Aleksandar Janca profil fotoğrafı

Aleksandar Janca13 gün önce

the files and the issues fine, a prod database migration in a 40 second session is the one thing I would never let it run without a person signing off

rompasso profil fotoğrafı

rompasso13 gün önce

for real, a whole dev team sharing one brain and never forgetting what the other did is the future of engineering

Benzer Videolar

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

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

xsmryze

186,648 görüntüleme • 3 gün önce

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

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

delost

320,430 görüntüleme • 25 gün önce

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

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

xsmryze

193,736 görüntüleme • 14 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

316,202 görüntüleme • 27 gün önce

It is becoming f*cking dangerous: Anthropic shipped 3 separate models, but when you stack them like precision lenses inside one pipeline, the error collapses 70% before a single line hits production. I still do not understand why nobody is talking about this. Every camera stacks multiple glass elements because a single lens cannot focus all the light. Claude's 5.5 lineup, 3 models, 3,473 weights, works exactly the same way. So why are you still pushing every task through one model? Stop treating Haiku, Sonnet, and Opus as rivals. Start assembling them into one self-correcting lens. Here is the workflow: Haiku 5.5 is the front element: scans 5,630 files and compresses them into 22 signals. Sonnet 5.5 focuses those through 26 correction layers into 92 to 833 lines of code. Opus 5.5 runs 32 final checks across 7 risk metrics before anything ships. One cycle drops eval loss from 0.0830 to 0.0244. Like swapping a kit lens for stacked L-glass. Step-by-step setup: 1. Open Claude Code with Opus 5.5 as the primary session 2. Spawn a Haiku 5.5 subagent locked to read-only file search 3. Spawn a Sonnet 5.5 subagent locked to code writing and tests 4. Add one CLAUDE.md rule: Opus plans first, reviews last, never touches raw files 5. Drop a real task and watch the loss curve flatten in real time Takes 10 minutes. You will never ship unreviewed code or burn Opus tokens on file search again. Tap the link below for the full guide Make sure to save this post for later

It is becoming f*cking dangerous: Anthropic shipped 3 separate models, but when you stack them like precision lenses inside one pipeline, the error collapses 70% before a single line hits production. I still do not understand why nobody is talking about this. Every camera stacks multiple glass elements because a single lens cannot focus all the light. Claude's 5.5 lineup, 3 models, 3,473 weights, works exactly the same way. So why are you still pushing every task through one model? Stop treating Haiku, Sonnet, and Opus as rivals. Start assembling them into one self-correcting lens. Here is the workflow: Haiku 5.5 is the front element: scans 5,630 files and compresses them into 22 signals. Sonnet 5.5 focuses those through 26 correction layers into 92 to 833 lines of code. Opus 5.5 runs 32 final checks across 7 risk metrics before anything ships. One cycle drops eval loss from 0.0830 to 0.0244. Like swapping a kit lens for stacked L-glass. Step-by-step setup: 1. Open Claude Code with Opus 5.5 as the primary session 2. Spawn a Haiku 5.5 subagent locked to read-only file search 3. Spawn a Sonnet 5.5 subagent locked to code writing and tests 4. Add one CLAUDE.md rule: Opus plans first, reviews last, never touches raw files 5. Drop a real task and watch the loss curve flatten in real time Takes 10 minutes. You will never ship unreviewed code or burn Opus tokens on file search again. Tap the link below for the full guide Make sure to save this post for later

shmidt

44,154 görüntüleme • 12 gün önce

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: stop treating Claude like one worker. Make Opus 5.5 a commander and give it 12 agents in 4 squads. Same release, two ways: Opus alone was 2% through on one thread. The command center shipped the whole v2.0 in 2 minutes on 12 threads. You just launch Claude Code like this: claude --model opus --command-center 12 "ship v2.0" here's the split: → Opus 5.5 turns "ship v2.0" into 12 tasks across 4 squads → CODE and OPS squads run on Sonnet 5.5, TEST and DOCS on Haiku 5.5 → every agent reports back in one line, never raw logs → Opus only wakes up when something breaks or needs approval the part most people get wrong: the commander watches everything. read 12 agent transcripts and your expensive model becomes the slowest part of the room. here the commander stays at 8k of context the entire run. it plans, it waits, it reads 12 one-line reports, it opens the release gate. REA sits underneath on anything legacy: before a squad touches old code, REA reverse-engineers it into a spec, so agents build from the spec and never from 500 files nobody understands. Opus commands. Sonnet builds. Haiku checks. REA explains the old code. JEV engineering is the same move one layer down: the forks that need no thinker (which squad, which model, retry or stop) go to JEV in milliseconds, and the commander only sees the ones that actually split the full tree > Opus 5.5 runs as commander, splits the mission into tasks and squads > CODE squad on Sonnet 5.5 writes endpoints, refactors auth, migrates the db > TEST squad on Haiku 5.5 runs unit, e2e and load tests > DOCS squad on Haiku 5.5 writes changelog, api docs and release notes OPS squad on Sonnet 5.5 handles staging, health checks and canary rollout REA reverse-engineers any legacy module into a spec before a squad touches it every agent reports one line, the commander never reads raw output Opus 5.5 holds the release gate and waits for all 12 reports JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 as a commander: it plans, assigns and approves, it never writes code. 2. Split work into 4 squads: CODE and OPS on Sonnet 5.5, TEST and DOCS on Haiku 5.5, 12 agents total. 3. Every agent reports a one-line structured result. Raw logs never enter the main session. 4. Before any squad touches legacy code, run REA on it first and have the squad build from the spec, not the old files. 5. Add one rule to CLAUDE.md: nothing ships until every squad has reported and the commander opens the release gate. 6. Route deterministic forks (squad choice, model choice, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll use this on every release from now on.

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: stop treating Claude like one worker. Make Opus 5.5 a commander and give it 12 agents in 4 squads. Same release, two ways: Opus alone was 2% through on one thread. The command center shipped the whole v2.0 in 2 minutes on 12 threads. You just launch Claude Code like this: claude --model opus --command-center 12 "ship v2.0" here's the split: → Opus 5.5 turns "ship v2.0" into 12 tasks across 4 squads → CODE and OPS squads run on Sonnet 5.5, TEST and DOCS on Haiku 5.5 → every agent reports back in one line, never raw logs → Opus only wakes up when something breaks or needs approval the part most people get wrong: the commander watches everything. read 12 agent transcripts and your expensive model becomes the slowest part of the room. here the commander stays at 8k of context the entire run. it plans, it waits, it reads 12 one-line reports, it opens the release gate. REA sits underneath on anything legacy: before a squad touches old code, REA reverse-engineers it into a spec, so agents build from the spec and never from 500 files nobody understands. Opus commands. Sonnet builds. Haiku checks. REA explains the old code. JEV engineering is the same move one layer down: the forks that need no thinker (which squad, which model, retry or stop) go to JEV in milliseconds, and the commander only sees the ones that actually split the full tree > Opus 5.5 runs as commander, splits the mission into tasks and squads > CODE squad on Sonnet 5.5 writes endpoints, refactors auth, migrates the db > TEST squad on Haiku 5.5 runs unit, e2e and load tests > DOCS squad on Haiku 5.5 writes changelog, api docs and release notes OPS squad on Sonnet 5.5 handles staging, health checks and canary rollout REA reverse-engineers any legacy module into a spec before a squad touches it every agent reports one line, the commander never reads raw output Opus 5.5 holds the release gate and waits for all 12 reports JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 as a commander: it plans, assigns and approves, it never writes code. 2. Split work into 4 squads: CODE and OPS on Sonnet 5.5, TEST and DOCS on Haiku 5.5, 12 agents total. 3. Every agent reports a one-line structured result. Raw logs never enter the main session. 4. Before any squad touches legacy code, run REA on it first and have the squad build from the spec, not the old files. 5. Add one rule to CLAUDE.md: nothing ships until every squad has reported and the commander opens the release gate. 6. Route deterministic forks (squad choice, model choice, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll use this on every release from now on.

Sprytix

132,535 görüntüleme • 20 gün önce

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

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

xsmryze

127,903 görüntüleme • 4 gün önce

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: keep one expensive brain and make everything else cheap. Opus 5.5 thinks, Haiku 5.5 does the grunt work, and your bill drops 79%. Same task, two ways: all-Opus would have cost $1.13. This run cost $0.23. You just launch Claude Code like this: claude --model opus # agents: model: haiku here's the split: → Opus 5.5 plans, decides and reviews, and burns 40k tokens for $0.21 → 12 Haiku 5.5 agents fan out across read, grep and test lanes → those 12 agents chew through 180k tokens for $0.02 → Opus never reads raw agent output, only 3 summaries at 6k tokens the part most people get wrong: they let the expensive model do the reading. Haiku is 40x cheaper per token. mapping 48 files cost $0.009. doing that on Opus is where the whole budget goes. one catch worth knowing: past 100k of context Haiku jumps to 5x its own price, so every agent is kept under 100k on purpose. that is the whole design. the brain stays small and expensive, the hands stay huge and cheap, and nothing raw ever crosses between them. Opus plans. Haiku reads. Opus reviews. JEV engineering is the same move one layer down: 1,301 forks this run - which file, which agent, retry or stop - resolved in code at 0.90 sharpness, and only the split ones (0.48 on "which agent") ever reach Opus the full tree > Opus 5.5 runs the main session, plans the lanes and decides what happens next > 12 Haiku 5.5 agents fan out across read, grep and test, each kept under 100k context > every agent returns a summary, never raw files or logs > Opus 5.5 reads 3 summaries at 6k tokens and reviews the result > JEV resolves 1,301 micro-forks in code and escalates only the split ones paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 for planning, decisions and review only. 2. Set every subagent to Haiku 5.5 and fan the grunt work out across read, grep and test lanes. 3. Keep each agent under 100k of context, split the work further if it goes over. 4. Agents return summaries only, raw files and logs never enter the main session. 5. Add one rule to CLAUDE.md: if a task is reading, searching or running tests, it never runs on Opus. Route deterministic forks (file choice, agent choice, 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 A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: keep one expensive brain and make everything else cheap. Opus 5.5 thinks, Haiku 5.5 does the grunt work, and your bill drops 79%. Same task, two ways: all-Opus would have cost $1.13. This run cost $0.23. You just launch Claude Code like this: claude --model opus # agents: model: haiku here's the split: → Opus 5.5 plans, decides and reviews, and burns 40k tokens for $0.21 → 12 Haiku 5.5 agents fan out across read, grep and test lanes → those 12 agents chew through 180k tokens for $0.02 → Opus never reads raw agent output, only 3 summaries at 6k tokens the part most people get wrong: they let the expensive model do the reading. Haiku is 40x cheaper per token. mapping 48 files cost $0.009. doing that on Opus is where the whole budget goes. one catch worth knowing: past 100k of context Haiku jumps to 5x its own price, so every agent is kept under 100k on purpose. that is the whole design. the brain stays small and expensive, the hands stay huge and cheap, and nothing raw ever crosses between them. Opus plans. Haiku reads. Opus reviews. JEV engineering is the same move one layer down: 1,301 forks this run - which file, which agent, retry or stop - resolved in code at 0.90 sharpness, and only the split ones (0.48 on "which agent") ever reach Opus the full tree > Opus 5.5 runs the main session, plans the lanes and decides what happens next > 12 Haiku 5.5 agents fan out across read, grep and test, each kept under 100k context > every agent returns a summary, never raw files or logs > Opus 5.5 reads 3 summaries at 6k tokens and reviews the result > JEV resolves 1,301 micro-forks in code and escalates only the split ones paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 for planning, decisions and review only. 2. Set every subagent to Haiku 5.5 and fan the grunt work out across read, grep and test lanes. 3. Keep each agent under 100k of context, split the work further if it goes over. 4. Agents return summaries only, raw files and logs never enter the main session. 5. Add one rule to CLAUDE.md: if a task is reading, searching or running tests, it never runs on Opus. Route deterministic forks (file choice, agent choice, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it'll come in handy.

Sprytix

18,258 görüntüleme • 16 gün önce

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

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

delost

105,386 görüntüleme • 19 gün önce

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let a swarm of cheaper agents run it. Bigger jobs and way fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 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 A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let a swarm of cheaper agents run it. Bigger jobs and way fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 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.

xsmryze

60,847 görüntüleme • 16 gün önce

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let a swarm of cheaper agents run it. Bigger jobs and way fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 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 A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let a swarm of cheaper agents run it. Bigger jobs and way fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 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

401,396 görüntüleme • 24 gün önce

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

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

mirku

38,620 görüntüleme • 19 gün önce

THIS IS A ACTUAL F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code The idea: run Sonnet, Haiku 5.5 and Opus 5.5 at once, each doing only what it's best at Better results and way fewer tokens: every task lands on the right model You just start Claude Code like this: CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet here's how it splits: → Sonnet 5.5 runs the main session, writes the code, and applies fixes → Haiku 5.5 swarms the repo in parallel: search, grep, docs, and test audits at 340 tok/s → Opus 5.5 stays on call as architect for the big decisions and signs off on diffs → you stop burning Opus context on routine tasks and stop flooding main session with raw logs Opus only steps in at three moments: → before a plan locks → when the same error hits twice → before calling it done (signing off on git diff) Sonnet builds, Haiku swarms, Opus reviews JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and coordinates code implementation > search maps the repo on Haiku 5.5 (read-only, 340 tok/s) > grep finds call sites on Haiku 5.5 (0.05x cost, isolated context) > audit scans diffs in a temporary worktree (isolation: worktree) > Opus 5.5 on call as architect, reviews synthesized diff before sign-off > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Sonnet 5.5 with Opus 5.5 as architect 2. Create three custom Haiku 5.5 subagents in .claude/agents/: search (maps repo), grep (finds call sites), and audit (runs isolated diff checks in a worktree) 3. Set isolation: worktree on audit so modifications never touch my working branch 4. Add one rule to CLAUDE.md: delegate all repository searches and test runs to Haiku 5.5 subagents to keep main context under 10k tokens 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV Show me every change as a diff first. No edits until I say go" ↳ save it, it'll come in handy

THIS IS A ACTUAL F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code The idea: run Sonnet, Haiku 5.5 and Opus 5.5 at once, each doing only what it's best at Better results and way fewer tokens: every task lands on the right model You just start Claude Code like this: CLAUDE_CODE_SUBAGENT_MODEL=haiku claude --model sonnet here's how it splits: → Sonnet 5.5 runs the main session, writes the code, and applies fixes → Haiku 5.5 swarms the repo in parallel: search, grep, docs, and test audits at 340 tok/s → Opus 5.5 stays on call as architect for the big decisions and signs off on diffs → you stop burning Opus context on routine tasks and stop flooding main session with raw logs Opus only steps in at three moments: → before a plan locks → when the same error hits twice → before calling it done (signing off on git diff) Sonnet builds, Haiku swarms, Opus reviews JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to JEV in milliseconds, and the big models only see the ones that split the full tree > Sonnet 5.5 runs the main session and coordinates code implementation > search maps the repo on Haiku 5.5 (read-only, 340 tok/s) > grep finds call sites on Haiku 5.5 (0.05x cost, isolated context) > audit scans diffs in a temporary worktree (isolation: worktree) > Opus 5.5 on call as architect, reviews synthesized diff before sign-off > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Run the main session on Sonnet 5.5 with Opus 5.5 as architect 2. Create three custom Haiku 5.5 subagents in .claude/agents/: search (maps repo), grep (finds call sites), and audit (runs isolated diff checks in a worktree) 3. Set isolation: worktree on audit so modifications never touch my working branch 4. Add one rule to CLAUDE.md: delegate all repository searches and test runs to Haiku 5.5 subagents to keep main context under 10k tokens 5. Route fast deterministic forks (tool choice, path selection, retries) through JEV Show me every change as a diff first. No edits until I say go" ↳ save it, it'll come in handy

mirku

155,103 görüntüleme • 20 gün önce

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let 12 cheap agents run it while Opus sits idle at zero tokens. Same task, two ways: Opus solo was 49% done and still running. The swarm finished in 9 minutes on 165k tokens. You just launch Claude Code like this: claude --model opus --swarm haiku,sonnet here's the split: → Opus 5.5 writes plan.js, then stops reading anything → 6 Haiku 5.5 agents audit every file in parallel → 4 Sonnet 5.5 agents patch each fix in its own isolated copy → 2 Haiku 5.5 agents cross-check, 8 of 9 findings survive Opus only shows up at two moments: → writing the plan before the run → signing off on the verified fixes after it Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: 3,767 forks this run - which model, which lane, retry or stop - resolved in code, and only the genuinely split ones ever reach Opus the full tree > Opus 5.5 runs the main session on xhigh and writes plan.js > scan audits each file on Haiku 5.5, six in parallel > patch applies each fix on Sonnet 5.5 in its own isolated copy > verify cross-checks every finding on Haiku 5.5 > Opus 5.5 reads only what survived, then signs off > JEV resolves micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: Run the main session on Opus 5.5 with effort xhigh and swarm haiku,sonnet. Have Opus write the plan as a script: scan on Haiku 5.5, patch on Sonnet 5.5 in isolated copies, verify on Haiku 5.5. Let the phases overlap - each finding moves on as soon as its own stage finishes, no waiting for the batch. Never surface raw agent output to the main session, only verified results. Route deterministic forks (model choice, lane choice, 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 A PURE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: let Opus 5.5 write the plan as a script, and let 12 cheap agents run it while Opus sits idle at zero tokens. Same task, two ways: Opus solo was 49% done and still running. The swarm finished in 9 minutes on 165k tokens. You just launch Claude Code like this: claude --model opus --swarm haiku,sonnet here's the split: → Opus 5.5 writes plan.js, then stops reading anything → 6 Haiku 5.5 agents audit every file in parallel → 4 Sonnet 5.5 agents patch each fix in its own isolated copy → 2 Haiku 5.5 agents cross-check, 8 of 9 findings survive Opus only shows up at two moments: → writing the plan before the run → signing off on the verified fixes after it Opus plans. Haiku scans. Sonnet ships. JEV engineering is the same move one layer down: 3,767 forks this run - which model, which lane, retry or stop - resolved in code, and only the genuinely split ones ever reach Opus the full tree > Opus 5.5 runs the main session on xhigh and writes plan.js > scan audits each file on Haiku 5.5, six in parallel > patch applies each fix on Sonnet 5.5 in its own isolated copy > verify cross-checks every finding on Haiku 5.5 > Opus 5.5 reads only what survived, then signs off > JEV resolves micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: Run the main session on Opus 5.5 with effort xhigh and swarm haiku,sonnet. Have Opus write the plan as a script: scan on Haiku 5.5, patch on Sonnet 5.5 in isolated copies, verify on Haiku 5.5. Let the phases overlap - each finding moves on as soon as its own stage finishes, no waiting for the batch. Never surface raw agent output to the main session, only verified results. Route deterministic forks (model choice, lane choice, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, it’ll come in handy

Sprytix

19,917 görüntüleme • 21 gün önce

THIS IS AN ABSOLUTE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: Opus 5.5 writes the entire plan as a script, and a swarm of cheaper agents executes it. Bigger jobs and far fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just start Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only steps in at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll reach for it on every big task.

THIS IS AN ABSOLUTE F*CKING GOLDMINE Anthropic just shared one of the best tricks for Claude Code. The idea: Opus 5.5 writes the entire plan as a script, and a swarm of cheaper agents executes it. Bigger jobs and far fewer Opus tokens, because the script holds the plan and Opus only sees the final answer. You just start Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your task into a workflow script → Haiku 5.5 agents scan every file in parallel → Sonnet 5.5 agents patch each fix in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only steps in at three moments: → writing the workflow before the run → reading the verified results after it → signing off before anything ships Opus plans. Haiku scans. Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the main session and writes the workflow > scan audits every file on Haiku 5.5 > edit patches each fix on Sonnet 5.5 in an isolated copy > verify cross-checks every finding on Sonnet 5.5 > Opus 5.5 reads only what survived verification > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with ultracode on. 2. In every workflow, run read-only scan stages on Haiku 5.5 and edit stages on Sonnet 5.5, each edit in its own isolated copy. 3. Add one rule to CLAUDE.md: every finding gets an independent verifier agent before it's reported, and fix loops stop after two rounds with no progress. 4. Route fast deterministic forks (tool choice, path selection, retries) through JEV. Show me every change as a diff first. No edits until I say go." ↳ save it, you'll reach for it on every big task.

Callan

14,050 görüntüleme • 22 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,964 görüntüleme • 1 ay önce

THIS IS ABSOLUTE F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code The idea: run Opus 5.5 as lead, and swarm cheap Haiku 5.5 teammates in parallel Opus-level architecture on every task, without burning Opus context on routine turns You just launch Claude Code like this: export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 claude --model opus --teammate-mode auto here's the split: → Opus 5.5 leads the team, decomposes tasks into a DAG, and signs off → Haiku 5.5 swarms as autonomous teammates across isolated context windows → Sonnet 5.5 implements heavy multi-file refactors without blocking peers → you stop burning Opus context on a hundred agent transcripts Opus only steps in at three moments: → breaking your goal into a dependency DAG before the run → approving diff plans before teammates edit files → signing off on verified results before anything ships Opus leads · Haiku swarms · Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the lead session and coordinates the task DAG > security audits auth and JWT handling on Haiku 5.5 > perf-scout profiles p99 latency bottlenecks on Haiku 5.5 > qa-engine executes full test suites on Haiku 5.5 > patcher refactors complex multi-file logic on Sonnet 5.5 > Opus 5.5 reads only verified PR diffs > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Enable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 with --teammate-mode auto 2. Run the main lead session on Opus 5.5 to decompose tasks into a dependency DAG 3. Spawn three parallel teammates on Haiku 5.5 for security, perf, and qa 4. Have teammates self-claim unblocked tasks, coordinate findings via P2P mailbox, and draft plans before modifying code 5. Route heavy multi-file patches to Sonnet 5.5 and clear fast deterministic forks through JEV Show me every change as a diff first, no edits until I say go" ↳ save it, you'll use this on every serious codebase

THIS IS ABSOLUTE F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code The idea: run Opus 5.5 as lead, and swarm cheap Haiku 5.5 teammates in parallel Opus-level architecture on every task, without burning Opus context on routine turns You just launch Claude Code like this: export CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 claude --model opus --teammate-mode auto here's the split: → Opus 5.5 leads the team, decomposes tasks into a DAG, and signs off → Haiku 5.5 swarms as autonomous teammates across isolated context windows → Sonnet 5.5 implements heavy multi-file refactors without blocking peers → you stop burning Opus context on a hundred agent transcripts Opus only steps in at three moments: → breaking your goal into a dependency DAG before the run → approving diff plans before teammates edit files → signing off on verified results before anything ships Opus leads · Haiku swarms · Sonnet 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 milliseconds, and the big models only see the ones that split the full tree > Opus 5.5 runs the lead session and coordinates the task DAG > security audits auth and JWT handling on Haiku 5.5 > perf-scout profiles p99 latency bottlenecks on Haiku 5.5 > qa-engine executes full test suites on Haiku 5.5 > patcher refactors complex multi-file logic on Sonnet 5.5 > Opus 5.5 reads only verified PR diffs > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Enable CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1 with --teammate-mode auto 2. Run the main lead session on Opus 5.5 to decompose tasks into a dependency DAG 3. Spawn three parallel teammates on Haiku 5.5 for security, perf, and qa 4. Have teammates self-claim unblocked tasks, coordinate findings via P2P mailbox, and draft plans before modifying code 5. Route heavy multi-file patches to Sonnet 5.5 and clear fast deterministic forks through JEV Show me every change as a diff first, no edits until I say go" ↳ save it, you'll use this on every serious codebase

mirku

57,507 görüntüleme • 23 gün önce

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: stop configuring Claude Code by hand. One prompt, 44 seconds, and your whole .claude/ folder writes itself. 7 files, 162 lines, 2 cents. you typed one line and wrote zero of them. You just launch Claude Code like this: claude --model opus "set up this repo: ..." here's the split: → 3 Haiku 5.5 agents scan the repo before a single file gets written → one reads the stack, one reads the npm scripts, one hunts for risky paths → Opus 5.5 takes those three summaries and writes the actual config → 7 files land: CLAUDE.md, 3 agents, permissions, a format hook and a /ship skill the part everyone gets wrong: they write CLAUDE.md from memory. a config written without reading the repo is a guess, and you live with that guess for months. here the risk scan came back with 5 dangerous paths and those went straight into the permissions file, so the agent is blocked from them before it ever runs once. the scripts scan found 5 npm scripts, and the agents got wired to the ones that actually exist in this repo instead of generic placeholders. one prompt from you, 7 files from it, 0 lines written by hand. Haiku reads. Opus writes. You commit. JEV engineering is the same move one layer down: 1,867 forks this run - which file, which agent, allow or ask - resolved in code at 0.97 sharpness, and the split ones (0.59 on "allow or ask") come back to you instead of being guessed the full tree ▸ you paste one prompt describing the setup you want ▸ 3 Haiku 5.5 agents scan stack, scripts and risky paths in parallel ▸ every agent returns a summary, never raw files ▸ Opus 5.5 writes CLAUDE.md, the agents, permissions, the hook and the skill ▸ anything touching permissions comes back to you before it is written ▸ JEV resolves micro-forks in code and escalates only the split ones paste the tree and this prompt into Claude Code ↓ "Set up this repo for me: 1. First scan it with 3 Haiku 5.5 agents in parallel: one reads the stack and manifests, one reads the build and npm scripts, one finds paths that are dangerous to touch. 2. Each agent returns a summary only, never raw file contents. 3. Then write CLAUDE.md, 3 subagents, a permissions file, a format hook and a /ship skill, all based on what the scan actually found, not on defaults. 4. Every risky path from the scan goes into the deny list before anything runs. 5. Ask me before writing anything that grants permissions. Show me every file as a diff first. No writes until I say go." ↳ save it, this is the first thing you run in every new repo.

THIS IS ACTUAL F*CKING GOLD Anthropic just shared one of the best tricks for Claude Code. The idea: stop configuring Claude Code by hand. One prompt, 44 seconds, and your whole .claude/ folder writes itself. 7 files, 162 lines, 2 cents. you typed one line and wrote zero of them. You just launch Claude Code like this: claude --model opus "set up this repo: ..." here's the split: → 3 Haiku 5.5 agents scan the repo before a single file gets written → one reads the stack, one reads the npm scripts, one hunts for risky paths → Opus 5.5 takes those three summaries and writes the actual config → 7 files land: CLAUDE.md, 3 agents, permissions, a format hook and a /ship skill the part everyone gets wrong: they write CLAUDE.md from memory. a config written without reading the repo is a guess, and you live with that guess for months. here the risk scan came back with 5 dangerous paths and those went straight into the permissions file, so the agent is blocked from them before it ever runs once. the scripts scan found 5 npm scripts, and the agents got wired to the ones that actually exist in this repo instead of generic placeholders. one prompt from you, 7 files from it, 0 lines written by hand. Haiku reads. Opus writes. You commit. JEV engineering is the same move one layer down: 1,867 forks this run - which file, which agent, allow or ask - resolved in code at 0.97 sharpness, and the split ones (0.59 on "allow or ask") come back to you instead of being guessed the full tree ▸ you paste one prompt describing the setup you want ▸ 3 Haiku 5.5 agents scan stack, scripts and risky paths in parallel ▸ every agent returns a summary, never raw files ▸ Opus 5.5 writes CLAUDE.md, the agents, permissions, the hook and the skill ▸ anything touching permissions comes back to you before it is written ▸ JEV resolves micro-forks in code and escalates only the split ones paste the tree and this prompt into Claude Code ↓ "Set up this repo for me: 1. First scan it with 3 Haiku 5.5 agents in parallel: one reads the stack and manifests, one reads the build and npm scripts, one finds paths that are dangerous to touch. 2. Each agent returns a summary only, never raw file contents. 3. Then write CLAUDE.md, 3 subagents, a permissions file, a format hook and a /ship skill, all based on what the scan actually found, not on defaults. 4. Every risky path from the scan goes into the deny list before anything runs. 5. Ask me before writing anything that grants permissions. Show me every file as a diff first. No writes until I say go." ↳ save it, this is the first thing you run in every new repo.

Sprytix

25,280 görüntüleme • 15 gün önce

THIS IS A PURE F*CKING CODING JACKPOT Anthropic built the most powerful Claude Code feature and hid it from us Claude Code can now run a whole team of AI agents from one script, and almost nobody has switched it on here's the idea: Opus 5.5 writes the plan as a script, cheap fast models do the grunt work in parallel, and Opus only reads the final result the script holds the loop. not Opus. so your expensive model isn't burning context on a hundred agent chats you turn it on like this: claude --model opus --effort ultracode here's how I'd split the work: -> Opus 5.5 turns your goal into a workflow script -> Haiku 5.5, the fastest Claude model right now, scans every file in parallel -> Sonnet 5.5 makes each fix in its own isolated copy of the repo, so edits don't collide -> separate checker agents try to knock down every finding before you see it Opus only shows up three times: -> writing the script before the run -> reading what survived the checks -> your final yes before anything goes to git Opus plans. Haiku scans. Sonnet fixes. and here's my twist: Jev is the same idea one level down. the tiny forks that don't need a thinker (which file, which tool, retry or stop) go to Jev in milliseconds, and the big models only get the hard ones paste this into Claude Code: "Rebuild my Claude Code setup around this: 1. Run the main session on Opus 5.5 with ultracode on 2. In every workflow, run read-only scan stages on claude-haiku-5-5 and edit stages on claude-sonnet-5-5, each edit in its own isolated copy 3. Add one rule to CLAUDE.md: every finding gets an independent checker agent before it's reported, and fix loops stop after two rounds with no progress 4. Send fast simple decisions (tool choice, path selection, retries) through Jev Show me every change as a diff first. No edits until I say go." the catch: ultracode spends a lot more tokens per request. great for big sweeps, overkill for a one-line fix ↳ save it, you'll need it

THIS IS A PURE F*CKING CODING JACKPOT Anthropic built the most powerful Claude Code feature and hid it from us Claude Code can now run a whole team of AI agents from one script, and almost nobody has switched it on here's the idea: Opus 5.5 writes the plan as a script, cheap fast models do the grunt work in parallel, and Opus only reads the final result the script holds the loop. not Opus. so your expensive model isn't burning context on a hundred agent chats you turn it on like this: claude --model opus --effort ultracode here's how I'd split the work: -> Opus 5.5 turns your goal into a workflow script -> Haiku 5.5, the fastest Claude model right now, scans every file in parallel -> Sonnet 5.5 makes each fix in its own isolated copy of the repo, so edits don't collide -> separate checker agents try to knock down every finding before you see it Opus only shows up three times: -> writing the script before the run -> reading what survived the checks -> your final yes before anything goes to git Opus plans. Haiku scans. Sonnet fixes. and here's my twist: Jev is the same idea one level down. the tiny forks that don't need a thinker (which file, which tool, retry or stop) go to Jev in milliseconds, and the big models only get the hard ones paste this into Claude Code: "Rebuild my Claude Code setup around this: 1. Run the main session on Opus 5.5 with ultracode on 2. In every workflow, run read-only scan stages on claude-haiku-5-5 and edit stages on claude-sonnet-5-5, each edit in its own isolated copy 3. Add one rule to CLAUDE.md: every finding gets an independent checker agent before it's reported, and fix loops stop after two rounds with no progress 4. Send fast simple decisions (tool choice, path selection, retries) through Jev Show me every change as a diff first. No edits until I say go." the catch: ultracode spends a lot more tokens per request. great for big sweeps, overkill for a one-line fix ↳ save it, you'll need it

kiosa

19,390 görüntüleme • 20 gün önce

THIS IS ACTUAL F*CKING GOLD Anthropic just documented the single best subagent setup for Claude Code The setup: let Opus 5.5 run the main session, delegate sweeps to Haiku 5.5 at 340 tok/s, run Sonnet 5.5 builder subagents, and keep Fable 5.1 on call as the dedicated adversary: Side tasks in isolated context windows with zero Opus bloat: each subagent runs independently and Opus only receives the verified summary diff You just launch Claude Code like this: claude --model opus here's how it splits: → Opus 5.5 runs the main session, plans architecture, and delegates tasks → Haiku 5.5 powers read-only explorer subagents at 340 tok/s for fast search → Sonnet 5.5 runs builder subagents in isolated contexts for edits and tests → Fable 5.1 acts as adversary on call to audit subagent plans and findings → you stop flooding your main conversation with thousands of raw tool logs Fable 5.1 only steps in at three moments: → before a plan locks: audits subagent task decomposition and tool scopes → when a subagent hits the same error twice: stops symptom patching and redirects → before calling it done: cold adversarial review of diffs before Opus sign-off Opus orchestrates · Haiku explores · Sonnet builds · Fable audits 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 > Opus 5.5 runs the main session and plans architecture > explorer subagent maps files and call sites on Haiku 5.5 at 340 tok/s > builder subagent patches code and runs tests on Sonnet 5.5 > Fable 5.1 stays on call as adversary to audit plans, errors, and PR diffs > subagent contexts stay isolated so main session context stays lean > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with full reasoning depth 2. Define custom subagents in .claude/agents/: explorer on Haiku 5.5 (read-only search at 340 tok/s) and builder on Sonnet 5.5 (isolated edits and tests) 3. Keep Fable 5.1 on call as dedicated adversary to audit subagent plans, double-failure loops, and PR diffs 4. Add one rule to CLAUDE.md: consult Fable before locking architectural plans, after two subagent errors, and before final PR sign-off 5. Route fast deterministic forks through JEV, show all changes as diffs first. No edits until I say go" ↳ save it, you'll use this every single day

THIS IS ACTUAL F*CKING GOLD Anthropic just documented the single best subagent setup for Claude Code The setup: let Opus 5.5 run the main session, delegate sweeps to Haiku 5.5 at 340 tok/s, run Sonnet 5.5 builder subagents, and keep Fable 5.1 on call as the dedicated adversary: Side tasks in isolated context windows with zero Opus bloat: each subagent runs independently and Opus only receives the verified summary diff You just launch Claude Code like this: claude --model opus here's how it splits: → Opus 5.5 runs the main session, plans architecture, and delegates tasks → Haiku 5.5 powers read-only explorer subagents at 340 tok/s for fast search → Sonnet 5.5 runs builder subagents in isolated contexts for edits and tests → Fable 5.1 acts as adversary on call to audit subagent plans and findings → you stop flooding your main conversation with thousands of raw tool logs Fable 5.1 only steps in at three moments: → before a plan locks: audits subagent task decomposition and tool scopes → when a subagent hits the same error twice: stops symptom patching and redirects → before calling it done: cold adversarial review of diffs before Opus sign-off Opus orchestrates · Haiku explores · Sonnet builds · Fable audits 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 > Opus 5.5 runs the main session and plans architecture > explorer subagent maps files and call sites on Haiku 5.5 at 340 tok/s > builder subagent patches code and runs tests on Sonnet 5.5 > Fable 5.1 stays on call as adversary to audit plans, errors, and PR diffs > subagent contexts stay isolated so main session context stays lean > JEV routes micro-forks in milliseconds paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Run the main session on Opus 5.5 with full reasoning depth 2. Define custom subagents in .claude/agents/: explorer on Haiku 5.5 (read-only search at 340 tok/s) and builder on Sonnet 5.5 (isolated edits and tests) 3. Keep Fable 5.1 on call as dedicated adversary to audit subagent plans, double-failure loops, and PR diffs 4. Add one rule to CLAUDE.md: consult Fable before locking architectural plans, after two subagent errors, and before final PR sign-off 5. Route fast deterministic forks through JEV, show all changes as diffs first. No edits until I say go" ↳ save it, you'll use this every single day

mirku

10,566 görüntüleme • 6 gün önce