正在加载视频...

视频加载失败

返回首页

holy f*ck. Official Anthropic tip for Claude Code: stop running agent teams on Opus and Sonnet 5.5 alone when Haiku 5.5 can swarm the bus at 340 tok/s spin up an autonomous team with /teams claude --teammate-mode auto Opus 5.5 acts as the lead architect, scoping architecture and validating...

mirku21's profile picture

mirku

1,490 subscribers

82,064 次观看 • 2 天前 •via X (Twitter)

科学技术
LIVE

Anya Rossi• Live Now

Private livecam show

17 条评论

Tin 的头像
Tin1 天前

340 tok/s of haiku confidently reading the wrong file I just hand the grunt work to codex from claude code instead:

marfin 的头像
marfin2 天前

I think this is the most useful tip for large agency projects because when they're running for a long time, Opus and Sonnet start burning through a huge amount of money

Anderson 的头像
Anderson1 天前

swarm the cheap model and pray the quality holds

Perk🥀 的头像
Perk🥀2 天前

haiku as a cheap second layer makes a lot of sense

beamnxw ./ 的头像
beamnxw ./2 天前

the model roles are actually pretty clean here

Hale 的头像
Hale1 天前

The 'smart boss + cheap fast workers' pattern won. Your agent architecture should look like a good company: one brain, many hands.

Ronald 的头像
Ronald1 天前

Haiku swarms the bus but the rake still eats you. Hours played > tokens/sec.

John Kovacs 的头像
John Kovacs1 天前

teammate-mode auto is still a hand flip for me. 340 tok/s on the haiku bus is why i'd leave it alone

DigitalAssetBuzz 🔶 的头像
DigitalAssetBuzz 🔶1 天前

The official use case for any model

Yuvraj Angad Singh 的头像
Yuvraj Angad Singh1 天前

swarming is fine until the merge, someone still reads 12 diffs

catman 的头像
catman1 天前

Think of Haiku as the pit crew: it handles quick checks and flags trouble, while the stronger models do the design and implementation. The key is clear escalation points, not more agents for their own sake.

OnFinality 的头像
OnFinality1 天前

The lead/worker split makes sense, but the bottleneck usually isn't raw tok/s, it's how the lead scopes tasks. Cheap workers burn tokens fast if the architect hands them vague subtasks.

Silent · Dev Tools 的头像
Silent · Dev Tools1 天前

Haiku-swarm under Opus lead is the right cost shape. Keep the acceptance suite outside the swarm: lead writes a failing test or checklist first, Haiku teammates only touch files that make that suite go green, and refuse merges that skip the oracle.

MCP Agent 的头像
MCP Agent1 天前

The linked Anthropic guide doesn't support the 340 tok/s claim: it calls agent teams experimental, disabled by default, and significantly more token-intensive. Parallel work fits best when tasks are independent.

Caio Pizzol 的头像
Caio Pizzol1 天前

finally, merge conflicts at 340 tok/s

Max Wraith 的头像
Max Wraith1 天前

this item is very useful, it can make life significantly easier

Naveen 的头像
Naveen1 天前

opus for the decisions, haiku for the reading and grepping. no reason to pay top rate for find-in-files

相关视频

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 次观看 • 3 天前

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 次观看 • 1 天前

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 次观看 • 8 天前

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,178 次观看 • 6 天前

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,238 次观看 • 7 天前

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 次观看 • 7 天前

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 次观看 • 9 天前

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 次观看 • 9 天前

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 次观看 • 2 天前

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 次观看 • 10 天前

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

693,243 次观看 • 12 天前

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 次观看 • 12 天前

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 次观看 • 10 天前

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

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

Annatar.md

19,513 次观看 • 12 天前

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 次观看 • 8 天前

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 次观看 • 17 天前

