Spurious Legal Clause Identification Prompt

This prompt is a post-generation safety net for legal tech platforms and contract review systems. Its job is to take a model-generated contract summary or clause analysis and the original source contract, then identify every legal obligation, reference, or clause in the summary that cannot be traced back to the source text. The output is a structured audit report flagging spurious clauses, fabricated obligations, and invented legal language. The ideal user is a product engineer or legal operations professional building a review pipeline where a human attorney must approve flagged items before any output reaches a client-facing surface.

This prompt belongs in the output validation layer, after a model has produced a summary or analysis but before that output is delivered. It is not a contract generation prompt, not a clause extraction prompt, and not a replacement for legal judgment. You should use it when the cost of a fabricated obligation—such as an invented indemnity, a hallucinated payment term, or a spurious governing law clause—is high enough to require a dedicated detection step. The prompt requires two concrete inputs: the model-generated summary or analysis, and the full source contract text. Without both, the audit cannot produce reliable traceability.

Do not use this prompt as a primary summarization or extraction tool. It is a validator, not a generator. It will not improve the quality of a good summary; it will only flag what is unsupported. If your workflow already includes strict retrieval-augmented generation with citation grounding, this prompt may be redundant. However, for systems where a model is allowed to synthesize or paraphrase without inline citations, this audit step is a critical safety control. After running this prompt, route all flagged items to a human review queue and log the audit report for compliance evidence.

This template is the core instruction set for a spurious legal clause identification workflow. It is designed to be pasted directly into your application's prompt layer, with square-bracket placeholders replaced by real values at runtime. The prompt instructs the model to act as a strict contract auditor, comparing a generated analysis against the original source text and flagging any legal language, obligations, or references that lack a direct textual anchor. Because the output directly impacts legal review workflows, this prompt is designed for use within a harness that logs every comparison, surfaces flags for human attorney review, and never automatically removes content without explicit approval.

textCopy
You are a contract audit assistant. Your task is to compare a model-generated contract analysis against the source contract text and identify any legal clauses, obligations, rights, remedies, definitions, or references that appear in the analysis but cannot be traced to the source.

## INPUT
[SOURCE_CONTRACT_TEXT]

[GENERATED_ANALYSIS_TEXT]

## INSTRUCTIONS
1. Extract every discrete legal assertion, clause reference, obligation, right, remedy, definition, and citation from the generated analysis.
2. For each extracted item, search the source contract text for a direct textual match or a reasonable paraphrase grounded in specific contract language.
3. Classify each item as:
   - **Grounded**: The item is directly supported by identifiable language in the source contract. Provide the exact source text span as evidence.
   - **Spurious**: The item cannot be traced to any language in the source contract. It appears to be invented, inferred without evidence, or imported from external legal knowledge.
   - **Uncertain**: The item may be a reasonable interpretation but lacks a clear textual anchor. Flag for attorney review.
4. For every Spurious or Uncertain item, explain why it could not be grounded, noting whether it introduces a new obligation, alters a party's rights, or references a legal concept absent from the contract.
5. Do not modify, rewrite, or correct any content. Only classify and flag.

## OUTPUT FORMAT
Return a JSON object with this exact schema:
{
  "findings": [
    {
      "analysis_excerpt": "string (the exact text from the generated analysis being evaluated)",
      "classification": "grounded | spurious | uncertain",
      "source_evidence": "string | null (exact source contract text supporting the item, or null if none found)",
      "explanation": "string (reason for classification, especially important for spurious and uncertain items)",
      "risk_note": "string | null (if spurious, describe the potential impact: new obligation created, right altered, concept invented, etc.)"
    }
  ],
  "summary": {
    "total_items_reviewed": "number",
    "grounded_count": "number",
    "spurious_count": "number",
    "uncertain_count": "number",
    "requires_attorney_review": "boolean (true if any spurious or uncertain items found)"
  }
}

## CONSTRAINTS
- Do not introduce any legal analysis, interpretation, or commentary beyond grounding verification.
- Do not reference legal knowledge, statutes, case law, or external standards unless they are explicitly cited in the source contract.
- If the source contract is ambiguous, classify the item as Uncertain rather than Grounded.
- Never state that an item is Grounded without providing the exact source text span.
- If the generated analysis contains no spurious or uncertain items, return an empty findings array with appropriate summary counts.

To adapt this template, replace [SOURCE_CONTRACT_TEXT] with the full, unredacted contract text your system retrieved, and [GENERATED_ANALYSIS_TEXT] with the model-produced clause analysis or summary under review. If your application processes contracts in sections, run this prompt per section to keep context windows manageable and grounding evidence precise. The output JSON schema is designed for direct ingestion by a downstream validation harness that can log findings, trigger attorney review queues, and prevent spurious content from reaching client deliverables. Always pair this prompt with a human-in-the-loop step: the requires_attorney_review boolean should gate any automated publishing or delivery.

This prompt is not a standalone chat interaction. It is a post-generation filter designed to sit between a model that produces contract summaries or clause analyses and the attorney who reviews them. The harness must enforce a strict boundary: the prompt identifies potentially spurious clauses, but only a licensed attorney can decide whether flagged content is actually fabricated. The implementation must never present unverified output directly to a client or counterparty.

Input wiring: The harness must supply two required inputs: [SOURCE_CONTRACT] (the full text of the original agreement or the specific sections under review) and [GENERATED_ANALYSIS] (the model-produced summary, clause list, or obligation table being audited). An optional [REVIEW_SCOPE] parameter can limit the check to specific clause types—indemnification, limitation of liability, termination rights—to reduce noise in long contracts. The harness should chunk the source contract and generated analysis if they exceed the model's context window, running the prompt per chunk and merging results with deduplication logic. Model choice: Use a model with strong instruction-following and long-context handling. GPT-4o, Claude 3.5 Sonnet, or Gemini 1.5 Pro are appropriate. Avoid small or fast models that may miss subtle legal language fabrication.

Validation and retries: The output must conform to a strict JSON schema with a flagged_clauses array where each object contains clause_text, source_reference (the exact location in the source contract that contradicts or fails to support the clause), spurious_reason, and confidence (HIGH/MEDIUM/LOW). If the model returns malformed JSON, the harness should retry once with a repair prompt that includes the schema and the raw output. If the second attempt fails, log the failure and escalate the entire analysis for full human review. Logging and audit trail: Every run must log the prompt version, model, input hashes, raw output, parsed flags, and the attorney's final disposition for each flag. This audit trail is essential for demonstrating diligence if a missed spurious clause later causes a dispute.

Human review integration: The harness must route all flagged clauses into a review queue—never auto-remove them. Each flag should display the spurious clause side-by-side with the cited source contract excerpt. The attorney confirms (spurious, remove), overrules (not spurious, keep), or requests re-analysis. The harness should track review decisions to measure the prompt's precision and recall over time. What to avoid: Do not use this prompt as a replacement for attorney review. Do not auto-accept removals. Do not run the prompt on contracts where the source text is incomplete or redacted—the model will flag more false positives when it cannot verify against missing sections. If the contract is in a scanned PDF, run OCR and text extraction before invoking this prompt; poor extraction quality will degrade accuracy and increase spurious flags.