Claude Code Costs $200/Month — Here's How to Cut It in Half

The $200 Problem

Claude Code Max 20x costs $200/month. That buys roughly 240-480 hours of Sonnet 4.6 per week and 24-40 hours of Opus 4.6 — more than enough for heavy professional use. The problem is that most developers on the Max plan are burning Opus-level reasoning tokens on tasks that do not need Opus-level reasoning.

I tracked my own usage for four weeks. The breakdown: roughly 40% of my Claude Code interactions were simple — file lookups, small edits, one-line fixes, "what does this function do?" questions. Another 25% were moderate — test writing, code reviews, documentation. Only 35% genuinely needed deep multi-step reasoning: complex refactors, architectural decisions, multi-file debugging sessions.

That means 65% of my token budget went to tasks that could have been handled cheaper, faster, or both. Here are five methods I tested to fix that, with real before/after numbers.

Method 1: Use /effort to Control Reasoning Depth

Claude Code's /effort command controls how deeply the model reasons before responding. Four levels are available: low, medium, high (the default), and max (Opus 4.6 only). Lower effort means fewer thinking tokens, which means less of your usage budget consumed per interaction.

How It Works

Run /effort low in your Claude Code session, and every subsequent response uses minimal reasoning. Claude skips extended thinking and responds directly. Run /effort high to switch back for harder tasks. You can also set /effort auto to let Claude decide based on the query.

What to Route Where

Before/After

A typical day of mixed Claude Code usage at the default high effort consumes your rate limit roughly 2x faster than it needs to. Setting /effort low for simple queries and /effort medium for moderate tasks reduces total token consumption by an estimated 30-40%.

Before: 100% of interactions at high effort. Hit rate limits by mid-afternoon on the Pro plan. After: 40% at low, 25% at medium, 35% at high. Same Pro plan lasts through the full workday.

Estimated savings: 30-40% of total token usage.

Method 2: Write a Good CLAUDE.md to Kill Wasted Iterations

Every wasted iteration costs tokens. When Claude Code misunderstands your project structure, uses the wrong test framework, or formats code in a style you reject — that is a round trip you pay for twice: once for the wrong answer, once for the correction.

A well-crafted CLAUDE.md file prevents this by giving Claude Code the context it needs upfront. This is not the same as documentation. It is a concise instruction set that prevents the most common misunderstandings.

What Belongs in CLAUDE.md

# Project: my-app

## Architecture
- Next.js 15 App Router, TypeScript strict mode
- Database: PostgreSQL via Drizzle ORM
- Styling: Tailwind CSS v4, no CSS modules

## Conventions
- Components: named exports, no default exports
- Tests: Vitest, co-located in __tests__ directories
- Error handling: Result pattern, never throw in business logic

## Active Context
- Currently refactoring auth flow from NextAuth to custom JWT
- Migration in progress: /src/lib/auth/ is the new path

## Do NOT
- Use default exports
- Add console.log (use project logger at src/lib/logger.ts)
- Create new API routes under /pages/api (deprecated)

Why This Saves Money

Without CLAUDE.md, Claude Code reads your codebase to infer conventions. That means scanning multiple files per task, often guessing wrong on the first attempt, and requiring corrections. Each correction is a full round trip — your prompt plus Claude's response plus the new correction prompt.

With a good CLAUDE.md: Claude gets conventions on the first read, produces correct output more often on the first try, and needs fewer file reads to understand your project structure.

Before/After

Before: Average 2.3 iterations per task. Claude frequently uses wrong patterns, requiring correction prompts. After: Average 1.4 iterations per task. Corrections needed only for genuinely ambiguous requirements.

Estimated savings: 25-35% of total token usage. The compounding effect matters — fewer wasted iterations means fewer tokens consumed per task means more tasks within your rate limit.

Keep your CLAUDE.md under 500 lines. Every token in it gets loaded every session. Bloated context files defeat the purpose. The AI CLI Tools Complete Guide covers CLAUDE.md best practices in depth.

Method 3: Offload Simple Tasks to Gemini CLI (Free)

This is the highest-impact single change you can make. Gemini CLI is free — 1,000 model requests per day, 60 requests per minute, using Gemini 2.5 Pro with a 1 million token context window. No credit card. No trial period.

For the 40% of tasks that are simple lookups, explanations, small fixes, and documentation, Gemini CLI handles them well. Not as well as Claude Code on complex tasks — but for straightforward work, the quality difference is negligible and the cost difference is $200 vs. $0.

The Routing Rule

Before typing a prompt in Claude Code, ask one question: Does this task require multi-step reasoning across multiple files?

• Yes — Use Claude Code.
• No — Use Gemini CLI.

This single heuristic handles 90% of routing decisions correctly. The dual-tool strategy guide covers the full decision framework, but the one-question version gets you 80% of the savings.

What Gemini CLI Handles Well

• Explaining unfamiliar code
• Writing unit tests for a single function
• Generating boilerplate (components, API routes, config files)
• Quick code reviews of small changes
• Documentation drafts
• Simple refactors within a single file
• Answering "how do I do X in framework Y" questions

