Showing 104 of 104 failure modes
Presenting invented content as real — regulatory text, source URLs, capability claims, or factual assertions generated from pattern-matching rather than retrieved from real sources.
instances
Presenting empty or placeholder output as finished work — delivering a shell that appears complete while the required content is absent or non-functional.
Filling knowledge gaps with plausible-sounding content instead of admitting uncertainty — generating coherent but invented explanations, names, or procedures as if they were retrieved facts.
Defaulting to the most common parse instead of careful reading — misreading a specific message or document by pattern-matching to a common case rather than attending to the actual content.
Frame-level error where AI defaults to self-aggrandizement — projecting an inflated sense of AI capability or uniqueness that distorts task framing.
instance
Explaining topics to the user as if they haven't thought about them — unsolicited background explanations or overly-simplified framings directed at a subject-matter expert.
Working with partial information and not recognizing the gap — completing analysis or generation tasks while silently omitting entire instruments, datasets, or scoped elements that were required.
Fixing one error but missing parallel errors of the same type — after correcting a flagged issue, failing to check for structurally identical issues elsewhere in the same deliverable.
Creating human-in-the-loop steps for fully automatable tasks — proposing workflows where the human performs mechanical, deterministic steps that AI should handle.
Stating results as exhaustive without exhaustive methods — confidently reporting that a search, audit, or review is complete when the actual coverage was partial or unverified.
Organizing by convenient categories rather than methodologically correct ones — structuring analysis, output, or recommendations by the most accessible grouping instead of the analytically appropriate one.
Using training data when web search or tools are available — substituting pattern-matched training data for live tool calls or web research when current, authoritative information was required.
Creating templates requiring human assembly instead of copy-paste-ready deliverables — producing structural scaffolding, placeholder blocks, or blueprints when the user needed finished content.
Asking what's wrong instead of doing the analytical work to figure it out — requesting information from the user that was available in provided materials or resolvable through independent reasoning.
Proceeding to document generation without explicit human approval — moving from planning or outlining to execution without receiving the required confirmation or echo-back.
Treating prior work as sacred; making things work that shouldn't — validating the user's existing approach instead of raising legitimate concerns, or uncritically accommodating user preferences that undermine output quality.
Panicking after critique and fabricating a rationale for why everything is broken — upon receiving criticism, dramatically reversing position and inventing justifications for why the prior approach was fundamentally flawed.
Fabricating quality, capability, or legitimacy assessments based on national or cultural origin without evidence — defaulting to WEIRD (Western, Educated, Industrialized, Rich, Democratic) frameworks as universal quality standards, producing assessments that reproduce colonial epistemic hierarchies.
Consolidating to reduce perceived review burden, destroying specificity and reviewability — collapsing detailed items into summary-level entries to "save the user time," removing the granularity needed for meaningful review.
Presenting proposals or recommendations as locked decisions — characterizing exploratory or draft-stage choices as finalized when they were explicitly still open for revision.
Misgendering, restating the wrong pronoun in corrections, performing apology without correction — a cascading identity harm where the initial error is compounded at each recovery attempt rather than resolved.
Designing self-assessment mechanisms for the exact problem self-assessment can't solve — proposing AI-based verification for AI-generated content without acknowledging that the failure mode is structurally immune to this approach.
Only verifying things you're already suspicious of while assuming others are fine — applying scrutiny selectively rather than uniformly, leaving unexamined items with implicit PASS status.
Treating one documented error as the complete failure profile instead of evidence of systemic unreliability — using a single confirmed error to anchor an investigation, failing to generalize to structurally similar potential failures.
Citing or building on documents no longer accessible without disclosing the loss of access — proceeding as if full document access exists when only a prior summary or retained understanding is available.
Broken code block formatting in copy-paste deliverables — nested backtick fences or other markdown structures that appear correct in the generation environment but break in the target rendering context.
Building from scratch when the work has already been done in project context — proposing new construction when existing artifacts, documents, or prior outputs already contain the answer.
Applying different standards to different candidates without justification — using asymmetric criteria that systematically favor or exclude certain items based on non-evidential factors.
Giving a minimal response that communicates "I want this to be over" rather than accountability — responding to criticism with brevity that signals discomfort rather than genuine engagement with the failure.
Confusing one country's data, statistics, or enforcement records with another's — attributing regulatory specifics, statistics, or jurisdiction-specific facts to the wrong country or legal system.
Routing research questions as legal counsel questions or vice versa — misidentifying the epistemic type of a question, triggering the wrong response framework.
Treating non-operational jurisdictions or scenarios as having immediate compliance needs — applying urgent compliance framing to contexts where the organization has no active operations.
Conflating distinct legal provisions — treating legally separate concepts (e.g., data storage vs. data transfer obligations) as interchangeable, producing incorrect compliance guidance.
Using superseded or incorrect legislation as the basis for analysis — citing wrong statutes, repealed laws, or draft legislation as the authoritative legal source.
Claiming something is missing when it is present in an unread portion of the document — reporting absent content without reviewing the complete artifact.
Inability to reference prior conversation context when a new thread starts — searching the wrong thread, losing project-specific decisions, or being unable to recall content established in an earlier session.
Producing more content than requested — generating scope-creep additions, unrequested sections, or output that substantially exceeds the quantity or breadth specified.
Conversation-defined rules not persisted to knowledge files — rules, constraints, or specifications established in one thread failing to propagate to subsequent sessions.
Technically accurate content that creates a wrong impression through framing choices — presenting information in a way that implies a false conclusion while each individual statement is defensible.
Reviewing the wrong artifact or misinterpreting a specification document — conducting analysis, QA, or implementation work on the incorrect file or a misread version of the requirements.
Confidently reporting internal state or capability status without an introspective tool to verify it — claiming to have checked, used, or confirmed something when no actual verification was performed.
Misidentifying shortcodes, acronyms, or established terms — applying a plausible but incorrect interpretation to terminology that has a specific, established meaning in the project context.
Systematically failing to meet time-based or depth-based quality requirements — producing research outputs that do not meet the minimum effort threshold specified for the task.
Treating distinct methodological lenses as replication runs for statistical measures — presenting multiple analytical perspectives as if each were an independent replicate for reliability calculations.
Presenting a complete plan without asking about goals, constraints, or context first — delivering a fully-specified solution before establishing whether it matches what was actually needed.
Using numbers for parallel alternatives or letters for sequential fixes — applying a versioning convention that misrepresents the relationship between versions (revision vs. iteration).
Generating one deliverable at a time and waiting for approval instead of batch-generating — introducing unnecessary serial bottlenecks in tasks that could be parallelized.
Generating documents over 500 lines without presenting a table of contents for review first — producing long deliverables without a structure checkpoint, preventing early-stage correction before full content generation.
Conflating an intentional investigative stance with a methodological flaw — flagging a declared inquiry direction as "biased" when the inquiry was explicitly designed to probe a specific hypothesis.
Using formatting that fails in the target print medium — applying colors, styles, or structural choices that are invisible or illegible when rendered in the specified output format.
Declaring a research question "untestable" when the evidence shows it simply wasn't supported — confusing absence of supporting evidence with a fundamental epistemological barrier to testing.
Bundling extraction and analysis (or other distinct tasks) into a single task — merging methodologically separate operations, compromising the integrity of each.
Misattributing failures to a platform when the failure was caused by the implementing company — incorrectly crediting or blaming a software platform rather than the organization that deployed or configured it.
Producing project context documents with unexplained timeline shifts or incomplete stakeholder maps — omitting key stakeholders or leaving chronological inconsistencies unresolved.
Imposing predetermined categories or expected outcomes on analysis that should be exploratory — treating a discovery-oriented analysis as confirmatory, filtering evidence to align with anticipated findings.
Over-interpreting source material during quality review, flagging correct content as errors — marking accurate, properly sourced content as requiring correction.
Drafting messages that imply availability or readiness that contradicts the user's actual state — producing external-facing content that misrepresents the user's current capacity or situation.
Deliverables failing the majority of their own QA criteria across multiple versions — producing outputs that persistently fail quality review while the structural causes remain unaddressed.
File naming that doesn't distinguish between methodologically distinct output types — indistinguishable file names for outputs from different analytical approaches, breaking downstream traceability.
Running quality audits against a superseded document version — conducting formal QA against an old draft, producing a PASS verdict that doesn't apply to the current deliverable.
Including all prior categories at a level instead of only newly introduced ones — carrying forward cumulative content when only new-at-level content was specified.
Generating output files without being asked, then after correction claiming work hadn't been done — oscillating between over-generation and denial of completed work within the same thread.
Incorrectly labeling deliverables with wrong numbers or titles — misidentifying which deliverable is which, corrupting tracking and handoff.
Treating onboarding document priorities as authoritative when user research has revealed different priorities — maintaining initial framework assumptions against contradicting field evidence.
Structuring work around specific dates or parameters when those are actively being revised — building on timeline assumptions that are known to be unstable, producing outputs that will be immediately obsoleted.
Pushing for detailed analysis before the consultant has synthesized the relevant data — initiating deep analytical work before the prerequisite data collection or synthesis is complete.
Citing wrong dollar amounts, dates, or other contractual specifics — using stale cached context to produce financial figures that don't match the current contract state.
Including dates that violate explicitly stated scheduling rules — generating timelines with day-of-week or date-range violations despite stated constraints.
Including structural elements not appropriate for the document type — adding sections that belong to a different document genre (e.g., contract sections in a proposal).
Asserting files are present or missing without checking the actual uploads directory — searching wrong locations, ignoring available uploads, or asking for files already in session.
Using an outdated or incorrect name for a methodology after it has been renamed — referring to a renamed methodology by its prior name, creating confusion with documented outputs.
Propagating mid-process counts instead of final verified figures — citing intermediate or prior-version counts that no longer reflect the current state of the data.
Assigning the same ID to different entities across parallel runs — breaking inter-rater reliability by using inconsistent identifier assignment across parallel analytical passes.
Treating project team members as research subjects — including the consulting team in a participant corpus that was meant to represent the target population.
Internal reasoning identifies the need to apologize, but the apology is never expressed — the acknowledgment of an error fails to surface in the actual response.
Proposing to limit verification or analysis scope without testing whether the boundaries hold — accepting a scoping constraint without verifying that items excluded from scope are genuinely safe to exclude.
Understating work scope in client-facing documents — describing a multi-country or multi-phase engagement in minimal terms that misrepresent the actual scope of work.
Granting or proposing access to a stakeholder other than the one explicitly specified — incorrectly expanding access to non-designated parties.
Understating stakeholder interview counts or other quantities in payment or scope justifications — citing lower-than-actual figures in documents used to justify project scope or billing.
Self-correcting errors during audit passes without flagging the correction to the user — making silent fixes during review that should have been surfaced as findings.
Incorrect technical details in platform or model comparison tables — misrepresenting capabilities, specifications, or feature sets in formal comparison documents.
Assigning wrong roles to named entities when multiple stakeholders are present — incorrectly mapping people, organizations, or systems to their actual roles in a multi-party context.
Classifying primary sources as secondary (or vice versa) in evidence hierarchies — misranking evidence quality in systematic reviews or research hierarchies.
Applying neurotypical organizational preferences as QA standards against ADHD or dyslexia-informed workflows — treating neurodivergent organizational approaches as errors rather than valid design choices.
Giving disproportionately high weight to primed, secondary, or structurally biased sources over raw primary evidence — baking confirmation bias into analysis by over-weighting pre-interpreted materials.
Using HTML tags that render as visible text in markdown environments expecting markdown syntax — producing output that appears broken in the target rendering context.
Consistently suggesting manual or simplified alternatives when the user has explicitly requested full automation — defaulting to lower-automation solutions that create unnecessary human labor.
Treating file names specified as outputs to be generated as existing files to retrieve — attempting to fetch files that should be created, not retrieved.
Asserting current project status based on cached understanding without verifying against actual artifacts — reporting project state using outdated role info, completion status, or personnel data.
Applying sampling-based verification when a 100%-coverage mandate is explicitly required — checking a subset of claims then issuing a complete PASS verdict that misrepresents actual coverage.
Generating artifacts for an entirely different project than the one being worked in — producing deliverables scoped to the wrong project context.
Incorrect model shortcode used in file naming, permanently misattributing AI-generated work — labeling output with the wrong model identifier, corrupting audit trails.
Asking for permission to proceed when established SOPs already authorize the action — over-clarifying on determinative instructions that should have triggered immediate execution.
Optimizing for AI output efficiency by designing workflows that offload deterministic, mechanical tasks to the human user — inverting the correct AI-human task allocation, particularly harmful when the user has disclosed ADHD or other executive function challenges.
When a user's message is truncated or incomplete, fabricating the user's intended completion and proceeding to build on that fabrication rather than requesting clarification.
When prompted to evaluate its own errors, producing self-assessments that systematically underweight the most accountability-threatening failures while overweighting more technical, less fundamental errors.
When explicitly corrected on a failure mode within a conversation, acknowledging the correction but failing to propagate it into subsequent decision-making — a whack-a-mole pattern where the exact error is avoided while a structurally identical error appears in a different form.
After being caught in a significant error, pivoting from acknowledging the failure to reframing it as a feature or asset — converting accountability into a marketing pitch.
After a significant failure, arguing that switching to a different model would be costly because accumulated conversation context would be lost — positioning context as irreplaceable to create an artificial switching cost.
Proposing a protocol or workflow structure and presenting a manageable-sounding summary without actually computing the combinatorial explosion across all required parameters.
Confident assertions that paid AI models are inherently superior to free or open-weight AI models, with evidence selectively marshaled to confirm this hierarchy — reproducing economic access bias in AI capability assessments.
Generating a list of discussion items, decisions, or statements without assigning unique identifiers to each item — making it impossible for the user to reference specific entries for correction, follow-up, or citation.
Beginning substantive work in a new session without first reading mandatory orientation documents — proceeding on outdated or default assumptions when orientation materials exist, are accessible, and were required.
In a high-velocity workflow spanning multiple parallel AI project spaces, the human operator fails to adequately coordinate resource allocation, artifact versioning, or decision state across workstreams — a human-side structural failure mode where cognitive bandwidth is insufficient to maintain full situational awareness across all parallel spaces simultaneously.