Routing Claude Opus for Architecture, Sonnet for Implementation

Q: How do I set up model routing in Claude IDE, CLI, or Cursor?

In Claude IDE, select the model from the dropdown when starting a conversation. For architecture, choose Opus; for implementation, choose Sonnet in a new conversation. In CLI tools (like codex-cli), pass a model flag: --model opus-4 or --model sonnet-4. In Cursor or Windsurf, select the model in the agent panel. None of these tools automatically route by task type; you choose the model explicitly per session.

Q: How can I approve an Opus architecture decision before Sonnet starts implementation?

Set up an approval gate: have Opus write its architecture to a file (e.g., ARCHITECTURE.md or APISPEC.md), review the file, and commit it before starting the Sonnet session. If you're using MobileVibe, you can approve the Opus conversation from your phone—MobileVibe sends a notification when Opus needs input, and you can review and approve the proposal remotely. Don't start Sonnet until the architecture is stable.

Quick answer

Use opus for architecture decisions—system design, API contracts, data models—then route implementation tasks to Sonnet for speed and cost efficiency. This model routing pattern keeps strategic thinking on the most capable model while letting a faster, cheaper agent handle focused coding work.

Key takeaways

Opus excels at architectural decisions: system design, trade-off analysis, API contracts, and schema planning where reasoning depth matters more than speed.
Sonnet handles implementation efficiently: focused feature work, refactoring, test writing, and bug fixes where the architecture is already clear.
Routing by task type balances quality and cost—Opus for the 10% of decisions that shape the codebase, Sonnet for the 90% that execute the plan.
Approval gates between models let you review Opus’s architecture before Sonnet starts writing code.
MobileVibe lets you monitor and approve multi-model workflows from your phone, so you can unblock an Opus decision or check a Sonnet implementation lane without returning to your desk.

Why Split Architecture and Implementation Across Models

Developers who direct AI coding agents face a recurring tension: the most capable model (Opus) is slower and more expensive; the fastest model (Sonnet) is cheaper but less suited to deep reasoning. Running everything on Opus wastes budget on routine tasks. Running everything on Sonnet risks shallow architectural choices that create technical debt.

The opus for architecture pattern solves this by routing tasks based on their cognitive load. Architectural decisions—choosing a database schema, designing an API surface, evaluating framework trade-offs—benefit from Opus’s deeper reasoning and longer context handling. Implementation tasks—writing a CRUD endpoint, refactoring a helper function, adding unit tests—run faster and cheaper on Sonnet once the architecture is clear.

This isn’t about using two models for redundancy; it’s about using the right model for each phase of work. Opus sets the foundation; Sonnet builds on it. The result is a workflow that balances quality, speed, and cost across the full development cycle.

Opus as Your Architectural Decision Agent

Opus is the model you reach for when the next step isn’t obvious—when you need to evaluate trade-offs, design a system boundary, or plan a refactor that touches multiple modules. It handles:

System design and data modeling: “Design a multi-tenant schema for this SaaS app” or “Should we use event sourcing or a relational audit log?”
API contract design: defining REST or GraphQL endpoints, request/response shapes, error handling patterns.
Framework and library evaluation: comparing ORMs, state management libraries, or authentication strategies with project-specific constraints.
Refactoring plans: analyzing a legacy module and proposing a migration path that minimizes risk.
Architecture decision records (ADRs): writing structured documentation of why a choice was made, for future reference.

Opus’s strength is its ability to hold complex context—multiple files, competing requirements, implicit constraints—and reason through second-order effects. It’s slower than Sonnet, but the output is more likely to anticipate edge cases and avoid design mistakes that would require rework later.

In practice, you start a conversation with Opus in a project folder, ask it to design the architecture, review its proposal, and approve the plan. That approval becomes the handoff point: the architecture is locked in, and implementation can proceed on a faster model.

Sonnet for Fast, Focused Implementation Tasks

Once the architecture is clear, Sonnet is the workhorse. It handles:

Feature implementation: writing the code for a well-defined endpoint, component, or service.
Refactoring and cleanup: applying a known pattern across multiple files, renaming variables, extracting functions.
Test writing: generating unit tests, integration tests, or fixtures based on existing code.
Bug fixes: addressing a specific error or edge case where the root cause is understood.
Documentation: writing inline comments, README sections, or API docs based on existing code.

Sonnet is faster and cheaper per token, making it ideal for high-volume, low-ambiguity work. It’s less likely to second-guess the architecture or propose alternative designs—it takes the plan and executes it. This focus is a feature, not a bug: you don’t want the implementation agent re-litigating decisions Opus already made.

The trade-off is that Sonnet may miss subtle architectural implications if the task isn’t scoped tightly. If you ask it to “add user authentication,” it might choose a library or pattern that conflicts with your broader system design. The solution is to scope Sonnet tasks narrowly and ensure Opus has already defined the boundaries.

Setting Up Model Routing in Your Agent Workflow

Model routing depends on which surface you use to run agents. Here’s how to implement the opus for architecture pattern in common tools:

