Loading video...

Video Failed to Load

Go Home

Official Anthropic tip for Claude Code: don't exhaust Opus 5.5 context on repetitive multi-file routines when Sonnet 5.5 can swarm them in parallel and Fable 5.1 can verify the result turn mass-agent sweeps into deterministic code with dynamic workflows claude --effort ultracode /workflows Opus 5.5 acts as the lead...

mirku21's profile picture

mirku

1,481 subscribers

18,295 views • 7 days ago •via X (Twitter)

LIVE

Anya Rossi• Live Now

Private livecam show

7 Comments

marfin's profile picture
marfin7 days ago

I think everyone needs to set up a workflow

beamnxw ./'s profile picture
beamnxw ./7 days ago

best tip by Antropic

Chen's profile picture
Chen6 days ago

sonnet 5.5 swarming multi-file routines faster than opus is such a no-brainer once you try it.

Paul Kruegel's profile picture
Paul Kruegel6 days ago

plan approval before the fan-out is the step i'd never skip. for verifying i mostly lean on tests and gates between the waves, does fable catch stuff those miss?

Lauane♡'s profile picture
Lauane♡6 days ago

i claimed my bonus credits #GHTRE

Ayush Barnwal | Building's profile picture
Ayush Barnwal | Building7 days ago

this is the right split lead plans, workers grind, verifier checks the part that still breaks is the brief not surviving the next session... clean context inside one run is not memory

Yibo Zhang's profile picture
Yibo Zhang6 days ago

@grok 如何制作这种动态的图片？

Related Videos

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

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

delost

43,704 views • 8 days ago

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

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

delost

48,494 views • 7 days ago

Claude Code tip, and it's absolute free f*cking gold: run Opus 5.5, Sonnet 5.5 and Fable 5.1 as one team and stop burning Opus tokens on routine work the setup in one line: plan on high, delegate on medium, keep Fable on call • who does what > Opus 5.5 on high - plans and ships the code > Sonnet 5.5 on medium - explorer reads code, worker edits and runs tests, researcher pulls docs > Fable 5.1 via /advisor fable - reads the whole session and speaks up only when it matters • when Fable 5.1 steps in -> before a plan: is this the right approach? -> when an error repeats: am I digging in the wrong place? -> before "done": what did I miss? Jev engineering takes it one layer lower: which file, which tool, retry or stop all go to Jev in under half a second, so the big models only see the real forks paste this into Claude Code ↓ "Rebuild my Claude Code setup: 1. Find subagents in ~/.claude/agents and .claude/agents that fit explorer, worker and researcher. Draft only the missing ones. Set each to model: sonnet, effort: medium. List any that pin a different model and leave them 2. In ~/.claude/settings.json set effortLevel to high and advisorModel to fable. 3. Report anything that disables the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, flag-fetching blockers) and CLAUDE_CODE_EFFORT_LEVEL. Change nothing. 4. Add to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done. Show every change as a diff. No edits until I say go." ↳
0:24

Claude Code tip, and it's absolute free f*cking gold: run Opus 5.5, Sonnet 5.5 and Fable 5.1 as one team and stop burning Opus tokens on routine work the setup in one line: plan on high, delegate on medium, keep Fable on call • who does what > Opus 5.5 on high - plans and ships the code > Sonnet 5.5 on medium - explorer reads code, worker edits and runs tests, researcher pulls docs > Fable 5.1 via /advisor fable - reads the whole session and speaks up only when it matters • when Fable 5.1 steps in -> before a plan: is this the right approach? -> when an error repeats: am I digging in the wrong place? -> before "done": what did I miss? Jev engineering takes it one layer lower: which file, which tool, retry or stop all go to Jev in under half a second, so the big models only see the real forks paste this into Claude Code ↓ "Rebuild my Claude Code setup: 1. Find subagents in ~/.claude/agents and .claude/agents that fit explorer, worker and researcher. Draft only the missing ones. Set each to model: sonnet, effort: medium. List any that pin a different model and leave them 2. In ~/.claude/settings.json set effortLevel to high and advisorModel to fable. 3. Report anything that disables the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, flag-fetching blockers) and CLAUDE_CODE_EFFORT_LEVEL. Change nothing. 4. Add to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done. Show every change as a diff. No edits until I say go." ↳

