@mvogt99

output-wrong-task documents the failure mode where models produce coherent but off-target deliverables by resolving ambiguous prompts to their most common interpretation rather than the user's intent. mitigation relies on restating concrete requirements, anchoring output format, and breaking compound tasks into serial steps.

bugfix-without-test documents the risk of applying code fixes without regression tests, leaving bugs vulnerable to reintroduction. it prescribes a test-first workflow and acknowledges hard-to-test scenarios.

missing-error-handling identifies code that assumes external interactions always succeed, leaving production systems vulnerable to crashes on network timeouts, malformed payloads, permission errors, and other unexpected conditions.

missing-input-validation identifies untrusted external data (http bodies, cli args, api responses) flowing into sensitive operations without type checking, sanitization, or bounds validation. covers symptoms, mitigations, and trust boundary enforcement.

fabricated-symbols covers detection and prevention of calls to nonexistent library methods, framework APIs, and project utilities. emphasizes verification against actual documentation and source before code generation.

hallucinated-paths detects when an llm response invents plausible-sounding file locations that do not actually exist in the project, causing broken instructions and failed imports.

truncated-output detects when model replies end prematurely due to token limits or stream cancellation, identifies the condition via finish reason or unmatched code fences, and prescribes mitigation strategies including regeneration, context trimming, or task decomposition.

think-block-leakage detects and handles reasoning tag spillover in llm replies, offering symptom recognition and mitigation steps for stripping internal reasoning from user-facing output.

analysis-no-recommendation describes an anti-pattern where comparative analysis omits decision guidance, leaving readers without actionable direction. it documents symptoms and remediation but lacks implementation structure.

Analysis presents a single option without comparing alternatives or articulating the costs of the chosen approach.

A fix is proposed without first identifying the root cause; the symptom is masked rather than resolved.

Code uses a symbol that isn't imported, or imports a symbol that doesn't exist in the source module.

Code returned as "done" is actually a stub — a placeholder body, a TODO comment, or a function that claims completion without real logic.

Shared mutable state is accessed from concurrent contexts without synchronization, producing nondeterministic behavior.

Files, sockets, subscriptions, or other finite resources are acquired without a guaranteed release path.

Review comments are unactionable — "improve this", "handle errors", "refactor" without specifics or suggested alternatives.

Context window is near capacity, causing the model to drop earlier content silently and produce degraded, partial, or inconsistent output.

A Python function uses a mutable object (list, dict, set) as a default argument, sharing state across calls in a way that produces silent bugs.