Video wird geladen...

Video konnte nicht geladen werden

Zur Startseite

Reverse engineering with REA + Opus 5.5 takes any program apart piece by piece, and it's f**king unreal websites, games, apps what took years, REA now takes apart in one evening and copies everything without you writing a single line of code this file turns Claude into a system...

noisyb0y1's profile picture

Noisy

28,186 subscribers

12,672 Aufrufe • vor 15 Tagen •via X (Twitter)

LIVE

Anya Rossi• Live Now

Private livecam show

8 Kommentare

Profilbild von Nicholas Michael Kloster
Nicholas Michael Klostervor 14 Tagen

Why does REA keep trying to access my bank account?

Profilbild von Avid
Avidvor 15 Tagen

this is so useful

Profilbild von Nicholas Michael Kloster
Nicholas Michael Klostervor 14 Tagen

I don't understand can you explain this

Profilbild von Donatello
Donatellovor 14 Tagen

Well done noisy

Profilbild von Nicholas Michael Kloster
Nicholas Michael Klostervor 14 Tagen

When I tried using it nothing worked

Profilbild von alpha404
alpha404vor 15 Tagen

REA WITH OPUS WTF

Profilbild von Caleb
Calebvor 14 Tagen

Reverse engineering slots? I just read pay tables. What's your edge per hour?

Profilbild von Sebastian Hardy | AI Marketing
Sebastian Hardy | AI Marketingvor 14 Tagen

Looks interesting. Is REA an open repo? Anything that opens programs and clicks around goes through the same check for me first, stars, last update, who publishes it. Would love the link.

Ähnliche Videos

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.
0:20

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 Aufrufe • vor 9 Tagen

Anthropic just shared one of their most expensive systems, a $4.2M one, for Claude Code It rewrites a codebase agencies quote at $240,000 in 7 minutes for 88 cents. most rewrites die the same way: you dump 212 files of old logic into the model and it drowns REA reverse-engineers the old system once and writes a spec instead, every endpoint, every rule, every edge case 12 Sonnet 5.5 agents build from that spec, one module each, and none of them touches the old code Opus 5.5 writes the plan, then sits idle the whole run, so you pay almost nothing at the end REA replays the new system against the old one, 148 of 148 behaviours match Opus plans. REA reverse-engineers. Sonnet builds. save it, tomorrow this will be sold in $500 courses ↓
0:22

Anthropic just shared one of their most expensive systems, a $4.2M one, for Claude Code It rewrites a codebase agencies quote at $240,000 in 7 minutes for 88 cents. most rewrites die the same way: you dump 212 files of old logic into the model and it drowns REA reverse-engineers the old system once and writes a spec instead, every endpoint, every rule, every edge case 12 Sonnet 5.5 agents build from that spec, one module each, and none of them touches the old code Opus 5.5 writes the plan, then sits idle the whole run, so you pay almost nothing at the end REA replays the new system against the old one, 148 of 148 behaviours match Opus plans. REA reverse-engineers. Sonnet builds. save it, tomorrow this will be sold in $500 courses ↓

Noisy

37,564 Aufrufe • vor 11 Tagen

THIS IS A PURE F*CKING GOLDMINE the best REA trick almost nobody runs yet. The idea: REA takes the app apart, Jev keeps only what's proven, and a fresh Opus 5.5 rebuilds the feature from that alone. Nothing gets copied and no guess makes it into the code, because the builder never sees the original, only the spec Jev signed off on. You just connect REA like this: npx rea-agents setup here's the split: → REA reads the feature down to the binary and writes every rule into SPEC.md → Jev checks each rule against REA's evidence and sends back anything unproven → a fresh Opus 5.5 session gets only SPEC.md and rebuilds the feature → Haiku 5.5 runs the tests against 3 intentionally broken versions Opus only shows up at three moments: → rebuilding from the approved spec → the checks Jev marks as unclear → signing off before anything ships REA reads. Jev judges. Opus rebuilds. That's the clean-room rule in one line: the model that saw the original never writes the code, and the model that writes the code never sees the original. the full tree > REA reads the app and writes SPEC.md with evidence for every rule > Jev approves or returns each rule > Opus 5.5 rebuilds from the approved SPEC.md in a fresh session > Haiku 5.5 runs the tests and the 3 broken versions > Jev routes unclear checks back to Opus > /goal keeps going until all 3 broken versions fail paste the tree and this prompt into Claude Code ↓ "Set up a clean-room rebuild around this tree: 1. Use REA to investigate [FEATURE] in [APP]. Write every behavior and rule into SPEC.md, each with the evidence REA found. 2. Send each rule to Jev. Any rule without evidence goes back to REA. 3. Start a fresh session with only SPEC.md. Rebuild the feature on Opus 5.5 without opening the original. 4. Write tests on Haiku 5.5 plus 3 intentionally broken versions. Use /goal until the rebuild passes and all 3 broken versions fail. Show me SPEC.md first. Nothing gets built until I say go." ↳ save it, it'll come in handy.
0:20