Mr. Buzzoni

142,491 views • 9 days ago

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

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 views • 10 days ago

Claude Code tip: keep Opus 5.5 as your main model, but stop paying Opus prices for your subagents move them to Sonnet 5.5 Opus 5.5 plans and decides Sonnet 5.5 subagents do the heavy reading, editing and testing at half the price ($2 / $10 vs $4 / $20 per 1M tokens) Fable 5.1 stays on call with /advisor and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Opus thinks. Sonnet does. Fable checks Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big models only see the ones that split - the full tree > Opus 5.5 on high runs the main session > explorer reads the code > worker edits and runs tests > researcher pulls the docs > all three on Sonnet 5.5, medium > Fable 5.1 on call as the advisor paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: claude-sonnet-5-5, effort: medium > List any that pin a different model before changing them 2. Keep the main session on Opus, set effortLevel to high in ~/.claude/settings.json and advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable that stops feature-flag fetching) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳
0:32

Claude Code tip: keep Opus 5.5 as your main model, but stop paying Opus prices for your subagents move them to Sonnet 5.5 Opus 5.5 plans and decides Sonnet 5.5 subagents do the heavy reading, editing and testing at half the price ($2 / $10 vs $4 / $20 per 1M tokens) Fable 5.1 stays on call with /advisor and only speaks up at three points: → before a plan: is this the right approach? → when the same error comes back: am I digging in the wrong place? → before "done": what did I miss? Opus thinks. Sonnet does. Fable checks Jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to Jev in under half a second, and the big models only see the ones that split - the full tree > Opus 5.5 on high runs the main session > explorer reads the code > worker edits and runs tests > researcher pulls the docs > all three on Sonnet 5.5, medium > Fable 5.1 on call as the advisor paste the tree and this prompt into Claude Code ↓ "Rebuild my Claude Code setup around this tree: 1. Check ~/.claude/agents and .claude/agents for subagents that already fit explorer, worker and researcher. > Draft new ones only for missing roles > Give each model: claude-sonnet-5-5, effort: medium > List any that pin a different model before changing them 2. Keep the main session on Opus, set effortLevel to high in ~/.claude/settings.json and advisorModel to fable 3. Find anything that keeps the advisor off (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, any variable that stops feature-flag fetching) plus CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, change nothing 4. Add one rule to ~/.claude/CLAUDE.md: consult the advisor before a large plan, when an error repeats, and before calling a long task done Show me every change as a diff first. No edits until I say go." ↳

delost

27,459 views • 9 days ago

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

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

delost

697,378 views • 12 days ago

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

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

Alvaro Cintas

54,424 views • 3 days ago

Claude Code tip: once Opus 5.5 is your main model, stop letting your Fable 5.1 quota go to waste put it on call with /advisor run /advisor fable Opus 5.5 keeps doing the work Fable 5.1 sits on the sidelines, reads the whole session, and steps in at three moments: → before a plan: is this right? → when the same error comes back: am I going the wrong way? → before "done": did I miss anything? Fable 5.1 advises. Opus 5.5 writes the code the same idea sits under Jev engineering: the expensive model stops weighing in on every step and only gets called at the moments that change the outcome • the full setup > Opus 5.5 on high runs the main session > subagent one reads code > subagent two edits and runs tests > subagent three looks up docs > all three on medium > Fable 5.1 on call hand the tree and this prompt to Claude Code 👇 "Set up my Claude Code to match this tree: 1. Reuse fitting subagents from ~/.claude/agents and .claude/agents. > Propose new ones only for missing roles > Set each to model: opus, effort: medium > Leave any that set a different model alone and list them 2. Set main session effort to high via effortLevel in ~/.claude/settings.json 3. Check for env vars that disable the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, anything that stops flag fetching) and CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, don't change them 4. Add a rule to ~/.claude/CLAUDE.md: ask the advisor before a big plan, when an error repeats, and before calling a long task done Show me the changes first. Don't edit files yet." ↳
0:24

