Sonnet Builds, Opus Reviews, Haiku Reads: Does the Claude Code Advisor Save Money?

A post by Skunzu (@skunzu, October 12, 2026) made the rounds with a tidy idea: let Sonnet write the code, let Haiku read the files, and keep Opus on call for the big decisions. Better output, "way fewer tokens".

We checked it against Anthropic's documentation and price list. The short version: the feature is real, the saving is not automatic, and the setup only pays off when the agent does not waste turns. That last part has less to do with models than with what you hand the agent before it starts.

The original post by @skunzu on X (October 12, 2026)

How the three-model setup works

Claude Code has an experimental advisor (Anthropic docs). You run the session on one model and name a second, usually stronger one. At key moments Claude calls that second model, which reads the whole conversation, every tool call and result included, and sends back a short piece of advice. It works on Claude subscriptions and on API billing. The Haiku part is a separate feature: subagents, small helpers that read files in their own context and hand back only a summary.

Anthropic laid out the reasoning in April (the advisor strategy): the cheap model does most of the work at its own rate, and the expensive one only writes a short plan when asked, typically 400 to 700 tokens of text.

What the post gets wrong

The idea holds up. Five details do not:

The prices behind it

Everything rests on the price gap (Anthropic pricing, checked October 13, 2026; the same numbers are on our model price pages):

Opus 5.5 costs exactly twice as much as Sonnet 5.5. Haiku 5.5 costs a twentieth of Sonnet on prompts up to 100K tokens, so file reading moved to Haiku is close to free.

The catch nobody mentions

Your main session re-reads its history from the prompt cache at a twentieth of the normal price. The advisor does not. Per Anthropic's docs, "each advisor call processes the full transcript anew, with no reuse between calls", at the full Opus price. So one call costs roughly what the conversation weighs:

In the example below, one late call costs as much as two dozen ordinary turns of the same session. That changes the math.

One task, five ways

We priced the same made-up task five ways from the official prices: 60 turns, the first 15 spent reading 90,000 tokens of files, three advisor calls. This is arithmetic, not a test, but it shows where the money goes.

• The advisor alone saved nothing. With the files read in the main conversation, three full-price Opus reads cost more than the whole Sonnet discount: $4.90 against $4.73 for plain Opus.
• The saving comes from a small conversation. When helpers read the files and hand back summaries, every later turn and every advisor call gets cheaper. Haiku makes those helpers almost free: under three cents for all three.
• Plain Sonnet is still the cheapest. The advisor buys quality. In the best case here it costs 40% less than Opus throughout and about 20% more than Sonnet alone.

Anthropic reports that the advice can pay for itself by saving turns: in its April tests on earlier models, Sonnet with an Opus advisor scored 2.7 points higher on SWE-bench Multilingual and cost 11.9% less per task than Sonnet alone (as reported). Fewer wasted turns is the real lever. Which brings us to the cheapest advisor there is.

The cheapest advice is written down before you start

Look at what the advisor is paid for: checking the plan, breaking an error loop, checking that the work is really done. All three can be prepared in plain files before the first prompt, and reading a file costs a fraction of a cent per turn from the cache. That is what an AgentGid starter kit is.

A kit is a tested recipe for one kind of project. Each job in it gets a part from AgentGid's catalogs, with an exact version and license, and the kit writes the files your agent builds from: AGENTS.md with the plan and a check after every step, a first prompt that tells the agent to stop after step 1 and report, the MCP setup for Claude Code, Cursor, Codex or Copilot, and a license record. Every recipe was built from start to finish by a fresh coding agent, twice, before it was listed.

The part that saves the most turns is Known traps: the mistakes a test build actually ran into, written down so the next agent does not repeat them. Models write code from memory, and memory is often a version behind:

• MCP server kit: version 2 of the MCP TypeScript SDK renamed the imports and replaced server.tool(), and models still write version 1. Without the warning, that is exactly the kind of error that comes back twice.
• SaaS starter kit: Next.js 16 renamed middleware.ts to proxy.ts and dropped synchronous cookies().
• Telegram news bot kit: aiogram 3 is not aiogram 2, and Telegram rejects the HTML that RSS feeds hand over.
• 2D platformer kit: Phaser 4 is not Phaser 3, and one example from Phaser's own skills turns the bottom of every pit into a floor.

We have not measured how many turns a kit saves, so there is no percentage here: each trap above is simply something a test build really ran into.

Kits also cover the "docs" helper from the post. They plug in Context7, which hands the agent version-specific library docs instead of whole web pages, and our own MCP server, so the agent can look up another library that fits your limits instead of searching the web.

Nothing here is generated: picking parts and writing the brief are lookups, so the same request always gives the same kit. The MCP server kit's AGENTS.md is about 20 KB, roughly 5,000 tokens: read once, then served from the cache.

No recipe for your project? Create your own kit: describe the project and the kit builder splits it into jobs and fills each one from our catalogs in about 20 seconds. It is free with an account, up to 5 a day, and lands in your profile. Nobody has test-built it yet, so check it yourself; members' kits show what others made. Your agent can also fetch a kit itself through the AgentGid MCP server.

On a Pro or Max plan

You do not see dollars there, but the work comes out of the same allowance. Advisor calls and helper agents count toward your plan's limits, and Anthropic lists model choice and effort level among the things that affect how fast you use them (usage limit best practices). See Claude Code limits, the limits calculator and our tracker of early limit resets.

The verdict

• Worth trying on long tasks where most turns are routine and the plan decides the outcome: big refactors, a bug that keeps coming back.
• Not worth it on short tasks; Anthropic's docs suggest simply switching the model instead.
• Keep the conversation small. Every advisor call re-reads all of it at the Opus price, so helpers that summarise, /clear between tasks and the habits in how to cut token usage in Claude Code matter more with an advisor, not less.
• Start from a kit. A plan, the known traps and the checks in writing do much of the advisor's job before it is ever called.

Idea: Skunzu (@skunzu) on X. Facts about the advisor, models and limits: Anthropic's documentation, linked above; prices checked October 13, 2026. Cost figures are our own arithmetic on those prices, not a test. Kit details are from the kit pages on AgentGid.