Plan Mode Is Now Mandatory. Auto-Compact Should Be Enabled.

Two months ago I wrote about mastering Claude Code’s core loop. Plan Mode was already essential then. You toggled it with Shift+Tab, blocked write tools, and got structured plans before execution.

With Opus 4.5, Plan Mode isn’t just essential. It’s mandatory. And auto-compact, which I previously recommended disabling, should now be enabled.

Plan Mode: From Essential to Mandatory

Before native Plan Mode, developers invented workarounds:

• ROADMAP.md files: Persistent checklists with [ ] → [-] → [x] progression
• PLAN.md prompts: “PLAN.md IS the prompt” - structured files that survived context resets
• SCRATCHPAD.md: Anthropic’s own documentation recommended it for multi-step tasks
• ULTRATHINK: Magic keywords to force deeper reasoning before coding
• “Don’t code yet” prompts: Unreliable requests that Claude often ignored

These workarounds shared a common problem: no enforcement. You asked Claude to plan first, but it could still start coding. Users on Reddit reported “inconsistent results when requesting inaction from Claude” - the guidance worked sometimes, failed other times.

Before Plan Mode, “plan first” was a request Claude could ignore. Now it’s a system constraint Claude cannot bypass.

— The core problem

What Native Plan Mode Actually Does

Plan Mode blocks all write operations at the system level:

Available tools:

• Read, LS, Glob, Grep (exploration)
• WebFetch, WebSearch (research)
• Task with Explore subagent (codebase analysis)
• TodoRead, TodoWrite (task management)

Blocked tools:

• Edit, Write (file modifications)
• Bash (command execution)
• NotebookEdit (Jupyter changes)
• All MCP write operations

Claude physically cannot modify files until you approve the plan and exit. The workarounds are obsolete because the product solved the enforcement problem.

Opus 4.5: Interactive Planning

The November release added capabilities that make the old patterns look primitive:

• Proactive clarification: Claude asks about ambiguous requirements upfront instead of guessing
• Structured plan files: Creates editable plan.md with task breakdown and dependencies
• Superior reasoning: Opus 4.5’s deeper thinking produces better architectural plans
• Effort control: API parameter to balance thoroughness vs speed

The workflow shift is significant. Old pattern: “Please plan this → Review chat → Approve → Execute.” New pattern: “Request → Answer questions → Review plan.md → Edit if needed → Approve → Execute.”

Claude asks clarifying questions. You answer. It writes a structured plan. You edit directly. Only then does execution begin. The plan becomes a contract, not a suggestion.

The Real Game Changer: Parallel Subagent Exploration

Here’s what most people miss about Plan Mode: it’s not just Claude thinking before coding. It’s Claude spawning multiple agents to explore your codebase simultaneously.

When you enter Plan Mode and describe a complex task, Claude doesn’t explore sequentially. It launches parallel Explore subagents - lightweight Haiku-powered agents that search different parts of your codebase at the same time. One agent traces authentication flows. Another maps database schemas. A third identifies test patterns. They run concurrently, each with its own context window.

Plan mode now spins up multiple subagents in parallel to explore your codebase and generate plans from different perspectives. Then it asks clarifying questions before committing to an approach.

— Boris Cherny, Anthropic

This solves the context multiplication problem. A single agent exploring a large codebase exhausts its context window gathering information. With parallel subagents, each gets a dedicated context window. The main agent receives summarized findings without the exploration bloat.

Why this matters:

• Speed: Parallel exploration completes in the time of the slowest agent, not the sum of all searches
• Context isolation: Exploration details don’t pollute your main conversation
• Multiple perspectives: Different agents can analyze the same problem from security, architecture, and implementation angles simultaneously
• Cost efficiency: Explore subagents use Haiku (cheaper, faster) while your main agent uses Opus for reasoning

The old workarounds couldn’t do this. ROADMAP.md files don’t spawn parallel research. ULTRATHINK doesn’t delegate to multiple agents. The community built single-threaded planning because that’s all that was possible.

Native Plan Mode is multi-threaded by design.

Plans Persist to Disk

Here’s something the old workarounds couldn’t do: plans survive /clear.

When Claude creates a plan in Plan Mode, it writes to ~/.claude/plans/ with a unique filename. Run /clear to reset your context, and the plan is still there. Start a new session tomorrow, and Claude automatically references the latest plan in your interactions. The file is just markdown - you can read it, edit it, or delete it yourself.

This solves the session continuity problem that made PLAN.md workarounds necessary. Before, you’d write a plan to chat, /clear for fresh context, then manually tell Claude “read PLAN.md and continue.” Now the plan persists automatically and Claude continuously references it without prompting.

The workflow becomes: Plan Mode → approve plan → /clear for clean execution context → Claude continues from the persisted plan. You get the planning benefits without the context baggage.

Auto-Compact: I Changed My Mind

In my previous post, I recommended disabling auto-compact:

Want 22.5% of your context window back? Disable auto-compact in /config by setting auto-compact: false.

I’m reversing that recommendation.

Why I Said Disable It

Auto-compact had real problems:

• Opaque summaries: No visibility into what got preserved vs discarded
• Bad timing: Could trigger mid-debugging at the worst possible moment
• Context waste: Pre-allocated buffer consumed tokens before you started working
• Quality concerns: Important nuances could be lost in automatic summarization

Manual /compact at strategic breakpoints gave you control. You decided when to summarize and what to preserve.

What Changed

Opus 4.5 improved context handling significantly:

• Better summarization: The model does a better job identifying what matters
• 76% fewer output tokens: Less context consumed per response
• Automatic overflow handling: Long conversations don’t hit walls
• Improved MCP efficiency: Tool Search reduces definition overhead

The trade-off has shifted. Before: auto-compact quality was questionable, manual control was safer. Now: auto-compact quality is acceptable, and the convenience of not babysitting /compact outweighs the control benefits.

The Workflow That Emerged

After these improvements, here’s what I actually do:

1. /clear between tasks - Fresh context for each distinct piece of work
2. Plan Mode for everything non-trivial - Shift+Tab twice, no exceptions
3. Review plans critically - This is where you catch architectural mistakes
4. Let auto-compact handle overflow - Stop micromanaging context
5. Feed learnings to CLAUDE.md - Document patterns, not procedures

The foundation from my previous post still holds: master the core loop before reaching for MCPs and subagents. But the loop itself has improved.

Try It Now

If you’re still using external planning files or manually managing context:

1. Run /model and select Opus 4.5
2. Enable auto-compact if you disabled it (check /config)
3. On your next non-trivial task, hit Shift+Tab twice
4. Let Claude ask clarifying questions
5. Review the plan, edit if needed, approve

The workarounds are obsolete. ROADMAP.md, PLAN.md, SCRATCHPAD.md, ULTRATHINK - all replaced by native features. Use them.