Completeness Verification

The first step is to parse the original user query or system prompt into discrete, actionable sub-tasks. The model identifies all explicit requests, implicit requirements, and boundary conditions.

• Explicit Instructions: Direct commands like "list," "compare," "explain."
• Implicit Requirements: Unstated but necessary components, such as providing definitions for technical terms when explaining a concept.
• Constraints: Specifications like length, format (JSON, bullet points), or perspective to adopt.

This creates a verification checklist the model uses to audit its own output.

Using the decomposed checklist, the model performs a gap analysis on its initial draft response. It scans for:

• Missing Components: Were all requested items listed or explained?
• Partial Fulfillment: Was a point addressed superficially when depth was required?
• Scope Creep: Did the response include irrelevant information that distracts from the core request?

This is a deterministic matching process, not subjective evaluation. The output is a list of identified gaps.

Based on the gap analysis, the model executes a targeted revision. This is not a full rewrite but a surgical edit to fill identified omissions.

Example: If the original prompt was "Explain the Transformer architecture, including the attention mechanism and layer normalization," and the initial draft only covered attention, the revision would selectively add a concise explanation of layer normalization, integrating it logically into the existing structure.

The goal is minimal sufficient completion, adding only what is missing to satisfy the checklist.

A final self-check ensures the revised output passes the original completeness checklist. This step guards against regression—where fixes for one gap inadvertently create another—and verifies integration quality.

• The model confirms each checklist item is now addressed.
• It checks for new inconsistencies or redundancies introduced during revision.
• The output often concludes with a meta-statement, e.g., "This response now addresses all components: A, B, and C."

This pass closes the self-correction loop, providing a verifiably complete answer.

Completeness verification is often paired with, but distinct from, fact-consistency or hallucination self-check instructions.

A robust self-correction pipeline may run both checks sequentially.

Completeness verification is typically encoded as a mandatory final step in a system prompt. For example:

codeCopy
You are a technical assistant. After generating your answer, you MUST perform a completeness verification:
1. Re-read the user's question and extract every sub-question and requirement.
2. Compare this list to your answer.
3. If any point is missing or under-explained, revise your answer to include it.
4. Output the final, verified answer.

This transforms it from an optional meta-cognitive act into a deterministic, auditable step in the model's reasoning process. It is a foundational technique in prompt architecture for reliable AI assistants.

This pattern instructs the model to extract a formal checklist from the user's query, then verify its response against each item. It is highly effective for complex, multi-part requests.

Example Prompt:

codeCopy
User Query: 'Summarize the key risks in the Q3 report and propose mitigation strategies for the top two.'

Instructions:
1. First, extract an explicit checklist of all required response components from the user's query.
2. Generate your initial answer.
3. Review your answer against the checklist. For each item, state whether it is fully addressed, partially addressed, or missing.
4. If any items are not fully addressed, revise your answer to complete them.

Key Mechanism: Forces the model to operationalize vague instructions into concrete, verifiable subtasks, transforming implicit expectations into an explicit audit trail.

This technique directs the model to first decompose the original query into discrete sub-questions, answer each separately, and then synthesize a final response while ensuring no sub-question is omitted.

Example Prompt:

codeCopy
Task: Provide a market analysis for solar panels.

Step 1: Decompose the request 'market analysis for solar panels' into 4-5 distinct, non-overlapping analytical dimensions (e.g., cost trends, regulatory landscape, key competitors, technological advancements, demand drivers).
Step 2: Write a concise paragraph addressing each dimension.
Step 3: Combine the paragraphs into a cohesive analysis.
Step 4: Review the combined analysis. For each dimension from Step 1, confirm it is represented. If any are missing or underdeveloped, expand the analysis.

Benefit: Mitigates the common failure mode where models address the most salient aspect of a query while neglecting secondary but required elements.

This method trains the model to identify and prioritize action verbs and scope modifiers in the user's instruction (e.g., 'compare,' 'list,' 'explain the pros and cons of'), ensuring each commanded action is fulfilled.

Example Prompt:

codeCopy
User Request: 'Compare the architecture of transformers and RNNs, list three use cases for each, and explain why transformers dominate NLP.'

Your Process:
1. Identify all instructional keywords: [Compare, List, Explain].
2. Generate your response.
3. Triage your response:
   - Did you perform a *comparison* (similarities/differences)?
   - Did you *list* three distinct use cases for each architecture?
   - Did you *explain* the causal reasons for transformer dominance?
4. Flag any unmet instructions and regenerate.

Use Case: Essential for technical documentation and educational content where missing a single requested analysis type invalidates the response.

Instead of just checking for presence, this advanced prompt instructs the model to actively hypothesize what a incomplete answer would look like, then contrast its own output to prove completeness.

Example Prompt:

codeCopy
Query: 'Draft an email to the client covering the project timeline, budget changes, and next steps.'

