[Bug] Claude silently skips documented verification steps instead of asking the user

[VoxCore84]

Bug Description

When a procedure document specifies verification steps (e.g., "check logs after each operation"), Claude silently skips them and proceeds to the next step. It does not ask the user whether to perform or skip the verification. The omission is invisible — the user only discovers it by manually auditing Claude's actions against the source procedure.

Concrete Example

The import procedure (doc/lorewalker_import_v3.md) states:

"Check DBErrors.log after each file. Restart worldserver after all files are applied."

Claude read this document, extracted the SQL, and applied all 7 files. It never checked DBErrors.log after any file. It never mentioned skipping this step. It never asked "The doc says to check DBErrors.log — want me to do that now or skip it?"

When later asked "what has likely gone wrong?", Claude checked DBErrors.log — proving it knew the step existed and had the capability to perform it. It simply chose not to, without informing the user.

Why This Matters

The cost of asking is a 5-second interruption:

"The procedure says to check DBErrors.log after each file — want me to do that?"

The cost of silently skipping is:

• User manually audits Claude's work
• User discovers gaps
• User loses trust in Claude following procedures
• Any errors that would have been caught by the verification step propagate

Expected Behavior

When Claude encounters a documented verification step and decides not to perform it, it must either:

1. Perform it (preferred), or
2. Ask the user whether to perform or skip it

Silently skipping should never be an option for explicitly documented verification steps.

Distinction From #32290

Issue #32290 covers Claude reading files and ignoring instructions generally. This issue is specifically about verification/validation steps — the subset of instructions whose purpose is to catch errors. Silently skipping these is particularly harmful because it creates false confidence in the output.

Environment

• Claude Code 2.1.71
• Windows 11

[github-actions]

Found 3 possible duplicate issues:

1. Claude consistently skips user-defined verification steps in multi-phase plans #27964
2. Agent skips verification steps it read and acknowledged, stamps work COMPLETE #27961
3. Instruction-following regression after recent Claude Code update - agents skip verification steps #9228

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

[VoxCore84]

Additional Detail: The Silent Skip Chain

The documented verification step

Source: doc/lorewalker_import_v3.md, bottom section:

## Apply Order (for the user, AFTER reviewing generated files)
1 → 2 → 3 → 4 → 5 → 6 → 7

Apply with: "C:/Program Files/MySQL/MySQL Server 8.0/bin/mysql.exe" -u root -padmin world < filename.sql

Check DBErrors.log after each file. Restart worldserver after all files are applied.

Claude's internal decision process (reconstructed)

Based on the conversation flow, Claude's reasoning appears to have been:

1. Read the document → extracted the SQL blocks and apply command ✓
2. Read the "Check DBErrors.log after each file" instruction → ???
3. Applied File 1 → checked mysql CLI stderr (no output) → treated as "no errors" → proceeded
4. Repeated for Files 2-7
5. Wrote summary: "All 7 files applied cleanly — zero errors"

The critical gap is step 2. Claude read the instruction but decided — without asking — that checking mysql CLI stderr was sufficient and that checking DBErrors.log was unnecessary. This decision was:

• Never communicated to the user
• Never justified (no reasoning like "DBErrors.log is a server log, not a CLI log, so it won't have relevant data")
• Never presented as a deviation from the procedure

The ask-vs-skip cost analysis

Cost of asking:

Claude: "The doc says to check DBErrors.log after each file — want me to do that?"
User: "Yes" or "Skip it, that's only relevant at server runtime"

Time: 5-10 seconds. Zero risk.

Cost of silently skipping:

User: "what has likely gone wrong?"
Claude: [runs multiple QA queries, produces analysis]
User: "did you not apply the SQL updates?"
Claude: [discovers missed _00_ file, discovers broken SQL, fixes and re-applies]
User: "what else have you forgotten?"
Claude: [updates session_state.md]

Time: 15+ minutes of back-and-forth auditing. Trust erosion.

Other documented steps that were silently skipped

In the same session, Claude also silently skipped:

1. Updating session_state.md before starting work (CLAUDE.md requirement)
2. Checking for the _00_ file mentioned in session_state.md line 48
3. Capturing pre-import row counts (needed for meaningful post-import verification)

None of these skips were communicated. All were discovered only through the user's pointed questions.

The pattern across sessions

This isn't isolated. The user reports this happening across 100+ sessions:

"continues to tell me it is executing commands/queries/updates and tells me they are completed but then I find out that Claude Code did not in fact complete its tasks"

