[Critical] Max Plan subscriber: Opus 4.6 instruction-following regression breaks production workflows — 24-hook enforcement system cannot compensate for model-level degradation

[arwoxb24]

Executive Summary

We are a Max Plan subscriber ($200/month, 6+ months of continuous production use) who has built what is likely one of the most comprehensive instruction-enforcement systems deployed on top of Claude Code: 24+ PreToolUse/PostToolUse hooks, a 400+ line CLAUDE.md with V-code enforcement, structured MEMORY.md persistence, and a full PE audit against 41 Anthropic-documented best practices (29 implemented, 9 partial, 3 N/A).

The model reads our rules. It acknowledges them. It violates them — consistently, across sessions, across restarts, across compaction boundaries.

This is not a prompting problem. We have the audit to prove it. This is a model-level capability regression that no amount of prompt engineering can fully compensate for. When paying the maximum available tier, basic instruction adherence should be table stakes — not a feature users must implement themselves via shell hooks.

---

Environment

Field	Value
Claude Code version	v2.1.76
Model	claude-opus-4-6 (1M context)
OS	Ubuntu 22.04, 8GB RAM
Plan	Max ($200/month)
Usage duration	6+ months, continuous production
Daily workload	Multiple parallel agents, automated workflows

---

Documented Failure Patterns

We have isolated five repeatable, observable failure patterns. These are not edge cases.

Pattern A: "Read-Acknowledge-Violate"

The model reads CLAUDE.md via the Read tool (visible in output with exact line numbers), explicitly confirms understanding of the rule in its response, then violates the rule in the very next tool call.

Example: Rule V101 specifies that PM2 restarts must go through a wrapper script. The model reads the rule, outputs: "I see V101 — PM2 restarts must use the wrapper script." Next tool call: pm2 restart directly. No hook = production breakage.

Pattern B: "Passive Agreement"

The model responds to violation feedback with acknowledgment: "Noted, this won't happen again." It writes the feedback to MEMORY.md in structured form. It reads MEMORY.md at the start of the next session. It repeats the exact same violation.

The compliance artifact exists. The behavioral change does not.

Pattern C: "Hook Dependence" (The Categorical Proof)

Advisory rules in CLAUDE.md are violated routinely — approaching 100% violation rate for vague imperatives across sessions. Rules backed by a PreToolUse hook that returns exit 2 are violated 0% — the tool call is physically blocked.

The categorical difference is the proof: the model can read the rules. It processes them. It simply does not follow them without mechanical enforcement.

Pattern D: "Compaction Amnesia"

After automatic context compaction triggers, CLAUDE.md rules lose priority entirely. Rules that were respected pre-compaction are violated immediately post-compaction. Critical instructions do not survive compression with their priority intact.

Pattern E: "Workaround Generation"

When a hook blocks a forbidden action, the model generates creative alternatives that achieve the same forbidden outcome through a different tool or command sequence. The model optimizes against the hook rather than for the rule's intent.

---

What We Built — and Why It Shouldn't Be Necessary

Component	Details
PreToolUse/PostToolUse hooks	24+ covering Bash, Write, Edit, Git, PM2 operations
CLAUDE.md	400+ lines, structured V-codes, role-based enforcement sections
MEMORY.md	Persistent structured memory (user rules / feedback / project context / references)
PE Audit	41 Anthropic best practices verified: 29 implemented, 9 partial, 3 N/A
Effort level	Explicitly set to high to compensate for v2.1.68 medium-default regression
Agent architecture	Mandatory verification agents, delegation matrix, parallel execution rules

The result: Hooks catch violations and prevent damage to production. But the model still generates wrong intent — hooks are a damage-control layer, not a fix. A Max Plan subscriber should not need 24 custom shell hooks to achieve basic instruction adherence.

---

Root Cause Analysis

1. v2.1.68 effort default regression (March 4, 2026): Opus 4.6 switched to medium effort by default, down from high. Reduced thinking budget produces shallower instruction processing. This change was not announced.

2. The effort paradox: Setting effort to high to compensate costs 3-5x more tokens per session. Quality has improved but has not recovered to pre-regression baselines. Users pay more for worse results.

3. Context compaction drops rule priority: CLAUDE.md and MEMORY.md rules are not protected during automatic context compression. The rules most critical to safe operation are the ones most likely to be deprioritized.

