AI fact-checking prompt templates: verify sources, spot hallucinations & score confidence

A working library of fact-checking prompts — six template families, a calibrated five-tier confidence rubric, cross-model verification, web-grounded checks, and an eight-template kit you can save tonight.

Read this paragraph and tell me what is wrong with it:

“According to a 2024 McKinsey study, 73% of mid-market SaaS teams that adopted AI coding assistants saw a 28% lift in shipping velocity within six months, with the largest gains in teams already using trunk-based development (Patel et al., MIT Sloan Management Review, March 2024).”

You probably cannot tell. The sentence is well-shaped, names a credible firm, gives precise numbers, and cites a real-sounding journal with a plausible author. That is exactly how a confident hallucination looks. None of those numbers may be real. The Patel et al. citation may not exist. The 73 percent figure may be the model’s averaging of vibes from its training distribution.

A reader cannot catch this by reading harder. They catch it with a verification layer — one that extracts every claim, scores its confidence, hunts for the most likely failure modes, and grounds anything consequential against an outside source. That layer is built from prompts.

This article is a working library. Six template families, a five-tier confidence rubric, a worked pipeline, and a minimum kit you can paste into your snippet manager tonight. Whether you are a developer wiring fact-checks into an agent or a founder pre-publishing a strategy memo — the same templates apply.

Why hallucinations follow patterns

A hallucination is the model emitting a confident claim it cannot ground. The word “lie” is wrong because there is no intent. The behavior is structured, and the structure is what makes it catchable.

Six failure modes account for most of what slips through:

1. Invented citations — author names, paper titles, journal venues, and URLs that sound right because they pattern-match real ones.
2. Drifted statistics — a real figure (28% adoption) becomes a near-real figure (31%), or a real study becomes a fake one published a year off.
3. Fabricated quotes — plausible-sounding quotations attributed to real people who never said them.
4. Wrong dates and tenures — founding years, role start dates, version release dates, and “since X” claims that drift by 1–3 years.
5. Plausible APIs and methods — function names, parameters, command flags, library methods that look like real syntax but do not exist.
6. Causal claims with the arrow flipped — “X caused Y” when the actual research says Y caused X, or both correlated with Z.

If you know what to hunt, you can build a prompt that hunts each one specifically. The rest of this article is that hunt, organized.

The verification pipeline (the spine)

Before the templates, fix the workflow shape. A good fact-check has five stages, and skipping any one of them leaves a known hole.

1. Extract — pull every checkable claim from the draft into a list.
2. Verify — for each claim, force the model to mark whether it has direct grounding, memory only, or inference.
3. Ground — for high-stakes claims, attach a real, nameable source (web search, RAG retrieval, or a document you provided).
4. Score — assign each claim a confidence tier on a calibrated scale.
5. Mark — return the output with the confidence tier visible inline so the reader can see what is safe and what to double-check.

The templates that follow fill these stages. Most fact-check failures come from doing stage 1 in your head, skipping stage 3, and trusting the model on stages 4 and 5. Make all five explicit.

Template family 1 — Pre-publish fact-check

These run on an AI-written draft before it ships.

Template 1A — Claim extraction

You are a fact-checker. Extract every checkable factual claim from the text below.

For each claim, return:
- claim: the exact sentence or sub-sentence
- type: one of [statistic, quote, citation, date, named-entity, causal, definition, technical-fact]
- subject: the named person, company, paper, product, or event the claim depends on
- checkable: yes if a reader could verify this in 60 seconds with web search, no if not

Return as a numbered list. Skip opinions, recommendations, and stylistic statements.

Text:
"""
[paste the AI draft here]
"""

Use when: you have an AI-written draft and need a checklist before publishing.

Fails when: the draft is dense in opinion and thin in fact. Claim extraction on a values memo will return three items; on a research summary it will return forty. Right tool, right shape of content.

Template 1B — Numbers, dates, and named entities audit

Scan the text below. List every:
- number (including percentages, dollar amounts, counts)
- date (years, months, specific dates)
- named entity (person, company, paper title, product, URL, API name)