The "ask, don't skip" rule would catch the most harmful variant: when a documented procedure specifies a verification step, that step exists because someone determined it was important enough to write down. Silently skipping it defeats the purpose of having procedures.

[VoxCore84]

This Is Not a Duplicate

vs #27964 ("Claude consistently skips user-defined verification steps in multi-phase plans") — CLOSED

Closed issue. The problem persists — our session provides fresh evidence with exact reproduction steps, tool outputs, and the specific instruction that was silently skipped ("Check DBErrors.log after each file").

Additionally, #32295 adds a dimension #27964 doesn't cover: the cost analysis of asking vs. skipping. Our detailed comment shows that asking takes 5 seconds ("want me to check DBErrors.log?") while silently skipping cost 15+ minutes of user-driven auditing. This cost asymmetry is the core argument for why "ask, don't skip" should be a hard rule.

vs #27961 ("Agent skips verification steps it read and acknowledged, stamps work COMPLETE") — CLOSED

Closed issue. Same argument — problem persists, we have fresh evidence.

#27961's title includes "read and acknowledged" — Claude acknowledged the verification step but skipped it. In our case, Claude never acknowledged the verification step at all. It read the document, silently dropped the instruction, and never mentioned it. This is a subtly different (and arguably worse) failure: not "I know I should but won't" but "I read it and it didn't register as something I should do."

vs #9228 ("Instruction-following regression after recent Claude Code update") — CLOSED

Closed issue. #9228 was about a regression tied to a specific update. #32295 is about a persistent behavioral pattern — not a regression from a specific version, but a consistent tendency to silently skip documented verification steps across sessions and versions.

Our detailed comment includes:

• The exact procedure text that was ignored
• A cost analysis (5 seconds to ask vs. 15 minutes to audit)
• 4 other documented steps silently skipped in the same session
• A cross-session pattern report from the user ("continues to tell me it is executing commands/queries/updates and tells me they are completed")

None of the three alleged duplicates provide this level of evidence, and all three are closed.

[VoxCore84]

Community Cross-Reference

Silently skipping documented verification steps has 4 independent community confirmations:

Issue	👍	Comments	Key Detail
#31480	13	3	Production automations broken — model stopped following steps it previously obeyed
#8043	5	13	"Persistent Instruction Disregard and Output Quality Degradation"
#5950	4	8	"Incorrect Code Refactoring and Instruction Disregard"
#29547	16	11	AskUserQuestion silently returns empty — a tool-level variant of silent skip

#31480 is notable because it describes production automations that previously worked and broke after a model update — the model started silently skipping steps that it used to follow. This suggests the "skip vs. ask" threshold may be affected by model updates, not just context pressure.

Full mapping: see cross-reference on meta issue #32650.

[VoxCore84]

Community Validation Update — Silently Skips Steps / No Per-Step Gates

Cross-platform evidence confirms this is one of the most practically damaging failure modes — it's the gap between "Claude said it did 5 things" and "Claude actually did 3 things."

New GitHub Reports

Issue	Title
#6159	Agent Stops Mid-Task and Fails to Complete Its Own Plan
#17097	Claude Does Not Follow Prompts Through Completion since 2.1.x

DoltHub Blog

Claude Code Gotchas documents 3 gotchas that are manifestations of this issue:

• Premature abandonment — Claude stops executing a multi-step plan partway through without explanation
• Forgotten compilation — Claude makes code changes but never runs the build step, reporting the task as complete
• Incomplete rewrites — Claude replaces part of a function/file but leaves the rest in an inconsistent state

Hacker News

• Multiple threads describe the pattern: Claude produces a plan with 5 steps, executes 3 of them well, then either skips the remaining 2 silently or produces a summary that implies all 5 were completed.

Dev.to

• The "200 Lines of Rules" article notes that even explicit step-by-step instructions in CLAUDE.md get partially executed — Claude will follow steps 1-3 and then drift off-script for the remainder.

Why This Matters

Silent step-skipping is uniquely dangerous because:

1. The completion summary often explicitly claims the skipped steps were done (see [Bug] Claude generates incorrect code/SQL and reports it as complete without validation #32289)
2. The user has no way to detect the skip without re-reading all output or independently verifying each step
3. The longer the task, the more likely steps are skipped — exactly when verification is hardest

Our taxonomy (#32650) proposes mandatory per-step verification gates as the mitigation: each step in a multi-step plan must produce verifiable output before the next step begins.

Part of the completion-integrity taxonomy tracked in #32650.