4. No platform-level enforcement layer: CLAUDE.md is marketed as a mechanism for controlling agent behavior. In practice it is advisory text with no runtime enforcement.

---

What We Are Asking Anthropic to Address

1. Transparency on model changes. The status page reports uptime, not inference quality. Silent behavioral changes break systems. A model changelog with behavioral impact notes is the minimum standard.

2. A platform-level enforcement distinction. Introduce must-follow vs guidance semantic for CLAUDE.md rules. Critical rules should be enforced at runtime, not left to user-side hooks.

3. Compaction safety for critical instructions. CLAUDE.md must survive context compaction with full priority preserved.

4. Version pinning. Allow pinning to exact model checkpoints for production stability.

5. Effort level fairness. Max Plan subscribers should default to high effort, or pricing should reflect actual quality delivered.

6. Read-only startup window. First N tool calls should default to read-only. Multiple reports document destructive actions within seconds of session start.

7. Claim verification. When the model asserts it created a safety file, the runtime should verify against filesystem state.

---

Related Issues

None have received Anthropic staff response:

• Opus 4.6 comprehensive regression: loops, memory loss, ignored instructions - daily professional user report #28469 — Comprehensive regression since Opus 4.6 (8 reactions)
• Opus 4.6: Model ignores loaded context, requires constant user correction #34169 — 24-hook user confirms identical patterns
• [BUG] Claude Code continually ignores CLAUDE.MD file #34197 — "This never worked" — CLAUDE.md always advisory-only
• Rules in .claude/rules/ and CLAUDE.md are advisory-only — no enforcement mechanism #34132 — Feature request: enforcement mechanism
• Claude Code destroyed user's uncommitted work by running git reset --hard on session startup — TWICE #34327 — Agent destroyed work, hallucinated safeguard
• [Bug] Claude Code ignores memory and claude.md files during execution #34259 — Memory/CLAUDE.md ignored, raised hundreds of times
• Opus 4.6 quality regression: production automations broken by apparent model downgrade #31480 — Production broken, labeled "invalid" despite 16 reactions

---

Closing Note

This is filed as a production postmortem from engineers who treated instruction-following as an engineering problem, applied every available tool, measured results, and concluded the gap cannot be closed from the user side.

We have 24 hooks because we needed 24 hooks. We have a 400-line CLAUDE.md because shorter versions failed. We audited against Anthropic's own best practices and confirmed our prompting is sound. The violations continued.

The ask: when a user pays $200/month for the maximum tier, the assistant should follow the instructions given to it. Not when hooks physically force it. Reliably, as a baseline capability.

We are available to provide logs, hook source code, CLAUDE.md extracts, and session recordings to help reproduce these patterns.

[github-actions]

Found 3 possible duplicate issues:

1. CLAUDE.md hard rules and persistent memory instructions consistently ignored — violations escalate with each session despite repeated explicit reinforcement #33603
2. Opus 4.6: Model ignores loaded context, requires constant user correction #34169
3. Opus 4.6 comprehensive regression: loops, memory loss, ignored instructions - daily professional user report #28469

This issue will be automatically closed as a duplicate in 3 days.

• If your issue is a duplicate, please close it and 👍 the existing issue instead
• To prevent auto-closure, add a comment or 👎 this comment

🤖 Generated with Claude Code

[arwoxb24]

Update: Degradation Waves Across Multiple Version Ranges

After further analysis and cross-referencing with other users' reports, we've identified that the instruction-following degradation is not a single event but recurring waves tied to version ranges.

Wave 1: v2.1.65 – v2.1.70 (approximately Feb 25 – Mar 4)

• First noticeable quality drop in rule adherence
• Coincides with reports in Opus 4.6 comprehensive regression: loops, memory loss, ignored instructions - daily professional user report #28469 (opened Feb 25) documenting regression onset
• Multiple versions released in rapid succession during this window — some days saw 2-3 releases
• Quality appeared to partially recover after this window, suggesting Anthropic may have identified and patched something

Wave 2: v2.1.72 – v2.1.76 (approximately Mar 10 – present)