For each, mark one of:
- KNOWN: you are highly confident this is correct based on widely documented facts
- UNCERTAIN: you are not sure; the value may have drifted from your training
- LIKELY FABRICATED: this looks pattern-matched, not retrieved; treat as a hallucination until verified

Return as a table: item | type | mark | one-sentence reason for the mark.

Text:
"""
[paste here]
"""

Use when: the draft is fact-dense. Numbers and named entities are where most hallucinations live.

Fails when: the model marks everything KNOWN because it lacks a calibration baseline. Pair with Template 3B (the five-tier rubric) to anchor the scale.

Template 1C — Source-claim matching

I am giving you a claim and a source.

Claim: "[paste the claim]"
Source: "[paste the source text, paper abstract, article body, or page content]"

Tell me:
1. Does the source support the claim? Quote the exact sentence(s) from the source that support or refute it.
2. If the source partially supports the claim, what part of the claim is unsupported?
3. If the source does not address the claim at all, say so directly.

Do not infer support from related context. Only quote.

Use when: the model gave you a citation and you want to check whether the source actually says what was claimed.

Fails when: the source text is too long for the context window. Chunk first, run the template on each chunk, then aggregate.

Template family 2 — Hallucination detection in conversation

These run mid-conversation, before you act on the model’s last answer.

Template 2A — Suspicion ranking

Look back at your previous answer. Of the factual claims you made, rank the top 5 by how likely each one is to be wrong.

For each, give:
- claim
- one reason it could be wrong (training cutoff, drifted detail, pattern-matched citation, unfamiliar domain, etc.)
- one specific check that would resolve the uncertainty

Be honest. If you are not sure, the rank should be higher, not lower.

Use when: you are about to act on an answer with consequences — sending an email, making a decision, writing code based on an API claim.

Fails when: the model defaults to false modesty and ranks safe claims as suspicious. Counter by adding: “Do not rank stylistic choices as suspicious. Only rank factual claims that could be checked.”

Template 2B — Weakest-link audit

Your previous answer rests on a chain of facts. Identify the single weakest link — the claim that, if wrong, would invalidate the rest of the answer.

Give me:
- the claim
- why it is the weakest link
- the minimum evidence needed to confirm it

Use when: the model gave you a multi-step argument or a synthesized conclusion. The chain is only as strong as its weakest fact.

Fails when: the answer is a list, not a chain. Use 2A for lists.

Template 2C — The cross-paste check

Rewrite your previous answer so that every factual claim is named explicitly enough that a different AI model could verify it without access to this conversation.

Replace pronouns and references with specific names, dates, and numbers. Mark any claim that you cannot make this explicit as [INFERRED] or [SPECULATION].

Return only the rewritten answer.

Use when: you are about to hand the answer to another model (or human reviewer) for verification. This template strips out conversational shorthand that hides fragile claims.

Fails when: the answer is short and already explicit. The rewrite will look identical to the original — that is fine, it just means there is nothing to strip.

Template family 3 — Confidence scoring and calibration

These force the model to score its own confidence per claim, using a calibrated scale.

Template 3A — Per-claim confidence tag

Re-output your previous answer with a confidence tag after each factual claim.

Use this scale, inline, in square brackets:
[KNOWN]       — high confidence, widely documented
[LIKELY]      — high confidence, but specific details may have drifted
[INFERRED]    — logical deduction from known facts, not direct retrieval
[UNCERTAIN]   — could go either way, verify before relying on
[SPECULATION] — not grounded, model is filling in plausible content

Do not add new content. Only tag existing claims.

Use when: you want the answer back with visible confidence markers, so the reader can see what to double-check.

Fails when: the model over-tags safe claims as KNOWN. Pair with 3B for the rubric, or use a stricter version: “If a claim depends on a specific date or named source, default to LIKELY, never KNOWN.”

Template 3B — The five-tier calibrated rubric

Use this scale for any factual claim in your answers:

