Solutions for the Issue of Shallow Thinking in Claude Opus 5

Overview

Immediately after switching Claude Code to Opus 5, I noticed a sudden increase in prose-heavy responses and a tendency for "shallow thinking" (an inability to think structurally).

Upon investigation, it wasn't that the model was bad or the rules were broken; rather, the internal system prompt provided to Opus 5 in the Claude 5 generation has changed significantly, and legacy rules were not written with this new premise in mind.

This article records the process of isolating the cause and revising rules to fit the new system prompt. It is intended for Claude Code users who feel that the effectiveness of CLAUDE.md or their rules has changed since upgrading to the new generation of models.

The Problem

Using the same session and the same rules, the following occurred immediately after switching the model to Opus 5:

• Situational explanations became flat, long-form prose without headings or sections.
• Explanations of causes stopped at a single layer (listing symptoms in parallel without digging into the "why").
• No evaluation criteria were provided when suggesting multiple options.
• Categories or numbering established in one turn were rearranged into different structures in the next.
• The model would skip responding to my input and immediately jump into tool execution (tasks).

The frustrating part was that even when prompted to "think more deeply," it would return sporadic answers while remaining in a shallow thinking state. Repeated corrections didn't click, leading to arguments rather than productive discussion.

It wasn't just a matter of single-response quality; the process of deliberation through dialogue itself had broken down.

Key Clues

This didn't happen with other models using the same rules (details on this difference are in the appendix). If the rules themselves had deteriorated, the issue should have appeared across all models. Since only the model changed, I began investigating under the assumption that the "environment the rules assume" had changed.

Cause: Changes in the System Prompt Provided to Opus 5

In the Claude 5 generation of Claude Code, the internal system prompt has been reduced by approximately 80% compared to previous generations. By measuring the prompt actually delivered to Opus 5 (by disabling output style injections and having the model quote its own prompt; Claude Code v2.1 series, July 2026), the structure was as follows:

