Wink Pings

Don't keep Opus running the whole time: a more cost-effective division of labor in Claude Code

Use Sonnet as the main workhorse, Opus as an advisor, and Haiku for read-only subagents. Claude Code's advisor tool reserves the expensive model's judgment for key moments. Includes commands, costs, and a few common pitfalls.

In Claude Code, you can separate the main model and the advisor model. The tweet author xsmryze gives a concrete division of labor: Sonnet 5.5 runs the main session and writes code, Haiku 5.5 searches, greps, and reads docs in parallel, and Opus 5.5 serves as an advisor only at key moments. The startup command is:

claude --model sonnet --advisor opus

This usage comes from Claude Code's advisor tool. The official docs clearly state: advisor is an experimental feature and only supports the Anthropic API; Bedrock, Claude Platform on AWS, Google Cloud Agent Platform, and Microsoft Foundry cannot use it. Behavior, pricing, and availability may change. State the limitations upfront so you don't treat it as a universal switch.

What it solves isn't a lack of model capability

In long tasks, most turns are routine changes, and plan quality determines the outcome. Keeping Opus on throughout is expensive, and many turns don't need that level of judgment. Using Sonnet throughout can also lack an independent layer of judgment when locking down a plan, repeatedly hitting errors, or doing final checks. advisor lets the main model consult a stronger model at key moments. The advisor receives the full conversation, including every tool call and result, and returns guidance.

Claude decides when to call it. The docs say this usually falls into three moments: before locking down a plan, when the same error keeps recurring, and before declaring the task complete. The tweet author also wrote these three into CLAUDE.md as fixed rules.

In the session you can see an Advising line, with results categorized as Reviewed, Declined, or Unavailable. When there is readable advice, press Ctrl+O to view it. Claude usually follows the advice, but when it finds conflicting evidence, it will surface the conflict rather than following it unconditionally. This detail matters: the advisor is a second opinion, not a scapegoat for the main model.

How to enable it, and where the cost is

Three ways: run /advisor opus in the session; set advisorModel to opus in settings; or add claude --advisor opus at startup. To turn it off, use /advisor off; to disable it completely, set CLAUDE_CODE_DISABLE_ADVISOR_TOOL=1.

The main model must support advisor, and the advisor tier cannot be lower than the main model. In the docs, acceptable advisors for Sonnet 5.5 include Fable, Opus 5 or higher, and Sonnet 5.5. Haiku 4.5 can call an advisor but cannot serve as one. Model aliases and versions should be based on the local /advisor output.

Don't ignore cost. Every advisor call reads the full conversation and is billed at the advisor model's rate; subscription plans count it toward usage limits. It is not called every turn, so it is usually cheaper than running a strong model throughout, but costs can rise if it is called often. Switching /advisor does not invalidate the main model's prompt cache; the advisor's own reads are not cached and are full reads each time.

The three-layer structure in the tweet

The tweet author draws the structure as a tree: Sonnet 5.5 in the main session changes code; Haiku 5.5 runs three read-only subagents—search explores the repo, grep finds call sites, and docs pulls API references; Opus 5.5 acts as advisor and reads the full transcript when consulted; JEV handles micro-decisions such as choosing files, choosing tools, retrying or stopping, returning in milliseconds.

JEV is not in the official advisor docs; it is another engineering idea from the tweet author. Don't conflate the two as one feature.

The tweet includes a pasteable prompt that makes Claude Code show a diff before editing. The four core steps: use Sonnet 5.5 in the main session with Opus 5.5 as advisor; create three read-only Haiku 5.5 subagents; add rules in CLAUDE.md to consult the advisor before locking a plan, after the same error occurs twice, and before completing the task; route fast deterministic branches through JEV. It emphasizes showing the diff first and waiting for you to say go before editing. This habit is more worth copying than the architecture itself.

Who it's for

It suits long refactors, debugging with repeated errors, and tasks that need an independent check before wrapping up. For short tasks, or tasks that need the strongest model on every turn, switching the main model directly is simpler. Try it first in a small repo, record the number of advisor calls and the cost in /usage, then decide whether to codify it in CLAUDE.md. Don't add three layers just for the sake of three layers.

References:

发布时间: 2026-10-31 15:45