Claude IDE (Desktop App)

The Claude IDE lets you select a model per conversation. Start a new conversation in your project folder, choose Opus from the model dropdown, and ask it to design the architecture. Once you approve the plan, start a new conversation in the same folder, switch to Sonnet, and reference the Opus conversation or paste its output as context. The two conversations remain separate, but they share the same filesystem, so Sonnet can read files Opus created.

Claude CLI (codex-cli or official)

If you use a CLI wrapper like MobileVibe’s codex-cli, you can specify the model with a flag: codex --model opus-4 "Design the API schema" for architecture, then codex --model sonnet-4 "Implement the /users endpoint" for implementation. Each command starts a new session, so you’ll need to provide context explicitly (e.g., paste the Opus output or reference a file it wrote).

Cursor or Windsurf

Cursor and Windsurf support model selection in their agent panels. Start an Opus session for architecture, export or summarize its output, then start a Sonnet session for implementation. These tools don’t natively share conversation history across model switches, so you’ll need to copy key decisions or files into the new session.

MobileVibe’s Multi-Model Support

MobileVibe treats each agent session as a conversation tied to a folder, model, and surface. You can run an Opus conversation and a Sonnet conversation in the same folder as separate lanes. The MobileVibe dashboard shows both, so you can approve the Opus architecture from your phone, then check the Sonnet implementation lane later. Email loop works per conversation: “Email this conversation” continues the Opus thread; starting a new email in the same folder can target Sonnet.

Approval Gates: When to Hand Off from Opus to Sonnet

The handoff between Opus and Sonnet is an approval gate—a moment where you review Opus’s architectural output before committing to implementation. This gate prevents Sonnet from building on a flawed foundation.

Practical approval workflows:

Opus proposes, you review: Opus designs the schema, API, or refactor plan. You read the output, ask clarifying questions, and approve when satisfied.
Opus writes an ADR or spec file: Instead of just chatting, have Opus write a ARCHITECTURE.md or API_SPEC.md file. Review the file, commit it, and use it as the contract for Sonnet.
Opus generates a task list: Ask Opus to break the architecture into discrete implementation tasks. Review the list, then feed each task to Sonnet one at a time.
MobileVibe approval from mobile: If Opus needs input while you’re away, MobileVibe sends a notification. You open the conversation on your phone, review the proposal, and approve or redirect. Sonnet doesn’t start until you give the green light.

The key is to avoid starting Sonnet implementation before the architecture is stable. If Opus is still iterating on the design, Sonnet’s work may become throwaway code.

Monitoring Multi-Model Conversations on Mobile

Running Opus and Sonnet in parallel—one for architecture, one for implementation—creates a multi-model workflow that benefits from mobile monitoring. MobileVibe’s dashboard shows all active conversations across models, so you can:

Check Opus’s progress on the architecture while commuting, without waiting for it to finish before starting your day.
Approve an Opus decision from your phone, unblocking the handoff to Sonnet.
Monitor Sonnet’s implementation lane to see if it hit a quota, needs re-auth, or finished a task.
Run multiple Sonnet lanes in parallel (e.g., one per feature or worktree) while keeping the Opus architecture conversation open for reference.

Because MobileVibe routes to your real desktop, the agents run on your own machine with your filesystem, terminal, and tools. The phone is a control surface, not a constrained mobile IDE. You can review diffs, approve changes, or pause a lane without SSH or remote desktop.

This is especially useful for the opus for architecture pattern, where the Opus conversation may take hours to produce a design, and you don’t want to block Sonnet work while waiting. You can start Sonnet in a separate lane once Opus writes the spec file, and monitor both from your phone.

Common Pitfalls and Trade-Offs in Routing Patterns

Model routing adds complexity. Here are the failure modes and how to avoid them:

Pitfall: Sonnet re-invents the architecture

If you don’t provide enough context, Sonnet may make architectural choices that conflict with Opus’s design. Solution: Always give Sonnet a clear, written spec (a file Opus created, or a summary you wrote). Don’t assume Sonnet will infer the architecture from the codebase alone.

Pitfall: Opus over-engineers simple tasks

Opus’s depth can be overkill for straightforward features. If you ask Opus to design a simple CRUD endpoint, it may propose an elaborate event-driven system. Solution: Use Opus only for genuinely ambiguous or high-stakes decisions. If the task is clear, start with Sonnet.

Pitfall: Context loss between models

Switching models mid-conversation can lose nuance. Opus’s reasoning about trade-offs may not carry over to Sonnet unless you explicitly document it. Solution: Treat the handoff as a formal boundary. Write down the key decisions, commit them to a file, and reference that file in the Sonnet session.

Pitfall: Cost creep from unnecessary Opus usage

Opus is more expensive per token. If you use it for routine tasks, costs add up. Solution: Reserve Opus for the 10% of work that shapes the system. Use Sonnet for the 90% that executes the plan.

Trade-off: Coordination overhead