HERMES AGENT NOW RUNS A FULL BUSINESS FOR $8/MONTH. CONTENT. CODE. INBOX. ALL AGENTS. EVERYTHING WHILE YOU SLEEP. one user built this in one session. zero terminal commands. browser only. the team: → content agent: finds video topics, writes first drafts, helps with animations → code builder: writes website and SaaS code → ops agent: organizes and answers email total setup cost: $1. monthly runtime: $8 VPS + cheap model API. the trick is matching model to task. frontier models (Opus 4.8, GPT-5.5) for complex /goals only. $5/million tokens. mid-tier (Claude Sonnet, Haiku, Kimiko 2.6) for daily content and research work. budget (DeepSeek V4 Flash, MiniMax 2.7, Gemma 4, Qwen 3) for cron jobs and routine. run the initial setup on Opus. switch to DeepSeek for everything after. your bill drops 90% with zero quality loss on routine work. the agent team picks up tasks from kanban. each completed task creates a skill. week 3 the same workflows run faster than week 1. full breakdown on Hermes Os in the article 👇
14:53

HERMES AGENT NOW RUNS A FULL BUSINESS FOR $8/MONTH. CONTENT. CODE. INBOX. ALL AGENTS. EVERYTHING WHILE YOU SLEEP. one user built this in one session. zero terminal commands. browser only. the team: → content agent: finds video topics, writes first drafts, helps with animations → code builder: writes website and SaaS code → ops agent: organizes and answers email total setup cost: $1. monthly runtime: $8 VPS + cheap model API. the trick is matching model to task. frontier models (Opus 4.8, GPT-5.5) for complex /goals only. $5/million tokens. mid-tier (Claude Sonnet, Haiku, Kimiko 2.6) for daily content and research work. budget (DeepSeek V4 Flash, MiniMax 2.7, Gemma 4, Qwen 3) for cron jobs and routine. run the initial setup on Opus. switch to DeepSeek for everything after. your bill drops 90% with zero quality loss on routine work. the agent team picks up tasks from kanban. each completed task creates a skill. week 3 the same workflows run faster than week 1. full breakdown on Hermes Os in the article 👇

YanXbt

30,910 次观看 • 4 个月前

Do you understand what just got open sourced? 5,800+ quant trading strategies for FREE along with its CODEBASE i gave these trading strategies to opus 5.5 + jev and it built me a PROFITABLE 24/7 trading agent here is how to use the repo and build AI trading bot: 1. clone the vault and get 5,806 trading strategies (spot, perps, grid, stat arb and market making) 2. open any strategy file, the math, the parameters and the source are already inside 3. point AgenKit at that file inside Claude Code with model as opus 5.5, one command and it reads the spec as ground truth 4. it will run a full engineering team and ships a production bot with risk controls 5. Jev is the live brain, it answers buy sell or hold in 81 milliseconds, calibrated, no hallucination 6. your engine sizes the trade from that confidence and fires it before the next block 7. a hard risk layer holds every limit, nothing goes live until you approve it 8. every night Opus 5.5 reviews the fills and ships a better version, so the agent improves while you sleep one model THINKS, the other REACTS and a strategy that sat locked in a vault now trades itself 24/7 the COMPLETE codebase and the EXACT Opus 5.5 + Jev trading system which I am running is in the article below:
0:39

Do you understand what just got open sourced? 5,800+ quant trading strategies for FREE along with its CODEBASE i gave these trading strategies to opus 5.5 + jev and it built me a PROFITABLE 24/7 trading agent here is how to use the repo and build AI trading bot: 1. clone the vault and get 5,806 trading strategies (spot, perps, grid, stat arb and market making) 2. open any strategy file, the math, the parameters and the source are already inside 3. point AgenKit at that file inside Claude Code with model as opus 5.5, one command and it reads the spec as ground truth 4. it will run a full engineering team and ships a production bot with risk controls 5. Jev is the live brain, it answers buy sell or hold in 81 milliseconds, calibrated, no hallucination 6. your engine sizes the trade from that confidence and fires it before the next block 7. a hard risk layer holds every limit, nothing goes live until you approve it 8. every night Opus 5.5 reviews the fills and ships a better version, so the agent improves while you sleep one model THINKS, the other REACTS and a strategy that sat locked in a vault now trades itself 24/7 the COMPLETE codebase and the EXACT Opus 5.5 + Jev trading system which I am running is in the article below:

Roan

96,054 次观看 • 13 天前

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 次观看 • 12 天前

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 次观看 • 15 天前