Wink Pings

Sonnet Writes Code, Haiku Searches the Repo, Opus Signs Off at Only Three Points

Running three models simultaneously in Claude Code, each doing the work it is best at. The token savings are real, but setting Opus's intervention point at the second error may already be too late.

Running three models at the same time in Claude Code is a setup that has been circulating widely on X recently. The launch command in the original post is just one line:

claude --model sonnet --advisor opus

The division of labor is as follows:

  • Sonnet 5.5 runs the main session, writes code, and fixes bugs
  • Haiku 5.5 works in parallel in the repo, searching, grepping, and reviewing diffs
  • Opus 5.5 stands by as an advisor; it normally does not occupy the context window and only steps in for key decisions

Opus is woken up at only three points: before a plan is finalized, when the same error appears a second time, and before declaring the work complete. Sonnet writes, Haiku checks, Opus reviews.

This setup has corresponding implementation foundations in the Claude Code documentation. Subagents run in their own context windows; you can specify a model for each one, restrict tools, and use isolation: worktree to get an isolated copy of the repository. What is called a three-model division of labor, in practice, is a main session plus three Haiku subagents.

Docs: https://code.claude.com/docs/en/sub-agents

The original post provides a prompt you can paste directly into Claude Code to configure the whole structure in one go:

Reconfigure my Claude Code according to this structure:
1. Use Sonnet 5.5 for the main session and Opus 5.5 as the advisor.
2. In .claude/agents, create three Haiku 5.5 subagents: search (map out the repository), grep (locate call sites), audit (check diffs).
3. Set isolation: worktree for audit so it does not touch my working branch while checking.
4. Add a rule to CLAUDE.md: all repository searches and tests go to Haiku 5.5 subagents, keeping the main context lean.
5. Hand fast, deterministic forks (choosing tools, choosing paths, retries) to JEV.
Show me a diff before each change; do not modify any files until I say go.

One detail is worth calling out separately: letting audit run in a temporary worktree. This turns 'read-only' from a verbal promise into an environmental constraint, so the inspection cannot touch the working branch. But Haiku reviewing diffs can still miss context, so the final sign-off is still left to Opus.

The logic behind how this structure saves tokens is not hard to understand: reserve the most expensive context window for the fewest judgments. But several costs are easy to overlook.

Parallel grepping can easily rescan the same batch of files. Three subagents each going through the repo from scratch means part of the money you save gets spent again on duplicated work. Only when you define the search scope before dispatching is it truly saving. Someone in the comments of the original post mentioned this.

Do not use this setup for small changes. Spinning up three subagents, coordinating them, and collecting results itself costs context. For a job that changes two lines of code, it is faster to just let Sonnet finish it.

Setting the alarm point at 'the same error appears a second time' is a bit late. What really burns money is continuing to write after the direction is wrong; by the time the error surfaces, a pile of code has already accumulated. Some people suggest moving Opus's intervention point earlier, at least having it take a look at the moment the plan is finalized. There is no standard answer here; it depends on whether you are more afraid of writing in the wrong direction or more afraid of spending a few extra Opus calls.

Some also ask why not just let the smartest Opus oversee everything from start to finish. The answer is not complicated: Opus's context window is the most expensive resource in this structure; having it watch from beginning to end is essentially spending the saved money right back. The premise of division of labor is admitting that every model has work it is not good at.

The JEV layer applies the same idea at a finer granularity. Which file to choose, which tool to use, whether to retry or stop—these forks that do not require judgment are handed to it for a few milliseconds, and only what truly needs judgment goes to the large model. The original post does not elaborate on JEV's implementation details; whether it is stable and whether it can stop when it should are things you have to run yourself to know.

Suitable scenarios: large repositories, lots of searching, and tasks that can be split into a 'write' phase and a 'check' phase. Unsuitable scenarios: changing one function at a time, or tasks that require frequent back-and-forth confirmation. The tool itself is not the problem; the problem is that many people apply a division of labor designed for large codebases to a single small commit, then wonder why it is slower.

发布时间: 2026-11-17 15:41