Video wird geladen...

Video konnte nicht geladen werden

Beim Laden dieses Videos ist ein Problem aufgetreten. Dies könnte an einem vorübergehenden Netzwerkproblem liegen oder das Video ist möglicherweise nicht verfügbar.

Opus 5.5 + Jev make this AI stack look f…cking illegal 10 GitHub repos for building everything around the model 01 claude-code-router ▸ → routes every request to the model you pick, Opus only where it counts 02 litellm ▸ → one gateway in front of 100+ models, spend... tracked per call 03 spec-kit ▸ → spec first, plan second, code last 04 claude-task-master ▸ → your PRD becomes tasks the agent works through one by one 05 superpowers ▸ → a full dev method built from skills: plan, test, then call it done 06 skills ▸ → Anthropic's own skills, folders Claude loads only when the job needs them 07 graphiti ▸ → memory as a temporal knowledge graph, not a dump 08 langgraph ▸ → agents as graphs: state, branches, back edges 09 E2B ▸ → AI-written code runs in isolated cloud sandboxes, not on your machine 10 promptfoo ▸ → evals and red teaming before anything ships the architecture: route → spec → tasks → skills → memory → graph → sandbox → evals I'd split the stack like this: route: claude-code-router → litellm plan: spec-kit → claude-task-master work: superpowers → skills state: graphiti → langgraph safety: E2B → promptfoo Opus 5.5 plans and ships. the forks in between, which file, which tool, retry or stop, go to Jev everyone posts the model and the prompt pack the stack around it decides whether your agent is still running next week ⭣show more

Chen

1,695 subscribers

35,110 Aufrufe • vor 1 Monat •via X (Twitter)

Wissenschaft & Technologie

Anya Rossi• Live Now

Private livecam show

13 Kommentare

Profilbild von 晚晚

晚晚vor 1 Monat

Opus 只用在关键步骤，账单应该能少吓人一点。

Profilbild von Jordan Lee

Jordan Leevor 29 Tagen

10 repos just to make Opus behave like an actual employee 😭

Profilbild von Kinsley

Kinsleyvor 1 Monat

What's the hold on that decision brain?

Profilbild von Chen

Chenvor 1 Monat

opus 5.5 plus jev sounding illegal tracks, i’d hoard those 10 repos fast.

Profilbild von Aditya Chawla

Aditya Chawlavor 1 Monat

That stack breakdown is one of the best listicles I've seen this week — the architecture compression at the end is the real value. I'm building AI tools too, let's connect!

Profilbild von JΞr₳h

JΞr₳hvor 1 Monat

opus 5.5 + routing repos is the stack people are actually using now. jev-style harnesses keep showing up for a reason.

Profilbild von 烦70·BG月白

烦70·BG月白vor 1 Monat

这套组合拳打下来简直是降维打击

Profilbild von YN

YNvor 1 Monat

2つの動画画面がリンクしてる！？

Profilbild von MichaelWu

MichaelWuvor 20 Tagen

组合多个路由工具时，我会先明确由哪一层选模型、哪一层负责回退。每次选模和上游尝试都关联同一个任务 ID，最后再核对实际成本，排查就会更直接。

Profilbild von catman

catmanvor 1 Monat

A sandbox like E2B is the safety boundary in this stack: agents can run generated code without giving it direct access to your machine.

Profilbild von Cole

Colevor 1 Monat

routing Opus only where it counts is most of the value here tbh, the other repos are plumbing around that one call

Profilbild von Kennedy

Kennedyvor 1 Monat

Routing models like counting cards. Casinos ban that too. What's the EV on this stack?

Profilbild von Van Quan

Van Quanvor 29 Tagen

the real alpha is building for the routing, not the prompt engineering

Ähnliche Videos

