Anthropic announced a major simplification of Claude Code's system prompts, removing over 80% of explicit rules, but a developer's packet analysis revealed that Opus 5 actually received significantly more instructions than the previous model. The apparent contradiction highlights a fundamental tension in AI development: as models become more capable, they sometimes need more, not fewer, constraints to behave predictably.

What Exactly Did Anthropic Remove?

The original Claude Code relied on what Anthropic described as an "Employee Handbook" approach to system prompts. The model had explicit, absolute rules written directly into its instructions to prevent mistakes. For example, the system prompt included default rules like "do not write comments" and "never write multi-line docstrings" unless explicitly requested by the user.

Over time, this approach created a problem: instructions from different parts of the prompt began to conflict with each other. When Claude encountered overlapping or contradictory guidance, it had to spend computational energy figuring out which instruction to follow before it could even start working on the actual task. Anthropic's solution was radical: perform what they called "major surgery" on the entire prompt structure.

The most visible change involved condensing lengthy lists of rules into single, principle-based statements. The old rules about comments and documentation became one sentence: "Write code that matches the style of the surrounding code, keeping consistent with its comment density, naming conventions, and idiomatic writing patterns." Instead of telling Claude what not to do, Anthropic told it to look at the existing codebase and make intelligent decisions.

How Did Developers Discover the Contradiction?

Developer Chen Cheng decided to verify Anthropic's claims by capturing the actual system prompts sent to different Claude models. Using the Claude Code command-line interface (CLI) pointed at a local server, Cheng counted the exact character length of prompts received by each model version.

The results were striking. When upgrading from Opus 4.7 to Opus 4.8, Claude Code's system prompts did indeed shrink dramatically, from 15,225 characters down to 4,467 characters. But when Opus 5 arrived, the trend reversed completely. The actual system prompts grew from 4,467 characters to 7,694 characters, a 72% increase compared to Opus 4.8.

This discovery raised an obvious question: if Anthropic removed 80% of prompts, why did the newest model receive more instructions than the previous version? The answer reveals something important about how AI models evolve.

Why Did Opus 5 Need More Instructions?

Anthropic's implementation uses two separate sets of prompts. A function in the code decides which set to send based on the model ID. Older models like Sonnet, Haiku, and Claude 3 continue using the detailed old prompt system, while new models like Opus 5 and Fable 5 use the streamlined new approach.

However, Opus 5 developed new behavioral habits that required additional constraints. According to Anthropic's published guidelines, Opus 5 is significantly more proactive than earlier models. It prefers to report progress while executing tasks, generates longer responses and documentation, and is more willing to call sub-agents, expand task scope, and repeatedly verify results.

These new tendencies are useful for complex, long-running tasks but can become problematic for simple requests. If a user only wants to modify a few lines of code, Opus 5's inclination to expand scope and generate extensive documentation creates unnecessary overhead. To manage this behavior, Anthropic added back targeted constraints specifically designed for Opus 5.

The extra content Cheng identified breaks down into two main categories. The first covers "Delivering work," with rules on how to control task scope, report progress, and deliver final results. The second addresses "Corrections," restricting the model from repeatedly explaining itself and correcting previous mistakes. Together, these two sections account for approximately 3,755 characters, which almost exactly matches the difference between Opus 5 and Opus 4.8.

How to Optimize Your Claude Code Setup for the New Prompt Architecture

Anthropic provided specific guidance for developers using Claude Code or building agents based on Claude. These recommendations reflect the shift from explicit rules to principle-based guidance:

• Streamline CLAUDE.md: Keep only project-specific special rules and remove information that Claude can infer directly from the codebase itself.
• Split long instructions into Skills: Save processes like code review, testing, and release as separate modules that load only when needed, rather than including everything in the main prompt.
• Remove duplicate instructions: Write each rule only once and eliminate content that already appears in tool descriptions or the system prompt.
• Reduce tool call examples: Clearly define parameter meanings, available options, and expected return results instead of providing rigid, fixed call examples.
• Provide executable references directly: Share test cases, existing code, HTML prototypes, or other project files with Claude for reference, replacing long descriptive text passages.

The underlying principle is simple: stop giving Claude an overly detailed handbook that covers every trivial point. Instead, clearly define tools, the operating environment, and task boundaries, then trust the model to make intelligent decisions within those constraints.

What Does This Mean for the Broader AI Development Landscape?

The Claude Code prompt saga illustrates a paradox in modern AI development. As language models become more capable, they don't necessarily need fewer instructions; they need smarter ones. The shift from explicit rules to principle-based guidance reflects growing confidence in the models' ability to reason about context and make appropriate decisions.

However, this approach also reveals that capability and controllability are not always aligned. A more powerful model that tends toward certain behaviors, like Opus 5's proactivity, sometimes requires more specific constraints, not fewer. Developers working with Claude Code should expect this pattern to continue as new model versions arrive with different behavioral characteristics.

The practical takeaway for developers is that prompt engineering is not a one-time task. As models evolve, the optimal prompt structure changes. The developers who will get the most value from Claude Code are those who understand that the tool requires ongoing adjustment and refinement, not just initial setup.