What Is Claude Code's Advisor Strategy? How to Use Opus as an Adviser With Sonnet or Haiku

The Problem With Using One Model for Everything

Most developers who start working with Claude Code default to a single model — usually Sonnet or occasionally Opus — and run every task through it. It works fine, but it’s not optimal. You’re either overpaying for simple tasks or under-resourcing complex ones.

The Claude Code Advisor Strategy is Anthropic’s documented approach to fixing that. It pairs Opus as a senior adviser — handling planning, architecture decisions, and code review — with Sonnet or Haiku as the executor that does the actual implementation work. The result is better output quality and, according to Anthropic’s own testing, meaningful cost savings.

This article explains how the advisor strategy works, when to use it, and how to configure it in your Claude Code setup.

Understanding Claude’s Model Tiers

Before getting into the strategy, it helps to understand what each model is actually good at.

Claude Opus

Opus is Anthropic’s most capable model. It excels at:

Complex reasoning and multi-step problem solving
Architectural decisions and system design
Analyzing ambiguous requirements
Catching subtle bugs and edge cases
Writing documentation and explaining decisions

It’s also the most expensive and slowest of the three. Using it for every single file edit or boilerplate generation is overkill.

Claude Sonnet

Sonnet is the middle tier — significantly faster and cheaper than Opus, with strong coding capabilities. It handles:

Implementing well-defined tasks
Writing standard code patterns
Making straightforward refactors
Running tests and interpreting results

For most day-to-day coding tasks, Sonnet performs close to Opus at a fraction of the cost.

Claude Haiku

Haiku is the fastest and cheapest model. It’s best suited for:

Simple, clearly scoped tasks
High-volume repetitive work (formatting, renaming, basic edits)
Quick lookups and summaries
Tasks where speed matters more than nuance

Using Haiku for complex architecture reviews would be a mistake. But using Opus to rename a dozen variables is wasteful.

What the Advisor Strategy Actually Is

The Claude Code Advisor Strategy is a multi-model workflow pattern where you designate Opus as a non-executing adviser and Sonnet or Haiku as the hands-on implementer.

Here’s the core idea:

Opus analyzes the problem — it reads your codebase, understands the requirements, identifies risks, and produces a structured plan
Sonnet or Haiku executes the plan — it follows Opus’s instructions step by step, writing and editing actual code
Opus reviews the output — it checks the work, catches issues, and decides whether additional iteration is needed

Opus never touches files directly in the primary workflow. It reasons about what should be done; the cheaper model does it.

This isn’t just a cost hack. The strategy tends to produce better results because it separates the cognitive tasks that Opus is genuinely superior at (reasoning, planning, reviewing) from the mechanical tasks where Sonnet or Haiku performs comparably (typing out code, following established patterns).

According to Anthropic’s documentation on multi-agent patterns, this kind of orchestrator-subagent architecture reduces unnecessary token usage while preserving quality on the decisions that actually matter.

How to Configure the Advisor Strategy in Claude Code

There are two main ways to implement this pattern in Claude Code: manual model switching and the multi-agent sub-agent approach.

Method 1: Manual Model Switching With /model

The simplest implementation uses Claude Code’s /model command to switch between models at different phases of a task.

Step 1: Start with Opus for planning

Open Claude Code and set your model to Opus:

/model claude-opus-4-5

Then describe your task and ask Opus to analyze and plan — not implement. For example:

Analyze this authentication module and create a step-by-step implementation plan for adding OAuth2 support. Include which files to modify, what the edge cases are, and what tests to write. Do not write any code yet.

Step 2: Capture the plan

Opus will return a structured plan. Copy this or keep it visible in your session.

Step 3: Switch to Sonnet for execution

/model claude-sonnet-4-5

Now give Sonnet the plan Opus produced:

Implement the following plan exactly as specified: [paste Opus plan here]. Follow it step by step and confirm each file change.

Step 4: Return to Opus for review

Once Sonnet completes the implementation, switch back to Opus:

/model claude-opus-4-5

Ask it to review the diff:

Review this implementation for correctness, edge cases, and any deviations from the plan. Flag anything that needs revision.

Step 5: Iterate if needed

If Opus flags issues, switch back to Sonnet to address them. Repeat until Opus signs off.