THIS IS A PURE F*CKING GOLDMINE the best REA trick almost nobody runs yet. The idea: REA takes the app apart, Jev keeps only what's proven, and a fresh Opus 5.5 rebuilds the feature from that alone. Nothing gets copied and no guess makes it into the code, because the builder never sees the original, only the spec Jev signed off on. You just connect REA like this: npx rea-agents setup here's the split: → REA reads the feature down to the binary and writes every rule into SPEC.md → Jev checks each rule against REA's evidence and sends back anything unproven → a fresh Opus 5.5 session gets only SPEC.md and rebuilds the feature → Haiku 5.5 runs the tests against 3 intentionally broken versions Opus only shows up at three moments: → rebuilding from the approved spec → the checks Jev marks as unclear → signing off before anything ships REA reads. Jev judges. Opus rebuilds. That's the clean-room rule in one line: the model that saw the original never writes the code, and the model that writes the code never sees the original. the full tree > REA reads the app and writes SPEC.md with evidence for every rule > Jev approves or returns each rule > Opus 5.5 rebuilds from the approved SPEC.md in a fresh session > Haiku 5.5 runs the tests and the 3 broken versions > Jev routes unclear checks back to Opus > /goal keeps going until all 3 broken versions fail paste the tree and this prompt into Claude Code ↓ "Set up a clean-room rebuild around this tree: 1. Use REA to investigate [FEATURE] in [APP]. Write every behavior and rule into SPEC.md, each with the evidence REA found. 2. Send each rule to Jev. Any rule without evidence goes back to REA. 3. Start a fresh session with only SPEC.md. Rebuild the feature on Opus 5.5 without opening the original. 4. Write tests on Haiku 5.5 plus 3 intentionally broken versions. Use /goal until the rebuild passes and all 3 broken versions fail. Show me SPEC.md first. Nothing gets built until I say go." ↳ save it, it'll come in handy.

Archive

59,706 Aufrufe • vor 11 Tagen

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.
0:32

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,207 Aufrufe • vor 5 Tagen

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.
0:32

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

398,556 Aufrufe • vor 13 Tagen

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

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

319,152 Aufrufe • vor 14 Tagen

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

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

189,043 Aufrufe • vor 3 Tagen

claude + REA can rebuild software features without copying a single line of code opus 5.5 reads what REA finds inside a program, then rebuilds the feature in a separate clean-room setup. here's how to do it: 1. run npx rea-agents setup to connect REA to Claude Code 2. pick a feature and let REA figure out how it works. save the behavior and rules in a spec file 3. start a fresh Claude session with only that spec. rebuild the feature without touching the original code 4. use /goal to run the tests and check 3 intentionally broken versions. all 3 must fail one project recovered 697 functions in just 12 days, with 696 exact matches. the real trick is building tests that catch mistakes before they become part of the finished software.
0:25

claude + REA can rebuild software features without copying a single line of code opus 5.5 reads what REA finds inside a program, then rebuilds the feature in a separate clean-room setup. here's how to do it: 1. run npx rea-agents setup to connect REA to Claude Code 2. pick a feature and let REA figure out how it works. save the behavior and rules in a spec file 3. start a fresh Claude session with only that spec. rebuild the feature without touching the original code 4. use /goal to run the tests and check 3 intentionally broken versions. all 3 must fail one project recovered 697 functions in just 12 days, with 696 exact matches. the real trick is building tests that catch mistakes before they become part of the finished software.

Gipp 🦅

140,768 Aufrufe • vor 13 Tagen

REA + Opus 5.5 might be the most dangerous combo on the internet right now and 99% of builders have no idea what to do with it you're paying every month for apps whose features are already sitting on your laptop send this one prompt to Opus 5.5 it reverse-engineers any paid closed-source app for you the engineer who brings a working internal copy of a $500/seat tool to Monday standup is the one who ends the quarter with a new title full guide on becoming a REA engineer from scratch below ↓
0:24

REA + Opus 5.5 might be the most dangerous combo on the internet right now and 99% of builders have no idea what to do with it you're paying every month for apps whose features are already sitting on your laptop send this one prompt to Opus 5.5 it reverse-engineers any paid closed-source app for you the engineer who brings a working internal copy of a $500/seat tool to Monday standup is the one who ends the quarter with a new title full guide on becoming a REA engineer from scratch below ↓

Mr. Buzzoni

34,412 Aufrufe • vor 13 Tagen

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

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

56,940 Aufrufe • vor 20 Tagen

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.
0:20

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