Claude Code tip: once Opus 5.5 is your main model, stop letting your Fable 5.1 quota go to waste put it on call with /advisor run /advisor fable Opus 5.5 keeps doing the work Fable 5.1 sits on the sidelines, reads the whole session, and steps in at three moments: → before a plan: is this right? → when the same error comes back: am I going the wrong way? → before "done": did I miss anything? Fable 5.1 advises. Opus 5.5 writes the code the same idea sits under Jev engineering: the expensive model stops weighing in on every step and only gets called at the moments that change the outcome • the full setup > Opus 5.5 on high runs the main session > subagent one reads code > subagent two edits and runs tests > subagent three looks up docs > all three on medium > Fable 5.1 on call hand the tree and this prompt to Claude Code 👇 "Set up my Claude Code to match this tree: 1. Reuse fitting subagents from ~/.claude/agents and .claude/agents. > Propose new ones only for missing roles > Set each to model: opus, effort: medium > Leave any that set a different model alone and list them 2. Set main session effort to high via effortLevel in ~/.claude/settings.json 3. Check for env vars that disable the advisor (CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY, anything that stops flag fetching) and CLAUDE_CODE_EFFORT_LEVEL, which overrides subagent effort. Report them, don't change them 4. Add a rule to ~/.claude/CLAUDE.md: ask the advisor before a big plan, when an error repeats, and before calling a long task done Show me the changes first. Don't edit files yet." ↳

Mr. Buzzoni

324,943 views • 12 days ago

This is f*cking insane. I spent thousands of dollars before I split my work across three models put Opus 5.5 on the plan, Sonnet 5.5 on the legwork and Fable 5.1 on call, and you stop spending Opus money on jobs it was never needed for who does what: Opus 5.5, high effort: makes the plan and owns the final diff Sonnet 5.5, medium effort, three jobs: explorer reads the code, worker edits files and runs tests, researcher pulls the docs Fable 5.1, through /advisor fable: reads the whole session, but only when it gets called Fable is consulted at three points: → before a plan ships: is this the right approach? → when an error comes back twice: is the search stuck in the wrong place? → before a long task counts as done: what got missed? Jev engineering applies the same split to the smallest decisions. which file to open, which tool to run, retry or stop need no reasoning, so Jev answers them in under half a second and the big models only get the real forks run Opus on everything and you pay it to check whether a file exists paste this into Claude Code: "Rebuild my Claude Code setup around three tiers. Look in ~/.claude/agents and .claude/agents for subagents that already cover explorer, worker and researcher. Create only the missing ones, each with model: sonnet and effort: medium. If an existing one is pinned to another model, list it and leave it alone. In ~/.claude/settings.json, set advisorModel to fable. Set high effort for Opus inside modelSettings for claude-opus-5-5, because a top-level effortLevel does not apply to Opus 5.5. Report, without changing anything: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY or anything blocking feature-flag fetches, CLAUDE_CODE_EFFORT_LEVEL, which can override subagent effort, and whether Fable as advisor needs a one-time billing consent. If you can't tell, say so. Add one line to ~/.claude/CLAUDE.md: consult the advisor before a big plan, when the same error shows up twice, and before marking a long task done. Show every change as a diff first. Touch nothing until I say go."
0:24