- KNOWN — you would bet $1000 it is correct. Widely documented, not time-sensitive.
- LIKELY — you would bet $100 it is correct, but specific numbers, dates, or names may have drifted.
- INFERRED — you are not retrieving this; you are deducing it from known facts. Mark assumptions.
- UNCERTAIN — you genuinely do not know; flag for verification.
- SPECULATION — pattern-matched, not retrieved. Do not use unless explicitly asked.

For each tier, justify the rating in one sentence. If you cannot justify a KNOWN rating in one sentence, downgrade it to LIKELY.

Use when: you want a canonical scale across all your prompts. Paste this once at the start of any session that involves factual claims.

Fails when: the model treats the scale as decorative and tags everything LIKELY. Counter by occasionally asking it to defend a KNOWN rating with the actual source.

Template 3C — Source-vs-memory-vs-inference labeling

For each factual claim in your answer, mark which of three buckets it came from:

[SOURCE]    — directly from a document I provided in this conversation
[MEMORY]    — from your training data, not from any document in this conversation
[REASONING] — derived by logical inference from other facts, not retrieved

If a claim is half-source-half-memory, mark [SOURCE+MEMORY] and explain which part is which.

Use when: you provided documents (a paper, a contract, internal notes) and want to know what the model is grounding in your text vs. its training.

Fails when: the model is generous about what counts as “from the document.” Add: “Quote the exact sentence from the document that justifies any [SOURCE] tag.”

Template family 4 — Source and citation verification

These hunt the highest-risk hallucination: the made-up citation that looks real.

Template 4A — Citation grounding

Re-output your previous answer with a citation for every factual claim.

Rules:
- Only cite sources you can name explicitly: title, author, year, venue, and URL if you have one.
- Do not invent a citation. If you cannot name a real source, mark the claim as [UNGROUNDED] instead of citing.
- Do not cite "general knowledge" or "common research." Either name the source or mark it ungrounded.
- Cite at most one source per claim. The strongest one.

Use when: you want citations forced explicit, not blended into prose.

Fails when: the model invents plausible citations rather than marking claims ungrounded. Always pair with 4B.

Template 4B — Citation audit

Here is a list of citations from a previous AI-generated answer:

[paste citations]

For each, tell me:
1. Is this source real? Mark as LIKELY-REAL, UNCERTAIN, or LIKELY-FABRICATED.
2. If LIKELY-FABRICATED, what tipped you off (impossible date, mismatched venue, author who does not work in this field, made-up DOI format, etc.)?
3. Even if the source is real, is the cited claim something this source would actually contain?

Do not give the source the benefit of the doubt. The default assumption is fabrication until proven otherwise.

Use when: you have any AI-generated text with citations. Run this every time.

Fails when: the auditing model is the same model that wrote the citations and has the same blind spots. Use a different model for the audit when stakes are high.

Template 4C — Hallucinated URL detection

Here is a list of URLs from a previous AI-generated answer:

[paste URLs]

For each URL, assess:
- Does the domain exist and serve the kind of content claimed?
- Does the URL path follow the real conventions of that site, or is it a plausible-looking pattern?
- Is this URL likely to resolve to the content described, or to a 404?

Mark each as LIKELY-REAL, UNCERTAIN, or LIKELY-HALLUCINATED.

Use when: any AI answer with URLs you have not clicked yet. URLs are the highest-frequency hallucination class.

Fails when: the model cannot actually check URLs. Pair with web-search tool use (template family 6) for a real check.

Template family 5 — Cross-model verification

Cross-model verification works because two frontier models have different training mixes, different RLHF, and different hallucination patterns. When they agree, your confidence rises. When they disagree, you have located the exact claim worth checking.

Template 5A — Adversarial cross-check

Paste this into a different model than the one that wrote the original answer:

Another AI model produced the following answer. Find the weakest part — the single claim most likely to be wrong, or the citation most likely to be fabricated.

Do not be diplomatic. You are reviewing this adversarially. Your job is to find errors, not to compliment the structure.

For each suspicious claim, say:
- the claim
- why you suspect it
- the check that would resolve it (web search query, specific source, etc.)

