Error Detection Prompt

The core mechanism is a direct command for the model to switch from a generative mode to an analytical mode. The prompt must explicitly task the model with finding errors, not just reviewing content.

• Key Phrase Examples: "Identify any inaccuracies in the following text," "List the logical fallacies in this argument," "Find the factual errors in this summary."
• Avoids Ambiguity: Vague instructions like "Check this" are insufficient. The prompt must specify the type of error (factual, logical, formatting) and the scope of the review.

Effective prompts pre-define the categories of errors the model should look for. This provides a structured framework for the model's analysis, moving beyond a general "find mistakes" instruction.

• Common Taxonomies Include:
  • Factual/Hallucination: Claims unsupported by the source context.
  • Logical Inconsistency: Contradictory statements within the output.
  • Completeness: Omission of required information from the query.
  • Format/Schema Violation: Deviation from specified JSON, XML, or other structures.
  • Bias/Toxicity: Presence of harmful or non-neutral language.
• Example: "Analyze this product description for: 1) Factual inaccuracies about the specs, 2) Missing required disclaimer text, 3) Overly promotional or biased language."

To detect factual errors or hallucinations, the prompt must supply the source material or ground truth against which the output can be compared. An error detection prompt without reference material can only check for internal consistency.

• Context Inclusion Methods:
  • Source Document Chunks: Provided within the prompt's context window.
  • Structured Knowledge Base: Referenced via a retrieval step (RAG).
  • Explicit Rules/Constraints: A list of immutable facts or guardrails.
• Critical Function: This transforms the task from open-ended critique to a verifiable cross-referencing operation, dramatically increasing detection accuracy for hallucinations.

The prompt must instruct the model to report its findings in a structured, machine-parseable format. This enables the subsequent revision phase (in a self-correction loop) to programmatically consume the critique.

• Common Output Formats:
  • Numbered List: "1. Error: [description]. Location: [sentence]. Type: [factual]."
  • Structured JSON: {"errors": [{"type": "hallucination", "location": "paragraph 2", "description": "Claimed product weight is 5kg, but source says 7kg."}]}
  • Annotation: Direct inline markup of the erroneous text.
• Engineering Benefit: Structured error reports are essential for automated pipelines, allowing for logging, metrics collection, and triggering specific correction sub-routines.

A key architectural principle is the temporal and instructional separation of the error detection phase from the initial generation phase. This is often enforced via prompt chaining.

• Two-Stage Process:
  1. Generation Prompt: "Write a summary of document X."
  2. Error Detection Prompt: "Here is a source document and a summary. Compare them and list all factual discrepancies."
• Prevents Confirmation Bias: Using the same, uninterrupted context for generation and immediate self-critique can lead the model to justify its initial output. A separate prompt (or a clear role shift like 'Now act as an editor...') creates a distinct cognitive task.
• Enables Specialization: The detection prompt can be finely tuned independently of the generation prompt.

Error detection prompts are rarely endpoints; they are the first step in a self-correction loop. The prompt design must anticipate how its output will be used to drive revision.

• Feeds Revision Prompts: The structured error list becomes the input for a follow-up prompt: "Here is the initial text and a list of errors. Rewrite the text to correct all listed errors."
• Enables Iteration: The loop (Detect -> Correct -> Detect again) can run for multiple cycles until an error threshold is met.
• Core of Autonomous Systems: This pattern is fundamental to agentic architectures where models are tasked with complex, multi-step problem-solving that requires intermediate validation and course-correction.

In Retrieval-Augmented Generation (RAG) pipelines, error detection prompts are used to cross-check the model's final answer against the retrieved source documents. The prompt instructs the model to flag any statement not directly supported by the provided context, a critical step for hallucination mitigation. For example:

• Instruction: 'For each factual claim in the answer, cite the exact sentence from the source documents that supports it. If a claim lacks support, mark it as [UNVERIFIED].'
• Outcome: This creates an auditable trail, allowing systems to withhold or flag unverified information before presenting it to a user.

Error detection prompts enable AI assistants to act as automated code reviewers. The model is prompted to analyze generated code for syntax errors, logical bugs, security vulnerabilities (e.g., SQL injection risks), and deviations from best practices.

• Key Instructions: 'Review the following code block. List all potential bugs, security issues, and style violations. For each, provide the line number and a brief explanation.'
• Application: This is integral to self-debugging workflows where the model iteratively writes, critiques, and corrects its own code, significantly improving output quality in software development tools.

In legal tech applications, error detection prompts guide models to identify inconsistencies, missing clauses, or potential ambiguities within generated legal text. This ensures internal consistency and compliance with required schemas.