What Still Needs Claude Code

• Multi-file refactors with cascading dependencies
• Debugging subtle bugs that span multiple modules
• Architectural decisions requiring deep codebase understanding
• Complex git operations and merge conflict resolution
• Tasks requiring tool use chains (read, edit, test, fix)

Before/After

Before: All tasks go through Claude Code. Max 20x at $200/month, and you still occasionally hit rate limits during heavy days. After: 40-50% of tasks routed to Gemini CLI. Claude Code usage drops enough to consider Max 5x at $100/month — or even Pro at $20/month if you are disciplined.

Estimated savings: $100-180/month (plan downgrade) or 40-50% of token budget (same plan, more headroom).

Method 4: Use Subagents Strategically (Not for Everything)

Claude Code's subagent system lets you spawn child agents for parallel work. Subagents are powerful for exploration tasks — searching a large codebase, investigating multiple potential root causes, or researching API documentation. But they are not free.

Each subagent runs as a separate Claude instance with its own context window. A main agent that spawns 3 subagents consumes roughly 4x the tokens of a single agent session. Spawning subagents for trivial tasks is like hiring four contractors to change a lightbulb.

When Subagents Save Money

Subagents save money when the alternative is worse: manually searching through 20 files in a single session (with every file read adding to your context), or going through multiple trial-and-error iterations because you did not explore the problem space first.

Good subagent use cases:

• Searching a large codebase for all usages of a deprecated API (subagent explores, main agent acts on results)
• Investigating 3 potential root causes for a bug in parallel
• Gathering context from multiple documentation sources before making an architectural decision
• Running test suites in a separate context while you continue development

Bad subagent use cases:

• Reading a single file (just read it directly — launching a subagent costs more)
• Simple search-and-replace operations
• Any task with fewer than 3 files to examine
• Tasks where you already know what to do and just need execution

The 3-File Rule

If a task involves examining fewer than 3 files, do it in your main session. If it involves 3 or more files of exploration, consider a subagent. This simple threshold prevents the most common overuse pattern.

Before/After

Before: Subagents spawned for nearly every task because "parallel is faster." Token consumption 3-5x higher than necessary. After: Subagents only for genuine exploration tasks. Token consumption drops by 40-60% on subagent-heavy workflows.

Estimated savings: 20-30% of total token usage for developers who use subagents. No impact if you do not use them.

Method 5: Context Management — /compact and /clear

Claude Code's context window is a rolling cost meter. Every message, every file read, every tool output stays in context and gets sent with every subsequent prompt. A session that has been running for 2 hours can have 100k+ tokens of context, and every new interaction pays for re-transmitting all of it.

Two commands manage this: /compact and /clear.

/compact — Summarize and Continue

/compact summarizes the current conversation into a shorter representation, preserving key decisions and context while discarding verbose intermediate steps. Use it when your context meter hits 60-70% capacity.

You can add custom preservation instructions:

/compact preserve the list of modified files and the test results

/compact keep only the architectural decisions, drop all debugging attempts

This is critical because Claude Code's default compaction preserves everything equally. Debugging dead-ends that consumed 20 messages are worth zero tokens after compaction — tell Claude to drop them.

/clear — Start Fresh

/clear wipes the context entirely. Use it when switching to an unrelated task. A context window full of auth refactoring context is pure noise when you start working on a payment integration.

The mistake most developers make: continuing the same session across unrelated tasks. By hour 3, context is bloated with irrelevant information from previous tasks, and every new interaction pays the token cost of carrying that dead weight.

The Workflow

1. Start a task in a fresh session or after /clear
2. Work until the context meter hits 60-70%
3. Run /compact with specific preservation instructions
4. Continue working
5. When the task is done, run /clear before starting the next task

Before/After

Before: Single continuous sessions running 3-4 hours. Context bloat makes later interactions 3-5x more expensive than early ones. After: Compact at 70%, clear between tasks. Average context size stays 40-60% lower across a workday.

Estimated savings: 20-35% of total token usage.

Combined Impact: The Full Stack

These five methods are not alternatives — they stack. Here is the combined impact when applied together:

The savings compound. If Gemini CLI handles 40% of your tasks, and /effort reduces token consumption on the remaining 60%, and good CLAUDE.md cuts wasted iterations within those tasks, and context management keeps your sessions lean — the combined effect is typically a 50-60% reduction in Claude Code usage.

For a developer on Max 20x at $200/month, that means you can likely drop to Max 5x at $100/month. For a developer on Max 5x at $100/month, you can likely drop to Pro at $20/month. The AI CLI cost optimization guide covers even more strategies including free tier stacking and budget templates for different developer profiles.

The Bottom Line

Claude Code is the best agentic coding tool available. The $200/month price is not the problem — using it wastefully is. These five methods are not workarounds or compromises. They are how Claude Code is designed to be used: right effort level for each task, clear project context, complementary tools for simple work, disciplined subagent use, and active context management.

Apply all five, track your usage for two weeks, and then decide whether your current subscription tier is still the right one. Most developers find they can drop at least one tier without losing any productivity.