Method 2: Sub-Agent Architecture

For more automated workflows, Claude Code supports spawning sub-agents that run independently. In this setup:

The primary Opus agent orchestrates the session
It spawns Sonnet sub-agents for specific implementation tasks
Each sub-agent works in a dedicated context and reports back

This requires more setup but scales better for large tasks. The Opus orchestrator maintains a high-level view of progress while Sonnet agents handle parallel workstreams — for example, one agent working on backend changes while another handles tests.

You can configure this in your CLAUDE.md file (Claude Code’s project-level configuration) by defining which model should handle different task types:

## Model Assignment Rules

- Architecture decisions and reviews: Use Opus
- Implementation tasks (new features, refactors): Use Sonnet  
- Simple edits, formatting, renaming: Use Haiku
- Security-sensitive changes: Always escalate to Opus for review

Method 3: Using the —model Flag in Non-Interactive Mode

If you’re running Claude Code in scripts or CI pipelines, pass the model flag directly:

# Planning phase
claude --model claude-opus-4-5 "Analyze this codebase and produce an implementation plan for..."

# Execution phase  
claude --model claude-sonnet-4-5 "Implement the following plan: ..."

This approach works well when you want to automate the hand-off between models without manual intervention.

When to Use the Advisor Strategy

Not every task benefits from this pattern. Here’s a practical guide.

Use It For

Large feature implementations — When adding a significant feature that touches multiple files and systems, Opus’s planning phase prevents Sonnet from going off-track or missing dependencies.

Debugging complex issues — Opus is significantly better at reasoning through intricate bug chains. Let it diagnose; let Sonnet apply the fix.

Architectural decisions — Before refactoring a module or introducing a new pattern, get Opus’s analysis. Sonnet can then implement with confidence.

Code reviews — After a Sonnet or Haiku session, run Opus over the output. It catches things the cheaper models miss.

Security-sensitive changes — Any code that touches authentication, authorization, data validation, or encryption warrants Opus review.

Skip It For

Small, well-defined tasks — If the task is clear and bounded (fix this typo, rename this function), just use Sonnet directly.

Exploratory scratchpad work — If you’re experimenting and nothing is final, Sonnet is fast enough and cheap enough to iterate with.

Repetitive high-volume tasks — Formatting, linting, generating test fixtures — Haiku handles this fine.

The Cost Breakdown

Here’s why the math works out.

Opus tokens cost significantly more than Sonnet or Haiku tokens. In a typical coding session without the advisor strategy, if you’re running Opus for everything, the cost is high but consistent.

With the advisor strategy:

Opus handles planning and review — usually 20–30% of total tokens in a session
Sonnet handles implementation — 60–70% of tokens
Haiku handles simple edits — 10–20% of tokens

The 11% overall cost reduction mentioned in Anthropic’s benchmarks comes from shifting the bulk of token consumption to cheaper models while preserving Opus for the tasks where it actually matters. In practice, savings can be higher depending on the task mix — complex projects with clear separation between planning and execution see the most benefit.

There’s also a quality dimension. Teams that use this pattern report fewer bugs and less rework because Opus’s planning phase catches problems early, before Sonnet has written 500 lines of code in the wrong direction. Prevention is cheaper than correction.

Common Mistakes to Avoid

Giving Sonnet Ambiguous Plans

If Opus produces a vague plan, Sonnet will fill in the gaps — and not always correctly. Push back on Opus during the planning phase: ask it to be specific about edge cases, error handling, and file paths. Sonnet executes better when the plan is tight.

Skipping the Review Phase

The Opus review at the end is where a lot of the quality improvement comes from. Skipping it to save a few tokens defeats the point. Budget for it.

Using Haiku When Sonnet Is the Right Fit

Haiku works well for truly mechanical tasks. But “looks simple” isn’t the same as “is simple.” If a task involves understanding context or making judgment calls, Sonnet is the safer bet.

Not Updating Your CLAUDE.md

If you’re working on a long project, update your project-level instructions as you go. Opus needs context to plan well. Stale or missing context leads to plans that don’t reflect the current state of the codebase.

Treating the Plan as Sacred