This is f*cking insane. I spent thousands of dollars before I split my work across three models put Opus 5.5 on the plan, Sonnet 5.5 on the legwork and Fable 5.1 on call, and you stop spending Opus money on jobs it was never needed for who does what: Opus 5.5, high effort: makes the plan and owns the final diff Sonnet 5.5, medium effort, three jobs: explorer reads the code, worker edits files and runs tests, researcher pulls the docs Fable 5.1, through /advisor fable: reads the whole session, but only when it gets called Fable is consulted at three points: → before a plan ships: is this the right approach? → when an error comes back twice: is the search stuck in the wrong place? → before a long task counts as done: what got missed? Jev engineering applies the same split to the smallest decisions. which file to open, which tool to run, retry or stop need no reasoning, so Jev answers them in under half a second and the big models only get the real forks run Opus on everything and you pay it to check whether a file exists paste this into Claude Code: "Rebuild my Claude Code setup around three tiers. Look in ~/.claude/agents and .claude/agents for subagents that already cover explorer, worker and researcher. Create only the missing ones, each with model: sonnet and effort: medium. If an existing one is pinned to another model, list it and leave it alone. In ~/.claude/settings.json, set advisorModel to fable. Set high effort for Opus inside modelSettings for claude-opus-5-5, because a top-level effortLevel does not apply to Opus 5.5. Report, without changing anything: CLAUDE_CODE_DISABLE_ADVISOR_TOOL, DISABLE_TELEMETRY or anything blocking feature-flag fetches, CLAUDE_CODE_EFFORT_LEVEL, which can override subagent effort, and whether Fable as advisor needs a one-time billing consent. If you can't tell, say so. Add one line to ~/.claude/CLAUDE.md: consult the advisor before a big plan, when the same error shows up twice, and before marking a long task done. Show every change as a diff first. Touch nothing until I say go."

Ryven

46,513 views • 3 days ago

this is straight f*cking gold for anyone on Claude Code you already pay for Fable 5.1, and while Opus 5.5 does all the work it just sits there one command puts it on your session as a senior reviewer: /advisor fable Opus 5.5 keeps writing the code Fable 5.1 reads the whole session, every tool call included, and speaks up at three moments only: > 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 does the same thing one layer down: 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 actually 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" ↳
0:24

this is straight f*cking gold for anyone on Claude Code you already pay for Fable 5.1, and while Opus 5.5 does all the work it just sits there one command puts it on your session as a senior reviewer: /advisor fable Opus 5.5 keeps writing the code Fable 5.1 reads the whole session, every tool call included, and speaks up at three moments only: > 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 does the same thing one layer down: 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 actually 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" ↳

Annatar.md

74,132 views • 10 days ago

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

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

rvaniaaa

250,263 views • 8 days ago

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

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

delost

69,880 views • 6 days ago

I don't understand why everyone isn't doing this yet. Anthropic released a guide for Claude that makes work much more efficient while burning a fraction of the tokens Main Idea: Agent Teams in Claude Code Instead of burning the expensive Opus 5.5 context on every line of code, tasks are delegated across an autonomous swarm: Architect (Opus 5.5, high effort): Plans the structure and handles final PR merges Developers (Sonnet 5.5, medium effort): Write code inside isolated ⁠git worktree⁠ environments (UI/UX, backend) Adversary / Critic (Fable 5.1): Steps in at contract boundaries, recurring test failures, and pre-PR audits to catch vulnerabilities Script Layer (Jev): Handles mechanical tasks (opening files, CLI invocations) in 16ms without involving LLMs Launch the team via terminal: claude --teammates ux,backend,adversary Configure my Claude Code workspace for autonomous agent teams: In ⁠~/.claude/teams⁠, generate missing roles: set workers to ⁠Sonnet⁠ (⁠medium effort⁠) in separate ⁠git worktree⁠ branches, and the adversary to ⁠Fable⁠ In ⁠~/.claude/settings.json⁠, set ⁠CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1⁠ and lock the main session to ⁠effortLevel: high⁠ Initialize ⁠tasks.json⁠ with file-level locking for direct peer coordination In ⁠CLAUDE.md⁠, add a rule requiring an adversary review before opening a PR. Show configuration diffs before applying edits >
0:24