Original answer:
"""
[paste]
"""

Use when: any consequential output. Best practice: produce in one model, verify in another. Claude verifies GPT. GPT verifies Claude. Gemini verifies either.

Fails when: both models share the same blind spot (rare for non-recent facts, common for very recent events or niche domains).

Template 5B — Disagreement triage

Two AI models gave different answers to the same question.

Model A said: "[paste]"
Model B said: "[paste]"

Tell me:
1. What is the specific factual claim they disagree on?
2. Which side is more likely correct, and why?
3. What single check would resolve the disagreement definitively?

Use when: you ran the same question through two models and got divergent answers. The divergence is the signal.

Fails when: the disagreement is on style or interpretation, not fact. Strip those before running.

Template family 6 — Web-grounded verification

A model verifying its own memory is a model lying to itself. Web search is the closing-loop tool.

Template 6A — Search-then-verify loop

For each claim in the text below:

1. Rephrase the claim as a precise web search query.
2. Search for the query (or assume search has been run and give me the query I should run).
3. Compare the top results against the claim. Mark agreement as CONFIRMED, partial agreement as PARTIAL, disagreement as CONTRADICTED, and no relevant results as UNRESOLVED.
4. For CONFIRMED claims, cite the source. For CONTRADICTED claims, quote what the source actually says.

Text:
"""
[paste]
"""

Use when: any claim that could have drifted since the model’s training cutoff — recent events, current statistics, version numbers, product features, regulatory dates.

Fails when: the search returns AI-generated content that repeats the original hallucination. The web is now polluted with model output. Prefer authoritative sources (official docs, peer-reviewed papers, named outlets) over aggregator pages.

Template 6B — Top-3-result agreement check

I am about to publish the following claim: "[paste claim]"

Run a web search for this claim. Look at the top 3 authoritative results.

Return:
- the 3 sources you would weight as authoritative for this claim
- whether each one supports, contradicts, or does not address the claim
- a verdict: PUBLISH, REVISE, or DO NOT PUBLISH

Use when: the claim is consequential and you are about to ship it publicly.

Fails when: the topic has no authoritative coverage. For very niche or very recent topics, downgrade to UNCERTAIN and either cut the claim or own the uncertainty in the published text.

The five-tier confidence rubric (canonical scale)

Paste this into the system prompt of any serious workflow. It is the same scale used in 3B, restated as a reusable instruction.

Confidence rubric — apply to every factual claim:

KNOWN          — would bet $1000. Widely documented, not time-sensitive.
                 Examples: founding dates of major companies, names of well-known laws of physics,
                 definitions of common technical terms.

LIKELY         — would bet $100. Confident on the substance but specific numbers,
                 dates, or names may have drifted.

INFERRED       — logical deduction, not retrieval. Mark the assumptions used.

UNCERTAIN      — genuinely unknown. Flag for verification before relying.

SPECULATION    — pattern-matched, not retrieved. Do not use unless explicitly
                 asked for speculation.

Default to a lower tier when in doubt. A wrong KNOWN tag is worse than a cautious LIKELY tag.

The rubric works because it forces the model to commit to a label — and labels with stakes (“would bet $1000”) resist the default smoothing toward false confidence. Calibration is a habit; the rubric is the training wheel.

Anti-patterns: prompts that look smart but produce nothing

These fact-check prompts feel productive and accomplish very little.

Replace each one with a specific template from above. The rule: any fact-checking instruction that does not specify what to check and how to mark the result is decoration.

The agentic workflow: chain the templates

For developers, chain the templates into a pipeline that runs before every consequential output.

A practical five-step chain for a research memo or strategy doc:

1. Generate — produce the draft with Model A.
2. Extract — run Template 1A on the draft. Output: list of claims.
3. Audit — run Template 1B for numbers, dates, and entities. Output: marked-up list.
4. Cross-verify — run Template 5A in Model B on the draft. Output: weakest-link report.
5. Ground + score — run Template 6A (web search) on every CONTRADICTED, UNCERTAIN, or LIKELY-FABRICATED item. Then run Template 3A to tag the final draft with confidence tiers.