Opus’s plan is a starting point, not a contract. If Sonnet hits a real obstacle during implementation, stop and return to Opus. Let it revise the plan with the new information rather than having Sonnet improvise.

How MindStudio Supports Multi-Model Workflows Like This

The advisor strategy works well inside Claude Code, but it also reflects a broader design principle: different models should do different jobs.

MindStudio applies the same logic at the workflow level. When you build AI agents in MindStudio, you can assign different models to different steps in a workflow — Opus for reasoning and evaluation steps, Sonnet for generation tasks, Haiku for classification or routing. You don’t need API keys or separate accounts for each model; MindStudio gives you access to 200+ models, including the full Claude lineup, out of the box.

This is particularly useful if you want to operationalize the advisor pattern in production — for example, building an automated code review pipeline that uses Opus to evaluate pull requests but Sonnet to generate the suggested fixes. MindStudio’s visual builder makes it straightforward to sequence those steps, pass context between them, and set up conditional logic (like escalating to Opus if Sonnet flags uncertainty).

If you’re already thinking about multi-model strategies for Claude Code, it’s worth knowing that MindStudio makes the same kind of orchestration available without writing infrastructure code. You can start free at mindstudio.ai.

For teams building more complex agentic pipelines, the MindStudio Agent Skills Plugin lets external AI agents — including those built on Claude Code — call MindStudio capabilities directly, so you can mix and match tooling as your workflow grows.

FAQ

What is the Claude Code Advisor Strategy?

It’s a workflow pattern where Claude Opus acts as a planning and review layer — analyzing tasks, creating implementation plans, and reviewing completed work — while Sonnet or Haiku handles the actual coding. The goal is to use each model where it adds the most value rather than running a single model for everything.

Why use Opus as an adviser instead of the executor?

Opus’s comparative advantage is reasoning: understanding complex requirements, identifying edge cases, evaluating trade-offs. It’s not necessarily faster at writing boilerplate than Sonnet. Keeping Opus in the advisory role means you get its best capability (deep reasoning) without paying for it on tasks that don’t need it (mechanical implementation).

How much does the advisor strategy reduce costs?

Anthropic’s benchmarks show approximately 11% cost reduction compared to using Opus for an entire session. Real-world savings depend on task complexity and the ratio of planning to implementation work. Projects with long implementation phases and shorter review cycles save more; projects that are mostly architectural discussion may see smaller differences.

Can I use the advisor strategy with models other than Claude?

The pattern itself is model-agnostic. You could use GPT-4o as the adviser with a lighter OpenAI model as the executor, or mix providers. Within the Claude ecosystem specifically, the strategy is well-documented by Anthropic and the model handoffs work naturally with Claude Code’s /model command. Using it cross-provider requires more manual orchestration.

Is the advisor strategy the same as multi-agent Claude Code?

Related but not identical. Multi-agent Claude Code involves spawning independent sub-agents that work in parallel, each with their own context window and tool access. The advisor strategy is specifically about the Opus-as-planner, Sonnet-as-executor separation. You can implement the advisor strategy with or without sub-agents.

What’s the best way to handle context handoffs between Opus and Sonnet?

Be explicit. Don’t assume Sonnet has access to everything Opus reasoned through — paste the relevant plan or summary into the Sonnet prompt directly. Claude Code sessions maintain context within a session, but when you switch models you should verify the new model has what it needs rather than relying on implicit context carryover.

Key Takeaways

The Claude Code Advisor Strategy uses Opus for planning and review, Sonnet or Haiku for implementation — matching model capability to task type.
It reduces costs (roughly 11% in Anthropic benchmarks) by shifting token consumption to cheaper models for mechanical tasks.
Quality often improves because Opus’s planning phase catches issues before implementation begins, and its review phase catches issues after.
You can implement it manually using /model switching or automate it with Claude Code’s sub-agent architecture and CLAUDE.md configuration.
The biggest mistakes are giving Sonnet a vague plan, skipping the Opus review, and using Haiku for tasks that require contextual judgment.

The advisor strategy is one of the more practical optimizations available in Claude Code — not a workaround, but a deliberate design pattern from Anthropic. If you’re running Opus for everything out of habit, it’s worth trying. If you want to apply the same multi-model logic to production workflows, MindStudio makes it possible without writing infrastructure code.