Загрузка видео...

Не удалось загрузить видео

На главную

BEFORE: Opus 5.5 does everything. Reads every file. Decides every retry. $6.42 per task. AFTER: Jev makes the small decisions. Opus only does the hard reasoning. Confidence thresholds catch the risky calls. $2.00 per task. Same agent. Same code quality. A third of the bill. Full build below 👇

24,858 просмотров • 15 дней назад •via X (Twitter)

Комментарии: 8

Фото профиля Arhi | AI × Crypto
Arhi | AI × Crypto14 дней назад

the confidence threshold idea is solid but curious what your actual false positive rate looks like on those easy calls before you filter to opus

Фото профиля James Malsawm
James Malsawm15 дней назад

$6.42 down to $2.00 just by letting opus 5.5 skip the small stuff, smart

Фото профиля Degenpark
Degenpark14 дней назад

did the confidence thresholds need calibration per-task or did you find one value that worked across the board? 🎯

Фото профиля Vipul Kumar Kewat
Vipul Kumar Kewat15 дней назад

This is where model routing delivers real savings.

Фото профиля Oliver Hayes
Oliver Hayes14 дней назад

A good leader outsources thinking that can and should be done by the team to the team. Works for models too.

Фото профиля Asmir
Asmir15 дней назад

i think the catch is the calls the threshold sends up, opus now gets the hard ones with less context than when it read everything itself

Фото профиля Sachin
Sachin15 дней назад

Routing the small decisions to a cheaper model is the real cost win. Most retry loops do not need the big model every time.

Фото профиля fuzzy
fuzzy14 дней назад

i used to let the main model decide every tiny retry too. that gets expensive way faster than you expect

Похожие видео

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

396,618 просмотров • 10 дней назад

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,801 просмотров • 8 дней назад

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

318,344 просмотров • 11 дней назад

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

313,925 просмотров • 13 дней назад

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 просмотров • 9 дней назад

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

199,296 просмотров • 8 дней назад

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,723 просмотров • 10 дней назад

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,225 просмотров • 7 дней назад

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

18,324 просмотров • 6 дней назад