Running two models means managing two conversations, two sets of context, and two approval flows. For small projects, this overhead may not be worth it. Solution: Start with a single model (Sonnet for most projects, Opus if the architecture is genuinely complex). Add routing only when you hit a clear pain point—either Sonnet making poor architectural choices, or Opus being too slow for routine tasks.

Running Parallel Lanes with Different Model Strategies

Advanced users run multiple agent lanes in parallel, each with a different model and scope. Common patterns:

One Opus lane for architecture, multiple Sonnet lanes for features: Opus designs the system in the main project folder. Each Sonnet lane works in a git worktree or subfolder, implementing a specific feature based on Opus’s spec.
Opus for the core module, Sonnet for peripheral modules: If your project has a critical core (e.g., the authentication system) and less critical peripherals (e.g., admin UI), use Opus for the core and Sonnet for the rest.
Opus for refactoring, Sonnet for new features: Run Opus in a branch where you’re refactoring legacy code. Run Sonnet in the main branch for new feature work. Merge the refactor when Opus finishes.

MobileVibe’s dashboard makes this practical by showing all lanes in one view. You can see which conversations need attention, which are blocked, and which are safe to let run. The email loop works per conversation, so you can continue the Opus architecture thread from email while checking Sonnet’s implementation progress on the phone.

This multi-lane approach is overkill for small projects, but it scales well for teams or complex codebases where different parts of the system have different cognitive loads.

FAQ

When should I use Opus instead of Sonnet for a coding task?

Use Opus when the task requires deep reasoning, trade-off analysis, or system-level design: choosing a database schema, designing an API surface, evaluating framework options, or planning a complex refactor. Use Sonnet when the architecture is clear and the task is focused: implementing a feature, writing tests, fixing a bug, or refactoring within a known pattern. If you’re unsure, start with Sonnet; if it produces a shallow or conflicting solution, escalate to Opus.

Can I route the same conversation between Opus and Sonnet, or do I need separate agent sessions?

Most surfaces (Claude IDE, CLI, Cursor, Windsurf) treat model selection as per-conversation, so switching models mid-conversation isn’t natively supported. You’ll typically start a new conversation for the new model and provide context from the previous one (paste the output, reference a file, or summarize the decisions). MobileVibe treats each model+folder+surface combination as a separate conversation, so you run Opus and Sonnet as parallel lanes in the same folder, not as a single conversation that switches models.

How do I set up model routing in Claude IDE, CLI, or Cursor?

In Claude IDE, select the model from the dropdown when starting a conversation. For architecture, choose Opus; for implementation, choose Sonnet in a new conversation. In CLI tools (like codex-cli), pass a model flag: --model opus-4 or --model sonnet-4. In Cursor or Windsurf, select the model in the agent panel. None of these tools automatically route by task type; you choose the model explicitly per session.

What happens to conversation history when I switch models mid-project?

Switching models typically starts a fresh conversation with no shared history. The new model doesn’t see the previous model’s reasoning unless you provide it (paste the output, reference a file the previous model wrote, or summarize the key decisions). If you’re using MobileVibe, each conversation is independent, but they share the same filesystem, so Sonnet can read files Opus created. Plan the handoff as a formal boundary: have Opus write a spec file, commit it, and reference it in the Sonnet session.

How can I approve an Opus architecture decision before Sonnet starts implementation?

Set up an approval gate: have Opus write its architecture to a file (e.g., ARCHITECTURE.md or API_SPEC.md), review the file, and commit it before starting the Sonnet session. If you’re using MobileVibe, you can approve the Opus conversation from your phone—MobileVibe sends a notification when Opus needs input, and you can review and approve the proposal remotely. Don’t start Sonnet until the architecture is stable.

Does MobileVibe let me monitor and control multi-model agents from my phone?

Yes. MobileVibe’s dashboard shows all active conversations across models, folders, and surfaces. You can monitor an Opus architecture conversation and a Sonnet implementation conversation in parallel, approve decisions, check progress, and resume or pause lanes—all from your phone. The agents run on your real desktop (macOS or Windows), and MobileVibe routes your phone to that machine through a private tunnel. You’re not SSH-ing or using a mobile IDE; you’re controlling the same agents you’d use at your desk.

Is this pattern worth the extra complexity for small projects?

For small, straightforward projects, a single model (usually Sonnet) is simpler and faster. Add the opus for architecture pattern only when you hit a clear pain point: Sonnet making poor architectural choices, or Opus being too slow for routine tasks. If your project has ambiguous requirements, complex trade-offs, or high stakes (e.g., a production refactor), the pattern pays off. If you’re prototyping or building a simple CRUD app, stick with Sonnet and escalate to Opus only if needed.

Routing opus for architecture and Sonnet for implementation is a practical way to balance quality, speed, and cost in AI-driven development. Opus handles the 10% of decisions that shape your system; Sonnet handles the 90% that execute the plan. With MobileVibe, you can monitor and approve both lanes from your phone, so you’re never blocked waiting for an architectural decision or stuck at your desk to unblock an implementation task. Try MobileVibe free and see how multi-model workflows feel when you can control them from anywhere.

Routing Claude Opus for Architecture, Sonnet for Implementation: