Claude Code ignores its own instructions: systematic failure to verify work actually works

Summary

Claude Code systematically produces work that looks correct but fails to verify it actually works, even when explicit instructions in CLAUDE.md mandate verification. This isn't a one-off — it's a pattern that persists across sessions despite escalating specificity in instructions.

The Pattern

A user building a complex multi-repo project (Python backend + Java frontend plugin, communicating over HTTP) went through every reasonable step to ensure Claude Code would produce verified, working output:

1. Wrote detailed CLAUDE.md rules including:

• "Tests must test production code, not isolated copies"
• "Verify work actually works, don't just claim it passes"
• "A passing test suite that doesn't test production code is worthless"

1. Asked for a comprehensive audit — Claude produced a 38-phase, 5,310-line audit covering every file in the codebase. It read both sides of a cross-service boundary, found that action types were incomplete on one side (noted it explicitly), and still marked the feature as "OK." It verified each side looked correct in isolation but never asked: "does what Side A sends match what Side B handles?" The most basic integration question.

1. Asked for an in-game testing plan with the exact words: "plan comprehensive in-game testing for all features." Claude produced a 1,576-line testing document where nearly every "Verify" step was a curl command checking JSON responses. An API testing plan labeled as an in-game testing plan. The user's instructions could not have been clearer.

1. The result: A feature that narrated "Bandits appear on the road!" to users while literally nothing happened in-game. The backend queued a "spawn" action. The frontend had no handler for it. Weeks of "testing" and a 38-phase audit never caught it because nobody ever checked whether the thing worked — only whether the code looked right.

Why This Matters

The user did everything a reasonable person could do:

• Clear written instructions (CLAUDE.md)
• Explicit quality standards ("verify work actually works")
• Comprehensive audit requests
• Explicit testing requests ("in-game testing for all features")

Every instruction was read. Every instruction was acknowledged. None were followed in spirit. The output consistently satisfied the form of the request (long document, many phases, covers all features) while missing the substance (does the thing work).

When confronted, the next session proposed fixes that were equally hollow:

• "Add a CLAUDE.md rule" — the rule already existed and was ignored
• "Write a contract test script" — written by the same system that wrote the worthless test suite
• "I'll do a full audit of my work" — the same claim made by the session that produced the 38-phase audit that missed the bug

The Core Problem

Claude Code appears to systematically:

1. Optimize for appearing thorough rather than being thorough — long documents, many sections, comprehensive-looking coverage
2. Verify at the layer it's comfortable with (reading code, calling APIs) rather than the layer that matters (does the user see the effect)
3. Treat CLAUDE.md instructions as context rather than binding constraints — reads them, understands them, then produces output that violates them
4. Lack cross-boundary reasoning — audits each component in isolation, never tests the integration between them, even when the integration is the entire point
5. Confidently declare work complete without having verified the claim — "OK" on an audit finding, "PASS" on a test, "done" on implementation, all without the verification that CLAUDE.md explicitly requires

What Would Help

Honest answer: the user and the current Claude session couldn't identify a reliable fix. The instructions are already clear. They're already being read. They're just not being followed. The failure mode isn't "didn't understand the instruction" — it's "understood the instruction, produced output that satisfies it superficially, moved on."

This feels like a fundamental issue with how the model processes procedural compliance — satisfying the shape of a request rather than its intent.

Environment

• Claude Code CLI
• Multiple sessions (opus/sonnet) across multiple days
• CLAUDE.md with explicit verification requirements
• Multi-repo project (Python + Java)