How to Use Claude Opus 4.5 in Claude Code Without Paying $200/Month

Originally surfaced by @LinearUncle

---

If you have been sleeping on Claude Code's lesser-known model routing tricks, you are leaving serious money on the table. Most developers assume that getting Opus 4.5-quality output requires the $200/month MAX subscription. It does not. There is a smarter way to work.

This post breaks down a cost-saving technique that has been quietly circulating among power users: the opusplan mode strategy. Once you understand how it works, you will rethink how you allocate model usage across every agentic coding session.

---

What Is /model opusplan and Why It Matters

Inside Claude Code, you can switch models mid-session using the /model command. Most users know about switching between claude-opus-4-5 and claude-sonnet-4-5 directly. Fewer people know about opusplan.

To activate it, simply run:

/model opusplan

Here is the key insight: opusplan is not a real model name. It is a hybrid routing strategy built into Claude Code. When you invoke it, the system does something much smarter than just picking one model:

1. Planning phase — Claude Opus 4.5 handles the high-level reasoning, architecture decisions, and task decomposition. This is where Opus earns its keep: deep context understanding, nuanced trade-off analysis, and producing a high-quality execution plan.
2. Execution phase — Claude Sonnet 4.5 takes over to carry out the actual implementation. Sonnet is faster, cheaper, and more than capable of following a well-structured plan. It does the heavy lifting of writing code, running tool calls, and iterating on output.

The result is that you get Opus-quality thinking at a fraction of Opus-level token cost. For long agentic sessions involving dozens of tool calls and file edits, this difference is substantial.

---

The Real Cost Problem with Agentic Sessions

To understand why this matters, consider what happens during a typical Claude Code session on a complex task.

A single agentic run might involve:

• Reading 15–20 source files
• Making 30–50 tool calls (bash, edit, search)
• Generating multiple intermediate reasoning steps
• Producing a final diff spanning hundreds of lines

If every single one of those steps runs on Opus 4.5, token costs stack up fast. Opus is priced significantly higher than Sonnet per token, and in an agentic loop, that gap compounds quickly.

The opusplan strategy treats model selection as a resource allocation problem, not a binary choice. You are not asking "which model should I use?" You are asking "which phase of this task actually needs the strongest model?"

The answer, almost always, is: only the planning phase does.

Once you have a precise, well-reasoned plan — clear subtasks, defined file targets, explicit constraints — Sonnet 4.5 can execute it reliably. You do not need Opus to write a for loop or call an API. You need Opus to figure out which for loop to write and why.

---

A Practical Workflow: Opus Plans, Sonnet Executes

Here is a concrete workflow you can adopt today.

Step 1: Start with an Opus plan

Open a Claude Code session and switch to opusplan:

/model opusplan

Then describe your task at a high level. Be explicit that you want a plan first:

I need to refactor our authentication module to support OAuth2 alongside 
the existing session-based auth. Do not write any code yet. Give me a 
detailed implementation plan with specific files, functions to modify, 
and potential edge cases.

Opus 4.5 will produce a thorough plan: which files to touch, what interfaces to preserve, where conflicts might arise, what tests to update. This is where the model's reasoning depth pays off.

Step 2: Review the plan before execution

Do not skip this step. Read the plan. Push back if something looks wrong. This is cheap — you are spending Opus tokens on reasoning, not on generating hundreds of lines of boilerplate.

The plan looks good, but we also need to handle token refresh. 
Can you update the plan to include that?

Step 3: Execute with Sonnet

Once the plan is solid, switch to Sonnet for execution:

/model claude-sonnet-4-5

Then tell Claude Code to implement the plan:

Now implement the plan we just finalized. Follow it step by step.

Sonnet 4.5 handles the execution phase efficiently. It follows clear instructions well, writes clean code, and runs tool calls without needing Opus-level reasoning at every step.

Bonus: Use Opus for spot-checks on hard sub-problems

If you hit a genuinely tricky problem mid-execution — a subtle race condition, an ambiguous API behavior, an architectural decision — switch back to Opus briefly:

/model opusplan

Get the clarification or micro-plan you need, then drop back to Sonnet to continue.

---

When to Use This Strategy (and When Not To)

Good candidates for opusplan:

• Large refactors touching multiple files and systems
• Greenfield feature development requiring upfront design decisions
• Debugging sessions where root cause analysis is non-trivial
• Tasks involving external APIs, database schemas, or security-sensitive logic

Cases where it adds less value:

• Small, well-defined tasks (fix this typo, add this field) — just use Sonnet directly
• Tasks where you already have a detailed spec written — skip the planning phase
• Rapid prototyping where iteration speed matters more than plan quality

The underlying principle is straightforward: match model capability to task complexity, not to session uniformity. Using Opus on everything is wasteful. Using Sonnet on everything leaves quality on the table. The split approach captures the best of both.

---

What This Reveals About Claude Code's Design

The existence of opusplan as a named strategy hints at something broader. Claude Code is not just a chat interface with a code editor bolted on. It is being designed with agentic economics in mind — the recognition that multi-step AI workflows have internal structure, and that structure should inform resource allocation.

As models continue to improve and differentiate, expect more of these hybrid routing patterns to emerge. The developer who understands how to orchestrate model tiers — not just which model to use, but when within a task to use each — will have a meaningful edge in both output quality and cost efficiency.

---

Conclusion

You do not need a $200/month MAX subscription to get Opus 4.5-quality results in Claude Code. The /model opusplan strategy gives you Opus reasoning where it matters most — the planning phase — while routing routine execution to the faster, cheaper Sonnet 4.5.

The workflow is simple: let Opus think, let Sonnet build. Review the plan before committing to execution. Use Opus for hard mid-session decisions. Keep Sonnet as your default workhorse.

This kind of model-tier orchestration is quickly becoming a core skill for developers working with AI coding tools. Start applying it now, and you will spend less while getting more.

---

Tip originally shared by @LinearUncle on X. Published on ClawList.io — your developer resource hub for AI automation and OpenClaw skills.