Opus 5.5 makes this AI stack look f…cking illegal 10 GitHub repos for building everything around the model 01 zen-mcp-server ▸ → your agent debates Gemini, GPT and local models mid-task 02 claude-context ▸ → semantic code search so the agent stops grepping blind 03 wshobson/agents ▸ → a roster of subagents, each with one narrow job 04 mcp-agent ▸ → workflow patterns built around MCP tools, not around chat 05 Backlog.md ▸ → tasks live in git, so the agent and you read the same board 06 Claude Code Development Kit ▸ → hooks, subagents and MCP wired for context at scale 07 agent-rules ▸ → shared guardrails the agent inherits in every repo 08 Agent Skills ▸ → one file that teaches the agent a job, portable across tools 09 agent-scan ▸ → scans your agents, MCP servers and skills for what leaks 10 awesome-claude-code-toolkit ▸ → the map: agents, skills, commands, hooks, MCP configs the architecture: rules → context → subagents → tools → state → review → scan I'd split the stack like this: context: claude-context → Development Kit work: wshobson/agents → mcp-agent → zen-mcp-server state: Backlog.md safety: agent-rules → Agent Skills → agent-scan everyone posts the SDK and the CLI the layer that decides whether your agent survives a week is this one the model is one folder in the stack ⭣

Opus 5.5 makes this AI stack look f…cking illegal 10 GitHub repos for building everything around the model 01 zen-mcp-server ▸ → your agent debates Gemini, GPT and local models mid-task 02 claude-context ▸ → semantic code search so the agent stops grepping blind 03 wshobson/agents ▸ → a roster of subagents, each with one narrow job 04 mcp-agent ▸ → workflow patterns built around MCP tools, not around chat 05 Backlog.md ▸ → tasks live in git, so the agent and you read the same board 06 Claude Code Development Kit ▸ → hooks, subagents and MCP wired for context at scale 07 agent-rules ▸ → shared guardrails the agent inherits in every repo 08 Agent Skills ▸ → one file that teaches the agent a job, portable across tools 09 agent-scan ▸ → scans your agents, MCP servers and skills for what leaks 10 awesome-claude-code-toolkit ▸ → the map: agents, skills, commands, hooks, MCP configs the architecture: rules → context → subagents → tools → state → review → scan I'd split the stack like this: context: claude-context → Development Kit work: wshobson/agents → mcp-agent → zen-mcp-server state: Backlog.md safety: agent-rules → Agent Skills → agent-scan everyone posts the SDK and the CLI the layer that decides whether your agent survives a week is this one the model is one folder in the stack ⭣

rody

18,089 Aufrufe • vor 1 Monat

this is where GPT-6 Astra is getting f...cking illegal 10 open-source GitHub repos I'd use to build the system around the model 01 PydanticAI ▸ → typed agents + structured outputs 02 LangGraph ▸ → state + long-running agent workflows BUILD THE AGENTS 03 Agno ▸ → agents + teams + workflows 04 smolagents ▸ → agents that execute through code GIVE THEM MEMORY 05 Mem0 ▸ → persistent agent memory 06 Graphiti ▸ → temporal knowledge graphs GIVE THEM A RUNTIME 07 E2B ▸ → isolated sandboxes for AI-generated code 08 Daytona ▸ → infrastructure for running agent workloads TEST EVERYTHING 09 DeepEval ▸ → evals for LLM systems 10 Langfuse ▸ → traces + evals + production monitoring the flow: request → agent → memory → tools → runtime → eval → retry → deploy that's the part people underestimate the model is one folder the system around it is the product ⭣

this is where GPT-6 Astra is getting f...cking illegal 10 open-source GitHub repos I'd use to build the system around the model 01 PydanticAI ▸ → typed agents + structured outputs 02 LangGraph ▸ → state + long-running agent workflows BUILD THE AGENTS 03 Agno ▸ → agents + teams + workflows 04 smolagents ▸ → agents that execute through code GIVE THEM MEMORY 05 Mem0 ▸ → persistent agent memory 06 Graphiti ▸ → temporal knowledge graphs GIVE THEM A RUNTIME 07 E2B ▸ → isolated sandboxes for AI-generated code 08 Daytona ▸ → infrastructure for running agent workloads TEST EVERYTHING 09 DeepEval ▸ → evals for LLM systems 10 Langfuse ▸ → traces + evals + production monitoring the flow: request → agent → memory → tools → runtime → eval → retry → deploy that's the part people underestimate the model is one folder the system around it is the product ⭣

Lummox

43,873 Aufrufe • vor 1 Monat

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

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

delost

400,076 Aufrufe • vor 19 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.

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

xsmryze

60,847 Aufrufe • vor 12 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.

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

delost

320,430 Aufrufe • vor 20 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.

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

xsmryze

193,232 Aufrufe • vor 9 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.

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

delost

316,202 Aufrufe • vor 22 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.

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 17 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

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,842 Aufrufe • vor 17 Tagen

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

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

mirku