I don't understand why everyone isn't doing this yet. Anthropic released a guide for Claude that makes work much more efficient while burning a fraction of the tokens Main Idea: Agent Teams in Claude Code Instead of burning the expensive Opus 5.5 context on every line of code, tasks are delegated across an autonomous swarm: Architect (Opus 5.5, high effort): Plans the structure and handles final PR merges Developers (Sonnet 5.5, medium effort): Write code inside isolated ⁠git worktree⁠ environments (UI/UX, backend) Adversary / Critic (Fable 5.1): Steps in at contract boundaries, recurring test failures, and pre-PR audits to catch vulnerabilities Script Layer (Jev): Handles mechanical tasks (opening files, CLI invocations) in 16ms without involving LLMs Launch the team via terminal: claude --teammates ux,backend,adversary Configure my Claude Code workspace for autonomous agent teams: In ⁠~/.claude/teams⁠, generate missing roles: set workers to ⁠Sonnet⁠ (⁠medium effort⁠) in separate ⁠git worktree⁠ branches, and the adversary to ⁠Fable⁠ In ⁠~/.claude/settings.json⁠, set ⁠CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1⁠ and lock the main session to ⁠effortLevel: high⁠ Initialize ⁠tasks.json⁠ with file-level locking for direct peer coordination In ⁠CLAUDE.md⁠, add a rule requiring an adversary review before opening a PR. Show configuration diffs before applying edits >

Bober_smart

326,267 views • 7 days ago

WHOEVER LEAKED THIS CLAUDE CODE SETUP DESERVES A RAISE I thought the best way to use Claude Code was to just throw Opus at everything. Apparently not. Anthropic’s setup is much more interesting: → Sonnet 5.5 runs the main session and actually builds the thing → Haiku 5.5 swarms the repo for file discovery, AST scans, grep, and docs → Opus 5.5 stays in the background as the architect → Opus gets called in before big plans, after repeated test failures, and before shipping → JEV handles the boring mechanical routing in ~16ms so frontier models only wake up when real reasoning is needed so you get: Opus reviews. Sonnet builds. Haiku swarms. JEV routes. the interesting part isn’t using multiple models. it’s giving each model a different job. Instead of burning Opus context on finding files and running routine commands, you save it for the moments where architectural judgment actually matters. Plan on high.Delegate on medium. Keep Opus on call.
0:24

WHOEVER LEAKED THIS CLAUDE CODE SETUP DESERVES A RAISE I thought the best way to use Claude Code was to just throw Opus at everything. Apparently not. Anthropic’s setup is much more interesting: → Sonnet 5.5 runs the main session and actually builds the thing → Haiku 5.5 swarms the repo for file discovery, AST scans, grep, and docs → Opus 5.5 stays in the background as the architect → Opus gets called in before big plans, after repeated test failures, and before shipping → JEV handles the boring mechanical routing in ~16ms so frontier models only wake up when real reasoning is needed so you get: Opus reviews. Sonnet builds. Haiku swarms. JEV routes. the interesting part isn’t using multiple models. it’s giving each model a different job. Instead of burning Opus context on finding files and running routine commands, you save it for the moments where architectural judgment actually matters. Plan on high.Delegate on medium. Keep Opus on call.

Arindam Majumder 𝕏

199,027 views • 1 day ago

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

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

Carnage

16,674 views • 17 days ago

JEV + OPUS 5.5 IS INSANE FOR BUILDING A COMPANY BRAIN I pulled the whole architecture out of the TypeSafe and Anthropic docs and packed it into a 14-page PDF the 10 steps: 1. meet the pair > Opus 5.5 thinks, Jev decides, your code holds the branch 2. stop asking a text generator for a yes or no > Jev returns a typed answer with a calibrated probability in 0.44s for $0.00035 3. ask everything at once > Choice, Score and Noul run in parallel, so the fourth question costs almost nothing 4. branch on the number > 0.999 goes straight into the if statement. ~99% of turns end right here 5. stop routing blind > Opus 5.5 to Sonnet and back costs 5.84 against 3.32 for staying on 5.5 6. keep one context warm > cache reads at $0.20 per Mtok are 20x cheaper than a fresh load 7. escalate the hard part > the toughest 1% goes to Opus 5.5 with 1M context and 66.4% on Terminal-Bench 4.0 8. score every chunk on every query > keep whole, summarize or drop. the context gets rebuilt each turn 9. gate the actual command > every bash call gets classified before it runs, inside your own code 10. judge 100% of runs > $3.50 a day for 10,000 traces, and it matched the human label on all 500 decisions the result: a while loop that paid a frontier model for every tiny call turns into a brain that spends a fraction of a cent to notice and pays properly only when it has to think the person who brings this into their team walks into the budget meeting with the AI bill cut and the output up the PDF maps the company brain. the loop side of it - how Jev takes a Claude bill from $765 to $3 a month - is in the article below ↓
0:24

JEV + OPUS 5.5 IS INSANE FOR BUILDING A COMPANY BRAIN I pulled the whole architecture out of the TypeSafe and Anthropic docs and packed it into a 14-page PDF the 10 steps: 1. meet the pair > Opus 5.5 thinks, Jev decides, your code holds the branch 2. stop asking a text generator for a yes or no > Jev returns a typed answer with a calibrated probability in 0.44s for $0.00035 3. ask everything at once > Choice, Score and Noul run in parallel, so the fourth question costs almost nothing 4. branch on the number > 0.999 goes straight into the if statement. ~99% of turns end right here 5. stop routing blind > Opus 5.5 to Sonnet and back costs 5.84 against 3.32 for staying on 5.5 6. keep one context warm > cache reads at $0.20 per Mtok are 20x cheaper than a fresh load 7. escalate the hard part > the toughest 1% goes to Opus 5.5 with 1M context and 66.4% on Terminal-Bench 4.0 8. score every chunk on every query > keep whole, summarize or drop. the context gets rebuilt each turn 9. gate the actual command > every bash call gets classified before it runs, inside your own code 10. judge 100% of runs > $3.50 a day for 10,000 traces, and it matched the human label on all 500 decisions the result: a while loop that paid a frontier model for every tiny call turns into a brain that spends a fraction of a cent to notice and pays properly only when it has to think the person who brings this into their team walks into the budget meeting with the AI bill cut and the output up the PDF maps the company brain. the loop side of it - how Jev takes a Claude bill from $765 to $3 a month - is in the article below ↓

Mr. Buzzoni

103,282 views • 12 days ago

ANTHROPIC LEAKED A FILE WHERE 5 AGENTS WITH JEV BUILD A $1.2M A YEAR SYSTEM IN 30 MINUTES you pay $3.70 and walk away with an asset that can do $1.2M a year repo → data model → API → UI → evals no layer starts until the one under it is closed, and that edge is what turns five scripts into a system the operator on Haiku 4.5 brings up the repo and CI, the architect on Opus 5 lays down the data model and migrations two builders on Sonnet 5 run API and UI in parallel, and the reviewer on Opus 5.5 can keep finished code out of prod the evals were sitting in the file before the first line of code existed at minute zero there was not a single file, by the end it is a working product with payments and tests five agents cover in half an hour what a human team bills for a quarter JEV hands one line between layers instead of the whole history, so the next agent never re-reads the project and the run costs $3.70 instead of $370 the build takes 30 minutes, the first customers show up weeks later save this and paste it into Claude Code - let it assemble those 5 layers for you ↓
1:20

ANTHROPIC LEAKED A FILE WHERE 5 AGENTS WITH JEV BUILD A $1.2M A YEAR SYSTEM IN 30 MINUTES you pay $3.70 and walk away with an asset that can do $1.2M a year repo → data model → API → UI → evals no layer starts until the one under it is closed, and that edge is what turns five scripts into a system the operator on Haiku 4.5 brings up the repo and CI, the architect on Opus 5 lays down the data model and migrations two builders on Sonnet 5 run API and UI in parallel, and the reviewer on Opus 5.5 can keep finished code out of prod the evals were sitting in the file before the first line of code existed at minute zero there was not a single file, by the end it is a working product with payments and tests five agents cover in half an hour what a human team bills for a quarter JEV hands one line between layers instead of the whole history, so the next agent never re-reads the project and the run costs $3.70 instead of $370 the build takes 30 minutes, the first customers show up weeks later save this and paste it into Claude Code - let it assemble those 5 layers for you ↓

Sprytix

14,208 views • 15 days ago