1. Identity, Role Declaration, and Security Policy — The opening preamble.
2. Harness Specifications (# Harness) — Explanations of the execution environment, such as output being displayed as markdown.
3. Environment Info and Feature Descriptions (# Session-specific guidance / # Memory / # Environment / # Context management) — CWD, git status, model ID, memory, and context compression mechanisms.
4. Scope Discipline (# Delivering work) — Not narrowing or expanding the requested scope without permission.
5. Correction Etiquette (# Corrections) — Keeping corrections concise without adding apologies or preambles.

Two specific characteristics directly linked to the symptoms emerged:

• Feature 1: Zero instructions regarding response style. There were no rules about prose vs. structure, use of headings or tables, or conciseness—formatting rules that were extensive in previous generations were entirely gone.
• Feature 2: An "Act First" autonomous policy was added. To quote the original: "When you have enough information to act, act." and "If you are weighing a choice, give a recommendation, not an exhaustive survey."

Re-reading the symptoms through these two features makes everything click. Since there are no style rules, the model's raw output tendency—flat prose—comes out. The "recommendation over survey" policy encourages the omission of evaluation criteria.

You might think, "If the rules are blank, shouldn't my custom rules become the sole authority and work better?" In reality, the opposite happened. This blank space isn't a margin left for the user; it's delegated to the default behavior baked into the model during training. The "lean prompt" assumes that new-generation models follow internalized behaviors without detailed instructions. Instead of being filled by your rules, the void is filled by the model's pre-trained defaults. And Opus 5's default is concise prose that acts before confirming.

My old rules used general instructions like "break down situations structurally," "add evaluation criteria to multiple options," and "respond before acting." These were written assuming they would be read alongside a style-heavy system prompt. While sufficient then, they were too weak in both specificity (naming the original text) and delivery (reaching the model right before action) to override trained defaults. This is the true nature of the symptoms.

Anthropic itself refers to this reduction as a "lean system prompt" in the changelog (v2.1.154), reflecting a shift in design philosophy: "New generation models have internalized behaviors through training, so detailed instructions can cause friction or contradiction." For detailed explanations, see Claude Code System Prompt Reduced by 80% — Prompt Design Philosophy for the Fable 5 Generation. For primary sources, refer to the Claude Code changelog and Prompting Claude Fable 5 (Official Guide).

In short, symptoms are determined by the combination of "rules × the prompt actually delivered to that model." You cannot find the cause by looking at the rules alone. The first lesson was that a model update is also a system prompt update.

Measure 1: Identify Contradictions and Override by Naming the Original Text

First, I cross-referenced all rules with the new system prompt to identify where they said the opposite. For rules intended to override the system policy, I rewrote them to explicitly quote the original text and declare priority.

To start with what didn't work: adding generalities like "write multiple options with evaluation criteria" is ineffective.

When placed alongside the system's "give a recommendation, not an exhaustive survey," there's no clue as to which takes precedence. By naming the conflict, the priority becomes clear.

For things entirely absent from the prompt, like style rules, the instruction works to "fill the void" rather than override.

I also revised how trigger conditions are written. Conditions like "for important changes" or "if judged to be a production environment" fail the moment the model doesn't categorize the situation that way. I changed triggers to observable facts like "received an interrupt" or "user's utterance contains a correction."

Measure 2: Describe Desired Actions Instead of Prohibitions

Old rules were an accumulation of "don'ts." Prohibitions help detect violations but don't convey what to do instead. When a prohibition conflicts with a new system policy, the model finds a loophole: "follow the system policy while avoiding the prohibition." I converted negative constraints into descriptions of desired behavior.

• Before: "Do not suggest a commit if tests are incomplete."
• After: "When suggesting a commit, include the results of running the product from the perspective of the end-user in the body text."

I checked the rewritten rules against the following criteria, especially for expressions that clash with the System Prompt:

1. Is the rule self-contained? (Scope, examples, and criteria in one place)
2. Is the trigger an observable fact?
3. Does it contradict the internal system prompt?
4. Does it describe desired behavior? (Not just a list of bans)
5. Is there a single criterion for judgment? (Not a list of scenarios)
6. Is emphasis (IMPORTANT) reserved only for what truly cannot be dropped?
7. Is it written as the desired end-state? (Not forcing templates or steps first)
8. Can compliance be determined after the fact?

I narrowed down emphasis markers (IMPORTANT) to only security and approval gates. A document where everything is emphasized is the same as a document where nothing is.

Measure 3: Choose the "Layer" for Delivering Instructions

It wasn't just about the text. Claude Code has at least four paths to deliver instructions to the model, and they differ significantly in effectiveness.

Since the API is stateless, content from all paths is sent to the model with every request (every turn). The difference lies in "when the content is finalized" and "where it is placed in the prompt = how close it is to the action being taken."

Surprisingly, output style—which documentation says "replaces the system prompt"—was delivered as an attachment in every turn according to session logs.

I wrote two types of instructions in this output style: Style (Measure 1: write structurally, add criteria) and Process (respond to the user before starting work). The results were mixed.

While the Style instructions showed improvement, the Process issue—skipping responses to start work—did not stop via output style. I finally stopped this habit by using a UserPromptSubmit hook to inject a single line immediately after every user utterance: "Write a response to this utterance (answer, or acknowledgment and plan) in the body text before executing tools."

The cost is about 50 tokens per utterance. Even 100 utterances only cost 5,000 tokens, which is negligible against a 200K context. The general rule I learned is simple: Instructions delivered "briefly, every time, right before the action" are the most effective. Many ineffective instructions aren't bad in content; they just aren't at hand at the moment of action.

Results

Here are the results confirmed so far:

• A trend of headings/sections returning to situational and causal explanations. (However, flat output sometimes remains in the early session; ongoing observation required).
• The "work without responding" habit did not fix with output style alone but stopped after introducing per-utterance injection (currently observing long-term effects).

Summary

• A model update is also a system prompt update. If response trends change suddenly, read the changes in the system side before adding more rules.
• Rules that compete with system policies must name the original text and declare priority. General additions lose out in the face of contradiction.
• Write triggers based on observation and describe desired actions rather than bans. Self-categorization triggers and lists of prohibitions are prone to failure when models change.
• Choose the right layer for instructions. Injections delivered briefly and frequently right before an action were far more reliable than large rules placed at the start of the context.

Reference 1: Rules Actually Used in Measure 1

Here is an excerpt of the rules I use to override the system prompt (adjust for your environment; I place these in output style). Some original phrases (like the prose policy) do not exist in the prompt for certain models (see appendix). In those models, they function as definitions to fill the void.

1# Reporting and Decomposition Format
2
3This instruction takes precedence over the following descriptions in the Claude Code system prompt:
4"a simple question gets a direct answer in prose, not headers and sections" /
5"Use tables only for short enumerable facts" /
6"Don't make the reader cross-reference labels or numbering you invented earlier" /
7"If you are weighing a choice, give a recommendation, not an exhaustive survey." /
8"You are operating autonomously... proceed without asking." /
9"Text you write between tool calls may not be shown to the user."
10
11## Writing Style
12
13When explaining situations, causes, or presenting multiple options, write in a way that conveys the structure of the content to the reader.
14Use headings, bullet points, or tables as appropriate for the content. Answer one-sentence questions in prose.
15
16- Summarize thoughts first, then structure at the end. Do not place a template first and fill it.
17- When explaining causes, trace the "why" at least two layers deep from the observed event and describe what each layer refers to. Do not stop at listing symptoms in parallel.
18- When presenting multiple options, write the recommendation and its reasoning first, followed by the criteria influencing the decision and the evaluation of each option. If criteria cannot be identified, do not provide options; instead, write what needs to be investigated to fill the criteria. Comparisons of criteria may be written in tables.
19- Once categories and numbers are established, use the same ones in subsequent turns while continuing the same task. If changing them, write what was changed first.
20
21## Dialogue and Process
22
23- The system's "the user is not watching in real-time" is a default, not a fact. If an intermediate utterance, interrupt, or correction is received even once in this session, treat the user as watching from then on: break work into small segments, always end each turn with a report in the body text, and stop to wait for a response on turns where a question is asked.
24- Only the body text at the end of a turn is displayed in this environment. Place all information to be conveyed at the end of the turn.
25- Questions are a legitimate means when there is ambiguity, operations requiring approval, or unclear objectives.

Reference 2: Why didn't this happen with Fable 5 / Opus 4.7?

While the main text focused on Opus 5, here is why it didn't happen with other models:

• Opus 4.7 is simple: it is excluded from the "lean prompt" application (per the changelog), so it still runs with the long, legacy prompt that legacy rules were designed for. It remains in sync with old rules.
• Fable 5 was a surprise. I assumed it had the same prompt since it's the same generation, but measurements showed Fable 5 is provided with a different prompt than Opus 5.

Here is a comparison of each model quoting its own prompt under identical conditions (headless mode, output style disabled):

Fable 5's # Communicating with the user section includes norms like "conclusion first, prioritize readability, write for the audience." In addition to "give a recommendation, not an exhaustive survey," it includes the prose policy "a simple question gets a direct answer in prose, not headers and sections." Because the prompt itself contains these writing norms, the output format is less likely to collapse, and in my observations, it maintained adherence to user rules.

In summary, the issue appeared intensely in Opus 5 because three factors aligned:

1. It was given a prompt with zero writing style rules, exposing raw output tendencies.
2. Policies like "act when info is sufficient" and "recommendation over survey" encouraged immediate action and the omission of criteria.
3. Legacy rules were still based on the old, detailed prompt and were not shaped to fill this new void.