424,860 Aufrufe • vor 1 Monat

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

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

74,302 Aufrufe • vor 19 Stunden

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

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

xsmryze

73,291 Aufrufe • vor 8 Tagen

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

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

Sprytix

132,535 Aufrufe • vor 15 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." ↳

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,765 Aufrufe • vor 14 Tagen

Introducing Jev Model Router for Claude Code This Claude Code Mod lets you use Jev through its direct TypeSafe AI API or Vercel AI Gateway With every request you send to Claude Code, Jev classifies the subagent model, main model (only at session start to avoid breaking the cache), and effort level Install it with one command: npx claude-code-templates@latest --mod productivity/jev-model-router Full Mod details:

Introducing Jev Model Router for Claude Code This Claude Code Mod lets you use Jev through its direct TypeSafe AI API or Vercel AI Gateway With every request you send to Claude Code, Jev classifies the subagent model, main model (only at session start to avoid breaking the cache), and effort level Install it with one command: npx claude-code-templates@latest --mod productivity/jev-model-router Full Mod details:

Daniel San

209,112 Aufrufe • vor 1 Monat

I still don’t understand why people build Opus 5.5 setups from scratch. 10 repos already did it for you, from 68K stars to 0. 01 claude-code-best-practice → 68K stars. the full guide to subagents, skills, hooks, MCP and memory, with working examples 02 claude-skills → 28K stars. 388 ready skills across 20 fields, built for Claude Code, Codex and Gemini CLI 03 awesome-claude-code-toolkit → 2.7K stars. 135 agents, 42 commands, 20 hooks and 15 rules you can drop into a project 04 AI-Product-Development-Toolkit → 994 stars. six planning prompts, a Next.js starter and a ready CLAUDE.md written for Opus 5.5 05 awesome-claude-video-skills → 867 stars. 300+ repos that teach Claude to make video, sorted by type 06 awesome-claude-code → 508 stars. the cleanest map of tools, plugins and usage trackers around Claude Code 07 motion-graphics-skills → 375 stars. launch-style motion graphics where every frame is code, no After Effects 08 opus-5-5-dev → 1 star. rules for long runs: define “done” first, keep a TASKS.md, end with a fixed four-part report 09 model-bump → 0 stars. scans your code for what breaks on Opus 5.5, like forced tool choice, sampling settings and prefill 10 claude-best-practices → 1 star. 29 agents, 174 skills, 58 rules and 22 hooks to copy into your project stars measure hype. fit measures results. pick one, run it on a single task, keep only what survives. save this before you upgrade, and follow for more setups like this

I still don’t understand why people build Opus 5.5 setups from scratch. 10 repos already did it for you, from 68K stars to 0. 01 claude-code-best-practice → 68K stars. the full guide to subagents, skills, hooks, MCP and memory, with working examples 02 claude-skills → 28K stars. 388 ready skills across 20 fields, built for Claude Code, Codex and Gemini CLI 03 awesome-claude-code-toolkit → 2.7K stars. 135 agents, 42 commands, 20 hooks and 15 rules you can drop into a project 04 AI-Product-Development-Toolkit → 994 stars. six planning prompts, a Next.js starter and a ready CLAUDE.md written for Opus 5.5 05 awesome-claude-video-skills → 867 stars. 300+ repos that teach Claude to make video, sorted by type 06 awesome-claude-code → 508 stars. the cleanest map of tools, plugins and usage trackers around Claude Code 07 motion-graphics-skills → 375 stars. launch-style motion graphics where every frame is code, no After Effects 08 opus-5-5-dev → 1 star. rules for long runs: define “done” first, keep a TASKS.md, end with a fixed four-part report 09 model-bump → 0 stars. scans your code for what breaks on Opus 5.5, like forced tool choice, sampling settings and prefill 10 claude-best-practices → 1 star. 29 agents, 174 skills, 58 rules and 22 hooks to copy into your project stars measure hype. fit measures results. pick one, run it on a single task, keep only what survives. save this before you upgrade, and follow for more setups like this

Ryven

17,804 Aufrufe • vor 9 Tagen

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

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

delost

700,925 Aufrufe • vor 1 Monat

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

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

delost

48,964 Aufrufe • vor 1 Monat

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

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

Hanako

52,065 Aufrufe • vor 1 Monat

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

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

kiosa

19,390 Aufrufe • vor 15 Tagen