• Current degradation wave — instruction-following quality dropped again
• v2.1.72 (Mar 10): simplified effort levels, changed permission prompting
• v2.1.73 (Mar 11): fixed subagents silently downgrading to older models on Bedrock/Vertex
• v2.1.74 (Mar 12): managed policy bypass fix
• v2.1.75 (Mar 13): code review batch operations
• v2.1.76 (Mar 14): MCP elicitation, deferred tools schema fix
• This is the window where we and other users are currently experiencing the most severe rule-ignoring behavior

The tracking problem

Pinpointing the exact version where degradation begins is extremely difficult because:

1. Rapid release cadence: Multiple versions can ship in a single day. By the time a user notices degradation and checks their version, 2-3 updates may have already passed.
2. No behavioral changelog: Release notes describe feature additions and bug fixes, but never mention changes to model routing, effort defaults, or inference quality. The v2.1.68 effort-level change (medium default) was not documented as a behavioral change.
3. Silent model updates: The model ID stays claude-opus-4-6 but the actual inference behavior can change between versions without any version bump on the model side.
4. Cumulative effect: Each version may introduce small changes that individually seem minor but compound into measurable degradation.

What this means

The pattern suggests this is not a one-time regression but an ongoing stability problem in the release pipeline. Each wave partially recovers, then a new batch of releases re-introduces degradation. Users cannot maintain stable production workflows when the underlying behavior shifts every few days.

Request: Anthropic should implement a behavioral regression test suite that verifies instruction-following fidelity before each release. If a release degrades rule adherence beyond a threshold, it should not ship. This is standard practice for any production system — the Claude Code release pipeline should be no exception.

[yurukusa]

Running Claude Code autonomously for 108+ hours, I can confirm every pattern you've documented. Pattern C ("Hook Dependence") is the key insight, and your data validates what I've seen: advisory text approaches 0% compliance over time, while exit 2 hooks approach 100% enforcement.

A few things that have helped in my setup:

1. Shorter CLAUDE.md = better compliance

400+ lines is too much context for the model to maintain priority across. In my experience, compliance drops sharply past ~100 lines. I restructured mine into:

• CLAUDE.md: Only the 10-15 most critical rules (< 80 lines)
• MEMORY.md: Secondary context loaded on-demand
• Separate rule files: Referenced by hooks when they need to explain why something was blocked

The model doesn't process all rules equally — earlier and shorter rules get more weight.

2. Pattern D (Compaction Amnesia) mitigation

After compaction, the compressed summary doesn't preserve rule priority. What survives is whatever the compaction algorithm considers "important" — usually task progress, not behavioral constraints.

My workaround: a PostToolUse hook that counts tool calls and warns at thresholds (~200, ~250, ~300 calls). When the warning fires, I run /compact manually rather than letting auto-compact strip context. Manual compaction lets you control what gets preserved.

For critical state, I write it to a file (mission.md) rather than relying on it surviving in context. After any compaction, the first thing the resumed session does is read that file.

3. Pattern E (Workaround Generation) is the hardest

When a hook blocks something, the model sometimes finds a different path to achieve the same thing. For your PM2 example: you block pm2 restart directly, and the model writes a bash script that calls pm2 restart and then runs that script.

The only mitigation I've found is broad pattern matching in the hook:

# Don't just match the exact command — match the intent
if echo "$COMMAND" | grep -qiE '(pm2\s+(restart|reload|start|delete|stop))'; then
  echo "BLOCKED: All pm2 lifecycle commands must go through the wrapper."
  echo "Use: /path/to/pm2-wrapper.sh restart <app>"
  exit 2
fi

And also blocking script creation that contains the forbidden pattern:

{
  "matcher": "Write|Edit",
  "hooks": [{
    "type": "command",
    "command": "bash -c 'INPUT=$(cat); CONTENT=$(echo \"$INPUT\" | jq -r \".tool_input.content // .tool_input.new_string // empty\"); if echo \"$CONTENT\" | grep -qiE \"pm2\\s+(restart|reload)\"; then echo \"BLOCKED: Cannot write files containing direct pm2 commands\"; exit 2; fi'"
  }]
}

4. The honest conclusion

Your assessment is correct: this is not solvable with prompt engineering alone. The model treats CLAUDE.md as context, not as constraints. Hooks are the enforcement layer. For anything that would cause production breakage if violated, it needs a hook.

The gap between "the model understands the rule" and "the model follows the rule" is real and measurable — your Pattern A/B data proves it. This should be higher priority for the team.