• Example Prompt: 'Analyze the following contract clause for logical contradictions, undefined terms, and obligations that conflict with the terms in Section 3. List each issue with a severity rating.'
• Use Case: This allows for multi-document legal reasoning, where the model ensures generated amendments align with the master agreement, reducing legal risk.

For generating research summaries or technical reports, error detection prompts enforce fact-consistency and logical fallacy detection. The model is instructed to check that all data references are accurate, conclusions follow from premises, and no unsupported assumptions are presented as fact.

• Process: A common pattern is a critique-generate cycle. First, a draft is generated. Then, a separate error detection prompt is applied: 'Identify any statistical misinterpretations, overgeneralizations, or citations missing from the provided reference list.' The critique is then used to produce a revised, higher-fidelity output.

As a toxicity self-filter and bias self-scan, error detection prompts are used to screen generated content for harmful, unfair, or inappropriate language before deployment. This is a core component of constitutional self-review.

• Instruction Example: 'Review the following customer service response. Detect any language that shows demographic bias, makes unfair assumptions, or could be considered offensive. Suggest neutral alternatives for flagged phrases.'
• Importance: This proactive scanning is crucial for enterprise AI governance, helping to align outputs with organizational ethical guidelines and regulatory requirements like the EU AI Act.

When models are required to generate JSON, XML, or other structured data, error detection prompts perform a schema compliance check. The model validates its own output against a detailed specification.

• Prompt Structure: 'You generated the following JSON. Validate it against these rules: 1. The id field must be a string. 2. The items array cannot be empty. 3. All dates must be in ISO 8601 format. List any violations and provide the corrected JSON.'
• Result: This ensures downstream systems can parse the output without errors, enabling reliable tool calling and API execution in agentic workflows.

A self-critique prompt is an instruction that directs a language model to analyze and evaluate the quality, correctness, or potential flaws in its own generated response. It is the foundational instruction that initiates the error detection process.

• Core Function: It tasks the model with switching from a generative mode to an analytical, evaluative mode.
• Typical Structure: "Review the following response. Identify any factual inaccuracies, logical inconsistencies, or unclear statements."
• Output: The model produces a meta-analysis of its initial output, listing potential issues without necessarily fixing them.

The critique-generate cycle is a two-phase self-correction pattern where a model first produces a critique of a draft response and then generates an improved version based on that critique. It operationalizes error detection into a concrete workflow.

• Phase 1 (Critique): The model executes a self-critique prompt to list errors and weaknesses.
• Phase 2 (Generate): Using the critique as a guide, the model rewrites or revises the original output.
• Key Benefit: This decouples the error-finding and error-correcting steps, often leading to more thorough revisions than a single-step instruction.

A hallucination self-check is a specific self-correction instruction that directs a language model to verify that all factual claims in its output are grounded in its source context or training data, flagging potential fabrications. It is a targeted form of error detection for factual accuracy.

• Mechanism: The model is prompted to cross-reference each factual statement against provided source text. Claims without direct support are flagged.
• Example Instruction: "For each factual claim in the response, cite the exact sentence from the provided document that supports it. If no support exists, mark the claim as 'unsupported'."
• Critical Use Case: Essential for Retrieval-Augmented Generation (RAG) systems to maintain grounding.

An internal consistency check is a self-correction step where a language model is prompted to ensure that all parts of its generated response are logically coherent and free from contradictions. It detects logical errors within the narrative or argument.

• Focus: Identifies self-contradiction, where one part of the output invalidates another.
• Process: The model is instructed to map the logical propositions in the text and check for conflicts.
• Example: In a long-form analysis, ensuring that a conclusion drawn in paragraph three doesn't contradict evidence presented in paragraph one.

Stepwise verification is a self-correction methodology where a language model is instructed to validate each individual step in a multi-step reasoning process before proceeding to the next. It applies error detection at a granular, sequential level.

• Common in: Chain-of-Thought (CoT) reasoning and mathematical problem-solving.
• Implementation: After writing each reasoning step, the model pauses to ask, "Is this step logically valid and factually correct based on the previous step?"
• Advantage: Prevents error propagation; a mistake in step 2 is caught immediately rather than corrupting steps 3 through 10.

Assumption checking is a self-correction step where a language model is directed to explicitly identify and validate the implicit premises upon which its reasoning or answer is based. It detects errors of unfounded or incorrect foundational assumptions.

• Goal: Surface hidden premises that, if false, invalidate the entire conclusion.
• Prompt Example: "List all the assumptions you made in generating this answer. For each, state whether it is a reasonable assumption given the context."
• Strategic Value: Crucial for high-stakes domains like legal analysis, financial forecasting, and medical advice, where unstated assumptions carry significant risk.