13,976 Aufrufe • vor 11 Tagen

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
0:28

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,727 Aufrufe • vor 11 Tagen

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.
0:36

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

70,735 Aufrufe • vor 2 Tagen

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.
0:37

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

314,920 Aufrufe • vor 16 Tagen

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
0:25

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 Aufrufe • vor 9 Tagen

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." ↳
0:36

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

104,299 Aufrufe • vor 8 Tagen

this is certified f*cking gold for anyone paying for Claude Sonnet 5.5 costs half of what Opus 5.5 does on real office work across 44 jobs it scores 1844. Opus scores 1846 on coding it went from 10.3% to 70.6% in one version and passed Opus on the way most of what you pay Opus for, Sonnet 5.5 now does at half the price here's how to split the work: • give it to Sonnet 5.5 > bug fixes and well-scoped coding tasks > decks built from your own slide template > spreadsheets and polished documents > UI polish, it has a real eye for design > fast back-and-forth, it runs 30%+ faster • keep it for Opus 5.5 > long, open-ended work with judgment calls for hours > anything where one wrong assumption costs you a day • the setting that saves the most > Medium is the default in the Claude apps and Claude Code > on Low or Medium it beats Sonnet 5's best score for a tenth of the cost > raise effort only when the first answer falls short • the price > $2 in and $10 out, against $4 and $20 for Opus > cache reads $0.20 on both • check before you switch > if you ran Sonnet with thinking off, move to the new between_tools setting first whoever routes the weekly grunt work to Sonnet 5.5 and saves Opus for the hard calls ships more on half the budget, and that's the person who gets noticed
0:24

this is certified f*cking gold for anyone paying for Claude Sonnet 5.5 costs half of what Opus 5.5 does on real office work across 44 jobs it scores 1844. Opus scores 1846 on coding it went from 10.3% to 70.6% in one version and passed Opus on the way most of what you pay Opus for, Sonnet 5.5 now does at half the price here's how to split the work: • give it to Sonnet 5.5 > bug fixes and well-scoped coding tasks > decks built from your own slide template > spreadsheets and polished documents > UI polish, it has a real eye for design > fast back-and-forth, it runs 30%+ faster • keep it for Opus 5.5 > long, open-ended work with judgment calls for hours > anything where one wrong assumption costs you a day • the setting that saves the most > Medium is the default in the Claude apps and Claude Code > on Low or Medium it beats Sonnet 5's best score for a tenth of the cost > raise effort only when the first answer falls short • the price > $2 in and $10 out, against $4 and $20 for Opus > cache reads $0.20 on both • check before you switch > if you ran Sonnet with thinking off, move to the new between_tools setting first whoever routes the weekly grunt work to Sonnet 5.5 and saves Opus for the hard calls ships more on half the budget, and that's the person who gets noticed

Annatar.md

19,642 Aufrufe • vor 29 Tagen

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared the sharpest trick for Claude Code The idea: let Opus 5.5 write the plan as a script, and swarm the new Haiku 5.5 in parallel Huge sweeps with zero Opus burn: the script holds the loop and Opus only sees the final diff You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your objective into an executable workflow script → Haiku 5.5 swarms every file in parallel at 340 tok/s to extract candidates → Sonnet 5.5 patches each fix and cross-checks findings in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → authoring the workflow script before the run → reading verified findings after the swarm finishes → signing off before anything ships to git 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 workflow.js > pipeline() fans out the new Haiku 5.5 to audit every file > parallel() schema validators drop false positives in V8 > Sonnet 5.5 patches each fix in an isolated worktree > verify cross-checks all diffs before reporting > 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 the new 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
0:24

THIS IS A PURE F*CKING GOLDMINE Anthropic just shared the sharpest trick for Claude Code The idea: let Opus 5.5 write the plan as a script, and swarm the new Haiku 5.5 in parallel Huge sweeps with zero Opus burn: the script holds the loop and Opus only sees the final diff You just launch Claude Code like this: claude --model opus --effort ultracode here's the split: → Opus 5.5 turns your objective into an executable workflow script → Haiku 5.5 swarms every file in parallel at 340 tok/s to extract candidates → Sonnet 5.5 patches each fix and cross-checks findings in its own isolated copy → you stop burning Opus context on a hundred agent transcripts Opus only shows up at three moments: → authoring the workflow script before the run → reading verified findings after the swarm finishes → signing off before anything ships to git 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 workflow.js > pipeline() fans out the new Haiku 5.5 to audit every file > parallel() schema validators drop false positives in V8 > Sonnet 5.5 patches each fix in an isolated worktree > verify cross-checks all diffs before reporting > 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 the new 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

mirku

200,066 Aufrufe • vor 11 Tagen

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
0:25

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,445 Aufrufe • vor 8 Tagen

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

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

mirku

81,928 Aufrufe • vor 13 Tagen