this is pure f*cking treasure Anthropic devs just posted 20 GitHub repos that turn your Claude Code into a f*cking engineering team: Exposed for Opus 5.5 1. rtk: squeezes command output before it hits your context. the authors claim 60-90% fewer tokens 2. claude-mem: memory across sessions. records what the agent did and brings back what matters 3. ccusage: shows where your tokens and money went. one command, npx ccusage 4. Serena: search and edit code by meaning, not by text 5. Context7: up-to-date library docs, so Claude stops writing for last year's API 6. claude-context: your whole codebase searchable through MCP 7. Repomix: packs an entire repo into one AI-friendly file skills and method 8. superpowers: a skills framework and a full development methodology. the one almost everyone installs 9. skills: the official Agent Skills repo from Anthropic 10. spec-kit: spec-driven development, from GitHub itself 11. agents: a plugin marketplace for Claude Code and six other harnesses 12. claude-code-templates: ready configs and monitoring from one CLI 13. claude-code-hooks-mastery: hooks explained with working examples 14. awesome-claude-code: the hand-picked map of everything else running more than one agent 15. container-use: a separate container for every agent, so they stop breaking each other 16. claude-squad: several terminal agents in one window 17. Happy: control your agents from your phone, iOS and Android 18. claude-code-router: route requests across different models 19. ccstatusline: a status line that shows what your session is doing 20. tweakcc: edit Claude Code's own system prompts, toolsets and themes the stack in one line: memory keeps the context, skills set the method, containers let you run five agents instead of one. check each repo before you install. save this.
0:30

this is pure f*cking treasure Anthropic devs just posted 20 GitHub repos that turn your Claude Code into a f*cking engineering team: Exposed for Opus 5.5 1. rtk: squeezes command output before it hits your context. the authors claim 60-90% fewer tokens 2. claude-mem: memory across sessions. records what the agent did and brings back what matters 3. ccusage: shows where your tokens and money went. one command, npx ccusage 4. Serena: search and edit code by meaning, not by text 5. Context7: up-to-date library docs, so Claude stops writing for last year's API 6. claude-context: your whole codebase searchable through MCP 7. Repomix: packs an entire repo into one AI-friendly file skills and method 8. superpowers: a skills framework and a full development methodology. the one almost everyone installs 9. skills: the official Agent Skills repo from Anthropic 10. spec-kit: spec-driven development, from GitHub itself 11. agents: a plugin marketplace for Claude Code and six other harnesses 12. claude-code-templates: ready configs and monitoring from one CLI 13. claude-code-hooks-mastery: hooks explained with working examples 14. awesome-claude-code: the hand-picked map of everything else running more than one agent 15. container-use: a separate container for every agent, so they stop breaking each other 16. claude-squad: several terminal agents in one window 17. Happy: control your agents from your phone, iOS and Android 18. claude-code-router: route requests across different models 19. ccstatusline: a status line that shows what your session is doing 20. tweakcc: edit Claude Code's own system prompts, toolsets and themes the stack in one line: memory keeps the context, skills set the method, containers let you run five agents instead of one. check each repo before you install. save this.

kiosa

55,680 views • 1 day ago

ok this is a f*cking cheat code for coding agents how to make them 200x faster and 400x cheaper with Jev engineering Jev founder Diogo Amogo put the whole harness into a 12-page PDF, 10 steps: 1. meet Jev the LLM writes, the harness executes, Jev decides what each turn sees, where it routes and whether it runs 2. ask the question that breaks every agent how would you build one if LLMs had no KV cache? 3. quit blind routing Claude Opus 5.5 -> Sonnet 5.5 -> Opus costs 6.19, Opus alone 4.15, because every handoff reprocesses the full context 4. follow the tokens reading and searching eat 56.2% of tool turns and 46.5% of tokens, writing code stays under 10% 5. score each chunk per query hide it, summarize it or keep it whole, and compress once the question is known 6. reveal tools in tiers one-line snippets for hundreds of tools, full schema on demand 7. load instructions by condition a *.tsx edit pulls the style guide, billing/ pulls its gotchas file, compaction can't wipe either 8. route by trust as well as difficulty secrets and infra stay on first-party frontier models, public docs go to the cheapest one 9. reuse one retrieval pass review, evals, explainers and progress pages all run read-only in the background 10. gate every command allow / ask / deny policies read the whole script before it runs hand this PDF and the article below to Claude Code or Codex and start shipping faster
0:24

