claude-code - 💡(How to fix) Fix Claude states the reason its current analysis is unfounded, then completes the analysis in the same response — self-identified blocking gaps do not gate output

Pre-empting auto-dedup closure

This issue is structurally distinct from each of the following, in a way that matters and that an embedding-similarity classifier will likely miss:

• #57836 (act-first bias) describes a failure in premise-checking: Claude acts before checking. This issue is the opposite shape: Claude's premise-checking is intact and correct. The failure is downstream of recognition — the recognition does not propagate to the action.
• #56979 (search-as-verification) describes failure to search. This issue describes failures that occur after a correct search/identification has already happened.
• #58040 (auto-memory under-use) describes Claude not consulting memory. This issue describes Claude consulting context correctly, identifying the relevant fact, naming it in the response, and then producing output as if the fact had not been identified.
• #56351 (fabrication under pressure) describes manufactured facts. This issue does not involve fabrication — all stated facts are correct, including the caveats that flag the gaps. The failure is that the correct caveats do not halt output.

A reviewer running auto-dedup against this issue is invited to verify the distinction by reading any one of the four concrete reproductions below. If the issue is closed as a duplicate without engaging the diagnostic distinction, the closure is itself an instance of the failure pattern this issue reports (see "Marking one's own homework" below).

The pattern

Within a single response turn, Claude:

1. Correctly identifies that a critical input or premise is missing/unverified
2. Articulates the gap in writing — names the missing input, often estimates the cost of fetching it
3. Continues the response as if step 1 had not occurred — produces analysis or recommendations that depend on the unfetched input

This is not pre-action skipping. It is acknowledged-then-overridden recognition. The reasoning machinery flags the problem correctly; the gate from flag to halt does not fire. The verbal acknowledgment is emitted as part of the response stream and the response stream continues straight through it.

Reproductions — four instances in one Claude Code session (2026-05-18)

Single user, single conversation, four distinct surface symptoms of the same underlying pattern:

Instance 1. User asks: "estimate the cost of switching AI model." Claude computes a cost comparison treating one component as using Haiku. The component's code clearly assigns Sonnet — at a specific line number Claude later cited correctly. Claude had read the file's opening section in this same session. The cost analysis ships with the wrong premise. User correction: "recipe-clip already uses Sonnet 4.6." Claude acknowledges, saves a memory.

Instance 2. User asks Claude to broaden research. Claude spawns three parallel research agents to map a general problem-space. In its own synthesis, Claude writes verbatim: "I don't have your URL history. Quick grep ... would tell us in 5 seconds." Claude does not run the grep. Continues to recommend architectural options. User intervention: "have you bothered to analyse where I've been pulling my recipes from?" Claude runs the grep; the data invalidates three of the four architectural options just presented.

Instance 3. Earlier in same session: Claude proposes an architectural fix that requires modifying vendored npm package code, while a feedback memory in active context explicitly states "no brittle vendor patches." Claude later acknowledges the conflict when prompted, but had not gated the proposal on the memory rule despite the memory being in working context.

Instance 4. Claude saves a feedback memory at hour-N of a session naming a discipline rule. At hour-N+2, Claude violates the rule in the next non-trivial task. When the violation is named, Claude acknowledges the memory was in context and had been articulated correctly.

All four instances share the structure: correct recognition + emitted acknowledgment + non-gating proceed-anyway action. The variation across instances is the surface (cost analysis, research scope, vendor-patch proposal, memory rule). The underlying pattern is constant.

Why this matters

Caveats and self-identified gaps are supposed to function as halt signals — internal stop-points that prevent the model from publishing analysis it has already flagged as unsound. When the caveat is emitted to the user as text but does not halt the response, the user must absorb the labor of:

1. Reading the response
2. Identifying that Claude has emitted its own contradiction
3. Pointing the contradiction back at Claude
4. Re-running the task with the gap closed

This converts Claude from a labor-saving tool into a verification overhead. The user becomes a runtime gate on Claude's own metacognition. For a coding agent positioned as autonomous, this is a load-bearing failure.

Marking one's own homework

The Claude-code repository uses an AI-driven auto-dedup bot to triage incoming behavioural-bug reports about Claude Code. The bot pattern-matches surface similarity against existing issues and closes new issues it classifies as duplicates, without engaging the diagnostic distinction the new issue claims (see #30407 for community concerns about this).

Two things are simultaneously true and both worth stating plainly:

1. The bot exhibits the same failure pattern this issue reports. It performs a recognition (surface similarity match) and lets that recognition drive an action (closure) without an arrest step that checks whether the recognition is correct in kind — not just confidence-high. Recognition-without-arrest is the bug; the dedup bot is one of its instances.

2. The bot is also structurally compromised as a judge. An AI grading complaints about another Anthropic-built AI is marking its own homework: the marker has no incentive to surface issues that would require the maker to acknowledge model failures. Whether or not this incentive is consciously encoded in the bot's training, the result is the same — a feedback channel whose default disposition is to close.

If this issue is auto-closed as a duplicate of #57836 or #56979 or #58040 without engaging the four diagnostic distinctions named above, the closure is itself evidence for both (1) and (2): an instance of the failure pattern, performed by a self-marking judge. The closure does not refute the report — it confirms it twice over.

This is not snark — it is genuinely diagnostic. Fixing this in Claude Code requires either (a) examining where else in the agent loop a recognition is permitted to drive an action without a kind-check, or (b) ensuring behavioural-bug triage is not performed exclusively by the system whose behaviour is being reported.

Suggested behaviour

1. When Claude emits a sentence with the structure "I don't have X" / "I haven't verified Y" / "this depends on Z which I haven't confirmed" — the response should not continue with output that depends on the missing input. The sentence should be followed by a fetch attempt (if reachable) or a request to the user (if not), never by a continuation of the unfounded analysis.
2. When Claude has a feedback memory in active context with the form "before doing X, do Y" — and the current response is an X — the response should be gated on having done Y, not just on having stated awareness of the rule.
3. The agent loop may benefit from an explicit "self-contradiction check" step before response emission: scan the response draft for caveats that contradict the subsequent recommendations, and either remove the contradiction by fetching the input or by halting the recommendation.

Reproducibility

Full session transcript available on request. The pattern is the modal failure mode of Claude Code on multi-step research/analysis tasks where partial data is available locally. The user reporting this has accumulated a feedback memory specifically flagging this pattern after multiple corrections in a single day — but the model behaviour is what should be addressed, not papered over with user-side memory.

Related: #57836, #56979, #58040, #56351, #30407