← Reddit

Plan drift between Opus 5 (planning) and Sonnet 5 (implementation) in Claude Code — best practices?

Reddit · tonyromero · July 26, 2026
A developer using Opus 5 for initial planning and Sonnet 5 for implementation has encountered drift between the original plan and actual implementation as work progresses through phases. The user inquires about optimal plan granularity, whether plan re-derivation at each phase is expected behavior, and methods to enforce the original plan as a binding constraint rather than a suggestion.

Detailed Analysis

A Reddit discussion in r/ClaudeAI surfaces a practical workflow problem that has become increasingly common as developers adopt multi-model pipelines in Claude Code: using Opus 5 at high reasoning effort to architect a multi-phase implementation plan, then handing execution off to Sonnet 5 for the actual coding. The poster describes a familiar failure mode — by the time several phases have been implemented, the resulting code has meaningfully diverged from the original plan in terms of structure, scope, and key decisions. Compounding the issue, Sonnet 5 appears to regenerate its own interpretation of each phase when prompted with "implement phase X," rather than treating the previously approved plan as a literal, binding specification, even when Claude Code is running in auto mode with the plan file ostensibly available as context.

The questions raised — plan granularity, re-planning behavior, model-switching effects, and enforcement mechanisms — point to a deeper tension in how agentic coding tools balance flexibility against fidelity. Claude Code, like most LLM-driven agents, treats prior planning artifacts as context to be reasoned over rather than as immutable instructions to be executed verbatim. This is by design: agents are built to adapt to real conditions in the codebase (files that don't exist yet, dependencies that changed, edge cases the plan didn't anticipate), which is generally a feature rather than a bug. But that same adaptability means that unless a plan is extremely prescriptive or explicitly re-injected and reinforced at each phase boundary, the model treats it more as a loose reference than a contract — and successive phases can compound small deviations into significant architectural drift.

The model-switching variable the poster raises is particularly interesting and reflects a genuine open question in the Claude ecosystem. Opus and Sonnet, despite sharing training lineage and alignment approach, are different models with different capacity, different default verbosity, and potentially different "taste" in code structure and naming conventions. When one model authors a plan and a different, generally less capable model executes it, there's an inherent translation gap: Sonnet must infer intent from Opus's plan rather than share Opus's internal reasoning state, and any ambiguity in the plan becomes an opportunity for reinterpretation. This is analogous to problems seen in human engineering organizations where a senior architect's design gets reinterpreted by implementing engineers — except LLM agents have no persistent memory of "why" a decision was made unless it's explicitly encoded in the artifact itself, making explicit, unambiguous documentation more load-bearing than it might be with human collaborators who can ask clarifying questions informally.

This thread reflects a broader trend in how developers are learning to operationalize agentic coding tools: the emergence of informal best practices around plan files, CLAUDE.md instructions, explicit phase-gating, and treating planning documents as first-class artifacts that must be re-referenced and reinforced rather than assumed to persist in an agent's working context. As teams increasingly split planning and execution across different models — often for cost or latency reasons, using expensive high-effort reasoning models for architecture and cheaper faster models for implementation — the industry is effectively re-deriving software engineering discipline (spec contracts, design docs, acceptance criteria) as a mitigation for the statelessness and interpretive flexibility of LLM agents. Anthropic's own documentation and community guidance increasingly emphasizes techniques like explicit plan-mode outputs, structured markdown specs, and instructing agents to "follow the plan exactly, ask before deviating" — but as this thread shows, users are still discovering through trial and error how much structure is required to make multi-agent, multi-model pipelines behave predictably, and enforcement mechanisms remain more probabilistic than guaranteed.

Read original article →