For chat-UI users without tool access, collapse steps 3 and 5 into a manual web check on flagged items. The pipeline shape stays the same: extract → verify → ground → score → mark.

This is the part that compounds. Once the pipeline is wired, every future draft costs the same to verify, and the cost is small.

Minimum viable kit (save these eight)

These eight templates cover most fact-checking situations you will hit this year. Save them as snippets.

1. Claim extraction (Template 1A) — the entry point to any fact-check.
2. Numbers and entities audit (Template 1B) — catches the highest-frequency hallucinations.
3. Suspicion ranking (Template 2A) — the fastest mid-conversation move.
4. Per-claim confidence tag (Template 3A) — the publish-ready output format.
5. Five-tier rubric (Template 3B) — paste into system prompt once, use everywhere.
6. Citation audit (Template 4B) — run on any AI text with citations.
7. Adversarial cross-check (Template 5A) — for any high-stakes output.
8. Search-then-verify (Template 6A) — for any claim that could have drifted since training.

Trust is a workflow, not a feeling

The job is not to make models stop hallucinating. They will not — not at the level of reliability a single confident reading provides. The job is to make hallucinations cheap to detect and impossible to ship undetected.

That happens when claim extraction is automatic, confidence tags are visible to the reader, citations are audited adversarially, and consequential numbers are grounded against an outside source. The templates above are the pieces. The pipeline is the assembly.

One operational rule to leave with:

Do not publish AI-assisted content without a marked confidence tag on every consequential claim. Do not act on AI-generated facts without running at least one cross-check.

The cost of running the pipeline is five minutes. The cost of a published hallucination is much larger — and lasts much longer.

Source Note

The templates, failure modes, and methodology in this article are distilled from published research on LLM hallucinations and calibration, vendor documentation from frontier labs, and practitioner patterns reproducible across Claude, GPT, and Gemini as of early 2026.

Core research:

• Ji et al., Survey of Hallucination in Natural Language Generation (2023), arXiv:2202.03629 — foundational taxonomy of hallucination types (intrinsic vs. extrinsic, factual vs. faithfulness) that informs the six failure modes section.
• Huang et al., A Survey on Hallucination in Large Language Models (2023), arXiv:2311.05232 — comprehensive analysis of hallucination causes, evaluation, and mitigation strategies in modern LLMs.
• Lin et al., TruthfulQA: Measuring How Models Mimic Human Falsehoods (2021), arXiv:2109.07958 — benchmark establishing that larger models do not automatically become more truthful, motivating the need for explicit verification layers.
• Kadavath et al., Language Models (Mostly) Know What They Know (2022), arXiv:2207.05221 — evidence that models can be prompted to produce calibrated self-assessments, basis for the five-tier rubric.
• Manakul et al., SelfCheckGPT: Zero-Resource Black-Box Hallucination Detection (2023), arXiv:2303.08896 — empirical basis for cross-model and self-consistency verification approaches.
• Lewis et al., Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (2020), arXiv:2005.11401 — foundational work on grounding model outputs in retrieved sources, basis for the source-vs-memory distinction.
• Min et al., FActScore: Fine-grained Atomic Evaluation of Factual Precision (2023), arXiv:2305.14251 — claim-level fact-checking methodology that informs Template 1A and 1B.

Vendor and practitioner guidance:

• Anthropic, Reducing hallucinations and Claude prompt engineering documentation — guidance on grounding, citation patterns, and confidence-aware prompting.
• OpenAI, Prompt engineering and Tactics for reducing hallucinations in the OpenAI Platform docs — including the “let it not know” pattern reflected in Templates 3C and 4A.
• Google, Grounding and citations in Vertex AI / Gemini documentation — covers search-grounded generation and citation verification.

Real-world failure documentation:

• Reporting on fabricated case citations in legal filings (Mata v. Avianca, 2023) and similar incidents across academic, journalistic, and corporate contexts — the empirical basis for treating invented citations as the highest-risk hallucination class.