Claude Code recently shipped one of its most impactful improvements yet - not a new model, not a flashy feature, but explicit control over context.

The result: better plan adherence, less drift, and far more predictable execution.

This post breaks down what changed, why it matters, and how it fundamentally shifts how we should think about LLM‑powered developer tools.

---

The Old World: Chat‑Driven Execution

Historically, LLM tooling has treated conversations as a continuously growing context window. Ideas accumulate, but they rarely disappear.

That means:

• Early brainstorming leaks into execution
• Abandoned approaches still influence output
• Stale constraints quietly survive

Visually, it looks like this:

flowchart TB
  A[Early Brainstorming] --> B[Partial Ideas]
  B --> C[Abandoned Constraints]
  C --> D[Revised Plan]
  D --> E[Implementation]

  C -. contaminates .-> E

  style C fill:#5c2d2d,color:#fff

Everything stays. Nothing truly resets.

This is the root cause of “why did it do that?” moments in long coding sessions.

---

Plans as Execution Artifacts

Claude Code introduces a subtle but powerful change:

When you accept a plan, Claude clears the existing context.

Only the following survive:

• The accepted plan
• Required system and tool context

Everything else is discarded.

flowchart LR
  A[Conversation Context] -->|Accept Plan| B[Context Cleared]
  B --> C[✅ Accepted Plan]
  B --> D[✅ System + Tools]
  C --> E[Execution]
  D --> E

  style B fill:#1f4f2f,color:#fff
  style C fill:#1f4f2f,color:#fff
  style D fill:#1f4f2f,color:#fff

This transforms the plan into a compiled artifact, not a conversational waypoint.

If you prefer the old behavior, you can opt out - but making this the default is an intentional and correct design choice.

---

Why This Improves Plan Adherence

By resetting context at execution time:

• The model no longer re‑litigates earlier ideas
• Conflicting constraints vanish
• The plan becomes the single source of truth

This mirrors how real systems behave:

• You design
• You compile
• You execute

Not:

• You keep every whiteboard scribble alive forever

---

Ralph Wiggum and Explicit Loop Control

As the Ralph Wiggum plugin gains adoption, a natural question emerged:

“How do I get a fresh context window per loop?”

The answer:

/clear

Each iteration can now start clean.

flowchart LR
  A["/clear"] --> B[Iteration 1]
  B --> C["/clear"]
  C --> D[Iteration 2]
  D --> E["/clear"]
  E --> F[Iteration 3]

This single command enables:

• Deterministic agent loops
• Repeatable evals
• Reduced cross‑iteration drift

Explicit lifecycle control beats hidden heuristics every time.

---

Auto‑Compaction: What’s Actually Happening

Auto‑compaction has drawn criticism for removing nuance. The Claude Code team addressed this directly by explaining how it works.

It’s not magic - it’s math.

flowchart TB
  A[Context Window]
  A --> B[Used Context]
  A --> C[Auto-Compact Buffer]
  A --> D[Free Space]

  C -->|computed from| E[maxOutputTokens]

  style C fill:#6b4e1e,color:#fff

The buffer exists to reserve space for future output.

---

The Formula (Simplified)

flowchart LR
  A[Context Window] --> B[Minus maxOutputTokens]
  B --> C[Minus small constant]
  C --> D[Auto-Compact Buffer]

Key facts:

• Default auto‑compact buffer ≈ 45k tokens
• If yours is larger, your maxOutputTokens is set high
• Large output caps force aggressive compaction

So when nuance disappears, it’s often because the system is protecting space for a massive potential response.

---

The Fix: Reduce Output to Gain Context

Counter‑intuitively, the solution is to lower your maximum output tokens.

flowchart LR
  A[High maxOutputTokens]
  A -->|forces| B[Large Auto-Compact Buffer]
  B -->|reduces| C[Usable Context]

  D[Lower maxOutputTokens]
  D -->|shrinks| E[Auto-Compact Buffer]
  E -->|increases| F[Usable Context]

  style F fill:#1f4f2f,color:#fff

Lowering:

CLAUDE_CODE_MAX_OUTPUT_TOKENS

Gives you:

• More effective context
• Less aggressive compaction
• Better retention of nuance

---

The Bigger Shift: LLMs as Compilers

Taken together, these changes reveal a clear philosophy shift.

flowchart LR
  A[Plan] --> B[Fresh Context]
  B --> C[Execution]
  C --> D[Diff / Output]

  style B fill:#1f4f2f,color:#fff

Claude Code is moving toward:

• Explicit execution boundaries
• Deterministic behavior
• Power‑user controls
• Compiler‑style workflows

This is not “chat with code.”

This is programming with an LLM.

---

Why This Matters for Serious Development

If you’re working on:

• Large refactors
• Multi‑step migrations
• Agent loops
• Repeated evaluations

These changes mean:

• Less re‑explaining
• Better diffs
• Fewer surprises
• More trust

The biggest improvements in AI dev tooling won’t come from larger models alone.

They’ll come from clarity, determinism, and explicit control.

Claude Code just took a major step in that direction - quietly, but decisively.