ok this is a f*cking cheat code for coding agents how to make them 200x faster and 400x cheaper with Jev engineering Jev founder Diogo Amogo put the whole harness into a 12-page PDF, 10 steps: 1. meet Jev the LLM writes, the harness executes, Jev decides what each turn sees, where it routes and whether it runs 2. ask the question that breaks every agent how would you build one if LLMs had no KV cache? 3. quit blind routing Claude Opus 5.5 -> Sonnet 5.5 -> Opus costs 6.19, Opus alone 4.15, because every handoff reprocesses the full context 4. follow the tokens reading and searching eat 56.2% of tool turns and 46.5% of tokens, writing code stays under 10% 5. score each chunk per query hide it, summarize it or keep it whole, and compress once the question is known 6. reveal tools in tiers one-line snippets for hundreds of tools, full schema on demand 7. load instructions by condition a *.tsx edit pulls the style guide, billing/ pulls its gotchas file, compaction can't wipe either 8. route by trust as well as difficulty secrets and infra stay on first-party frontier models, public docs go to the cheapest one 9. reuse one retrieval pass review, evals, explainers and progress pages all run read-only in the background 10. gate every command allow / ask / deny policies read the whole script before it runs hand this PDF and the article below to Claude Code or Codex and start shipping faster

Mr. Buzzoni

20,730 views • 7 days ago

Codex tip: once GPT-6.1 Sol runs your main session, stop paying Sol prices for the grunt work hand the reading to Luna and put Astra on call Sol keeps writing the code Luna agents read the repo and pull the docs, fast and cheap Astra only gets spawned 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? Sol ships. Luna reads. Astra checks jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to jev in under half a second, and the big models only see the ones that split - the full tree > GPT-6.1 Sol on high runs the main session > explorer reads the code on Luna > researcher pulls the docs on Luna > worker edits and runs tests on Sol > Astra on call as the architect > auto_review watches every approval paste the tree and this prompt into Codex ↓ "Rebuild my Codex setup around this tree: 1. Check ~/.codex/agents and .codex/agents for agents that already fit explorer, researcher and worker. > Draft new TOML files only for missing roles > explorer and researcher on gpt-6-luna, worker on gpt-6.1-sol, all with model_reasoning_effort medium > Add an architect agent on gpt-6-astra, model_reasoning_effort high, that only reviews plans, repeated errors and finished work > List any that pin a different model before changing them 2. In ~/.codex/config.toml set model to gpt-6.1-sol, model_reasoning_effort to high and approvals_reviewer to auto_review 3. Find anything that would override this (active profiles, flags in my shell aliases, agents.default_subagent_model). Report it, change nothing 4. Add one rule to AGENTS.md: spawn the architect 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." ↳
0:31

Codex tip: once GPT-6.1 Sol runs your main session, stop paying Sol prices for the grunt work hand the reading to Luna and put Astra on call Sol keeps writing the code Luna agents read the repo and pull the docs, fast and cheap Astra only gets spawned 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? Sol ships. Luna reads. Astra checks jev engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or stop) go to jev in under half a second, and the big models only see the ones that split - the full tree > GPT-6.1 Sol on high runs the main session > explorer reads the code on Luna > researcher pulls the docs on Luna > worker edits and runs tests on Sol > Astra on call as the architect > auto_review watches every approval paste the tree and this prompt into Codex ↓ "Rebuild my Codex setup around this tree: 1. Check ~/.codex/agents and .codex/agents for agents that already fit explorer, researcher and worker. > Draft new TOML files only for missing roles > explorer and researcher on gpt-6-luna, worker on gpt-6.1-sol, all with model_reasoning_effort medium > Add an architect agent on gpt-6-astra, model_reasoning_effort high, that only reviews plans, repeated errors and finished work > List any that pin a different model before changing them 2. In ~/.codex/config.toml set model to gpt-6.1-sol, model_reasoning_effort to high and approvals_reviewer to auto_review 3. Find anything that would override this (active profiles, flags in my shell aliases, agents.default_subagent_model). Report it, change nothing 4. Add one rule to AGENTS.md: spawn the architect 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

29,559 views • 9 days ago