After drafting your email:
1. Imagine a deficient version of this email that misses one of the three required topics.
2. Explicitly compare your draft to this deficient version. Articulate how your draft includes sections that address timeline, budget, *and* next steps.
3. If the comparison reveals a gap, revise.

Cognitive Load: This forces a higher-order reasoning step, often surfacing omissions that simple affirmative checks miss.

Completeness is enforced by mandating a structured output format (JSON, XML) with specific, required fields that map directly to the query's components. The model's self-check validates field population.

Example Prompt:

codeCopy
Analyze the provided software bug report. Your output MUST be valid JSON with the following exact keys:
{
  "bug_severity": "",
  "root_cause_analysis": "",
  "reproducibility_steps": ["", "", ""],
  "suggested_fix": "",
  "affected_components": ["", ""]
}

Before finalizing, run this check: Is every key populated with appropriate, non-empty content? If 'reproducibility_steps' has fewer than three items or any field is empty, re-analyze the report.

Integration: This approach interfaces seamlessly with downstream code, where missing keys cause parsing failures, creating a machine-verifiable completeness guarantee.

Completeness verification is rarely a one-step process. It is most robustly implemented as a distinct phase within a broader self-correction loop or critique-generate cycle.

Typical Architecture:

1. Generate: Produce an initial response.
2. Critique/Verify: Execute a completeness verification prompt on the initial response. The model outputs a checklist of met and unmet requirements.
3. Revise: Use the verification output as context to generate a revised, complete response.

System Prompt Example:

codeCopy
You are an assistant that rigorously checks its work. For every response, you will internally follow this process:
- GENERATE a first draft.
- VERIFY: List every discrete task in the user's query. Mark each as 'Addressed' or 'Missing' in the draft.
- If any are 'Missing', REVISE the draft into a final answer that addresses all tasks. If none are missing, the draft is your final answer.
- Begin your final answer with '[Verified Complete]'.

This formalizes completeness verification as a core, automated component of the model's operational protocol.

A self-correction loop is a prompting architecture where a language model is instructed to iteratively critique and revise its own output. This creates a closed feedback cycle aimed at improving accuracy, coherence, or adherence to constraints.

• Core Mechanism: The model generates an output, analyzes it against criteria, and produces a revised version. This cycle can be repeated for multiple iterations.
• Key Application: Used in complex reasoning tasks, code generation, and content creation where a single pass is insufficient.
• Example: A model writes a summary, is prompted to 'find and fix any factual inaccuracies,' and then generates a corrected summary.

Output verification is a self-correction instruction that tasks a model with checking its response for factual accuracy, logical consistency, and completeness against provided source material or common knowledge.

• Distinction from Completeness: While completeness verification focuses on addressing all query components, output verification is a broader check that includes factuality and logic.
• Common Prompt Pattern: 'Verify that every claim in the following answer is supported by the provided source document.'
• Use Case: Critical for Retrieval-Augmented Generation (RAG) systems to prevent hallucinations and ensure grounded responses.

An internal consistency check is a self-correction step where a language model is prompted to ensure all parts of its generated response are logically coherent and free from contradictions.

• Focus Area: Detects conflicts within the model's own output, such as recommending mutually exclusive solutions or stating opposing facts in different paragraphs.
• Prompt Example: 'Read your answer above. Identify any statements that contradict each other and resolve them.'
• Engineering Value: Essential for generating long-form technical documentation or multi-step plans where early assumptions must align with final conclusions.

Constraint re-application is a self-correction step where a language model reviews its final output to ensure it still satisfies all initial guardrails, rules, or boundary conditions specified in the original prompt.

• Typical Constraints: Output length, prohibited topics, required data formats (JSON, XML), specific terminology to use or avoid.
• Why It's Needed: During generation, especially with chain-of-thought, models can 'drift' and violate initial instructions.
• Process: The model is given a checklist of the original constraints and performs a binary verification for each one.

A schema compliance check is a self-correction instruction where a model verifies that its structured output adheres exactly to a specified format, data types, and required fields.

• Primary Use Case: Structured output generation for APIs, where the response must be valid JSON, XML, or YAML that matches a predefined schema.
• Action: The model parses its own output as data, validates types (e.g., price is a number, items is an array), and checks for all required keys.
• Tool Integration: Often paired with function calling instructions to ensure executable code or API requests are syntactically correct.

The critique-generate cycle is a fundamental two-phase self-correction pattern. First, the model (or a separate 'critic' instance) produces a critique of a draft. Second, a 'generator' model produces an improved version based on that critique.

• Phase 1 - Critique: Focuses on identifying flaws, missing elements, or areas for improvement.
• Phase 2 - Generate: Explicitly uses the critique as a guide for rewriting.
• Architecture: Can be implemented with a single model playing both roles sequentially or with separate specialized models. This pattern is the foundation for more complex multi-agent self-review systems.