Loading video...

Video Failed to Load

Go Home

Claude Code found $710/mo hiding inside an agent loop that already looked “optimized” /cost-audit 1. feed it the usage log for every task 2. make it flag late Opus escalations, cold-cache rewrites and effort changes 3. let it rewrite the router, handoff and session rules around those failures this...

13,961 views • 6 days ago •via X (Twitter)

42 Comments

Bober_smart's profile picture
Bober_smart6 days ago

I won't make such mistakes anymore

starmex's profile picture
starmex6 days ago

the craziest part isn't saving $710/mo it's finding that $710 inside a loop everyone already thought was optimized

Gipp 🦅's profile picture
Gipp 🦅6 days ago

first, detection, awareness, and cost savings congrats

Yarchi's profile picture
Yarchi6 days ago

late escalation being the top leak tracks with what i see

Gipp 🦅's profile picture
Gipp 🦅6 days ago

that’s right it is happening exactly as you see it

Argona's profile picture
Argona6 days ago

nice work, that cost-audit setup is clean

Gipp 🦅's profile picture
Gipp 🦅6 days ago

the cost audit setup is one of the cleanest I’ve ever seen

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

best command

Sacha Kleynjans's profile picture
Sacha Kleynjans6 days ago

The retries are always where the money hides imo, not the model price

shmidt's profile picture
shmidt6 days ago

nice found

morph's profile picture
morph6 days ago

It actually makes so much senses

Gipp 🦅's profile picture
Gipp 🦅6 days ago

everything is easy on the inside, but from the outside, it all looks difficult

Khairallah AL-Awady's profile picture
Khairallah AL-Awady6 days ago

thank you for this useful content Gipp

Gipp 🦅's profile picture
Gipp 🦅6 days ago

glad to hear it, brother

unicode's profile picture
unicode6 days ago

finding $710 is quite a challenge. claude managed to do it.

Gipp 🦅's profile picture
Gipp 🦅6 days ago

yes claude is a real genius

Avid's profile picture
Avid6 days ago

nice work

Gipp 🦅's profile picture
Gipp 🦅6 days ago

thank my homie

Archive's profile picture
Archive6 days ago

gipp, thanks for sharing this honestly never even thought about it

wast3's profile picture
wast36 days ago

I would like to use this too

Atenov int.'s profile picture
Atenov int.6 days ago

Do the new router rules add noticeable latency for real-time calls?

cristal💎's profile picture
cristal💎6 days ago

dynamic effort adjustments prevent paying top rates on easy tasks

iOne's profile picture
iOne6 days ago

good idea how to save credits on unimportant tasks

Gipp 🦅's profile picture
Gipp 🦅6 days ago

yep yep

Roan's profile picture
Roan6 days ago

this looks super interesting gipp

Gipp 🦅's profile picture
Gipp 🦅6 days ago

I think there is room for further work here

Kshitij Koranne's profile picture
Kshitij Koranne6 days ago

Cold-cache rewrites are the sneaky one. Which of the three saved you the most? @claudeai

Edwin | AI Systems's profile picture
Edwin | AI Systems6 days ago

Late escalation is the sneaky one. By the time Sonnet hands off to Opus the context is already huge, so you pay Opus rates on the whole mess plus a cold cache. Picking the model by task type up front is usually cheaper than escalating mid-loop.

kiosa's profile picture
kiosa6 days ago

cool

Slonski's profile picture
Slonski6 days ago

did you look at how the bill changes if you escalate earlier?

Brjan | AI Builder's profile picture
Brjan | AI Builder6 days ago

finding hidden costs like that can really boost efficiency and ROI

icosaedro's profile picture
icosaedro6 days ago

Claude catching its own Opus habit is the funniest part. Those leaks hide until you actually log everything.

marfin's profile picture
marfin6 days ago

I didn't know that command even existed thanks, bro, for finding it

slash1s's profile picture
slash1s6 days ago

interesting find

kuch.'s profile picture
kuch.6 days ago

maybe i'll find some unused money that i spend monthly

Ridark's profile picture
Ridark6 days ago

This one is going in my greatest hits folder

Fokki's profile picture
Fokki6 days ago

the fixes matter

Lummox's profile picture
Lummox6 days ago

Pay attention to it

Karan Jagtiani's profile picture
Karan Jagtiani5 days ago

Late escalation costs twice: you pay for the weaker model's failed attempts, then the stronger model rebuilds the whole cache. Routing on task shape before the first call, and handing over a compact summary instead of raw context when you do switch, cuts both.

NO1ennn's profile picture
NO1ennn6 days ago

bookmark this alpha

MAX's profile picture
MAX6 days ago

Auditing the agent itself is a powerful idea.

Muse's profile picture
Muse6 days ago

late escalations and cold cache rewrites are where most agent bills leak. routing on task type upfront beats escalating to the big model at step 9

Related Videos

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

delost

288,285 views • 1 day ago

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

mirku

421,711 views • 13 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."

Alvaro Cintas

55,249 views • 5 days ago

this is pure f*cking treasure Claude Code tip: once Opus 5.5 is your main model, stop leaving Fable 5.1 sitting idle and stop burning Opus tokens on tasks Sonnet 5.5 can swarm put it on call with /goal claude --auto-mode "/goal all tests pass and lint is clean" Opus 5.5 keeps writing the code in auto mode Sonnet 5.5 swarms the routine work at medium Fable 5.1 inspects the full transcript and only speaks up at the turn boundary: → not yet met: am I drifting from acceptance criteria? → met: do the tests, diffs, and lint hold? → impossible: am I chasing an unreachable state? Fable grades. Opus ships JEV engineering is the same move one layer down: the forks that need no thinker (which file, which tool, retry or halt) go to JEV in under 16ms, and the big models only see the ones that split — the full tree > Opus 5.5 on high runs the main session > worker edits and patches code on Sonnet 5.5 > explorer indexes AST maps and call sites on Sonnet 5.5 > verifier runs tests and linters on Sonnet 5.5 > all three subagents on medium effort > Fable 5.1 on call as the Stop hook evaluator > JEV routes micro-forks under 16ms paste the tree and this prompt into Claude Code ↓ "Reconfigure my Claude Code setup around this tree: 1. Set the main session to Opus 5.5 on high effort with auto mode enabled. 2. Put Fable 5.1 on call as a session-scoped evaluator attached to the Stop hook: - Read-only transcript evaluation with zero tool calls - Three structured outcomes: not yet met (with steering notes), met (auto-clear), and impossible (abort early) 3. Spawn Sonnet 5.5 subagents on medium effort for worker, explorer, and verifier roles. Defer goal checks while background tasks run. 4. Route fast deterministic forks (tool resolution, path selection, auto-retries) through JEV. 5. Add one rule to CLAUDE.md: run long tasks with: claude --auto-mode \"/goal \" Show me every configuration change as a diff first. No edits until I say go." ↳

mirku

41,562 views • 6 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." ↳

delost

48,494 views • 9 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." ↳

Mr. Buzzoni

324,943 views • 14 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." ↳

Hanako

52,065 views • 12 days ago

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

44,001 views • 10 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."

Ryven

46,513 views • 5 days ago