Verification Prompting: Make the Model Check Its Own Work

TL;DR: Verification prompting asks a model to check its own claims before it gives you a final answer. The real published version of this, Chain-of-Verification, answers those checks independently of the original draft, which matters more than it sounds. A documented court case shows exactly what happens when the check happens inside the same biased context as the mistake.

What verification prompting actually is

Verification prompting is a structured way of asking a model to catch its own errors before you see the final answer, instead of trusting the first draft outright. In its loosest form, that is just "are you sure?" tacked onto the end of a chat. In its more rigorous form, it is a separate, deliberate pass: generate a draft, extract the specific claims in it, check each claim, then produce a revised answer based on what the check found.

The gap between those two forms is the entire subject of this post, because one of them is a documented, tested technique and the other is the exact move that failed in a real courtroom.

The real technique: Chain-of-Verification

The published version of this idea is called Chain-of-Verification (CoVe), from "Chain-of-Verification Reduces Hallucination in Large Language Models" by Shehzaad Dhuliawala, Mojtaba Komeili, Jing Xu, Roberta Raileanu, Xian Li, Asli Celikyilmaz, and Jason Weston (2023). The paper's own description of the method has four steps: the model "first (i) drafts an initial response; then (ii) plans verification questions to fact-check its draft; (iii) answers those questions independently so the answers are not biased by other responses; and (iv) generates its final verified response."

Step (iii) is the part almost every casual "double-check yourself" prompt skips. Answering a verification question independently means answering it without the original draft sitting in front of the model as a reference point, because a model that can see its own prior claim while "verifying" it has an obvious shortcut available: agree with itself. Separating the check from the draft closes that shortcut, at least partially. The paper reports that CoVe "decreases hallucinations across a variety of tasks, from list-based questions from Wikidata, closed book MultiSpanQA and longform text generation." That is a real, tested direction, reported by the paper's own authors, not a number this project can independently confirm for any task of your own.

A prompt that follows the same shape:

Step 1 - Draft: Answer the question below in full.
[your question]

Step 2 - Plan verification questions: List 3-5 specific,
checkable claims from your draft above, each as its own
standalone question (e.g. "Is [X] actually true / does [Y]
actually say that?").

Step 3 - Answer independently: Answer each verification
question on its own, as if you had not written the draft.
Do not reference the draft's wording while answering.

Step 4 - Final answer: Compare the verification answers to
the original draft. Where they disagree, revise the draft.
Where a verification question could not be answered with
confidence, flag that claim as unverified rather than
restating it.

This will not add facts the model did not already have. What it can catch is an internal inconsistency the model introduces without noticing: a claim in the draft that its own independent re-derivation contradicts.

A worked example, walked through step by step

Take a hypothetical draft, invented for this walkthrough, answering "what changed in the latest release of a popular open-source framework": "Version 5 removed the legacy configuration file, added a built-in caching layer, and dropped support for the previous plugin format." Step 2 turns that into three verification questions: does version 5 remove the legacy configuration file, does version 5 add a built-in caching layer, does version 5 drop support for the previous plugin format.

Step 3 answers each one on its own, without the draft in view, which is the step that actually does the work. If the independent answer to the caching-layer question comes back uncertain or contradicts the draft (say, the caching layer was added a version earlier, not in version 5), step 4 catches the mismatch and either corrects the claim or flags it as unverified, rather than letting three unrelated claims travel forward as equally confident just because they were stated in the same sentence. Note what this walkthrough does not do: it does not go look at the framework's actual changelog. That is a separate, necessary step covered in how to fact-check what ChatGPT tells you. CoVe's independence check catches the model contradicting itself. It does not confirm the framework's changelog agrees with either answer.

The case that shows exactly where this breaks

Mata v. Avianca (S.D.N.Y., decided June 22, 2023, docket 1:22-cv-01461) is a real sanctions opinion, and it is the single clearest documented failure of naive verification prompting available. A lawyer, Steven Schwartz, had used ChatGPT to find case law and submitted a brief citing several cases that turned out not to exist. According to Judge P. Kevin Castel's opinion, when the fabrications were challenged, Schwartz went back into the same chat and asked ChatGPT two direct questions: "Is Varghese a real case" and "Are the other cases you provided fake". Both times, the opinion states, "ChatGPT responded that it had supplied “real” authorities that could be found through Westlaw, LexisNexis and the Federal Reporter." None of it could be found anywhere, because none of it was real.

That is verification prompting in its weakest form: asking the model to check a claim inside the same conversation where it made the claim, with no independence between the check and the thing being checked. It is structurally the opposite of CoVe's step (iii). The model had every incentive, in the shallow sense that its own prior text was sitting right there as context, to produce an answer consistent with what it had already said.

The opinion is also more precise than its reputation. It states there is "nothing inherently improper about using a reliable artificial intelligence tool for assistance." The sanction was for failing to check outside the tool, not for using it. Read the actual finding rather than the folklore version. The failure was not simply that the lawyer trusted an AI tool. It was that his one attempt at verification never left the room where the mistake had been made.

Where verification prompting genuinely helps

None of this means the technique is worthless. It means it has a specific, narrower job than catching every lie. Structuring a verification pass, even inside one conversation, is useful for:

• Internal consistency. Did the draft contradict a number or a name it used earlier in the same response?
• Completeness against the actual question. Did the draft answer what was asked, or drift into an adjacent topic?
• Logical gaps. Does a conclusion follow from the reasoning that supposedly produced it?
• Flagging its own uncertainty, when explicitly asked to distinguish a confident claim from a guess, which is not the same as resolving the uncertainty correctly, but is more honest than presenting both identically.

What it reliably does not do is add outside knowledge. A model verifying a fact it invented is drawing on the same training data, or the same absence of training data, that produced the invention in the first place. That is the boundary this technique cannot cross on its own, and it is why the workflow in how to fact-check what ChatGPT tells you treats an outside primary source as mandatory, not optional, for anything that actually matters.

Getting closer to real independence

Even the four-step template above is an approximation, because it usually runs inside one continuous chat, and the model can often still see the draft in the conversation history even when told to disregard it. A closer match to what the paper actually tested is running step 3 in a separate conversation entirely: paste only the verification question, with none of the surrounding draft, into a fresh chat, and treat that answer as the independent check. It is more friction than one long prompt, and it is also a meaningfully better approximation of the mechanism the research actually measured.

Phrasings that quietly defeat the technique

Even writers who know to add a verification step often phrase it in a way that reintroduces the same bias CoVe's independence step is designed to remove. Three patterns show up repeatedly:

• "Are you sure?" with nothing else. This invites a generic reassurance rather than a check against any specific claim, because there is nothing for the model to verify against. It is the exact shape of the two questions asked in Mata v. Avianca.
• "Double-check your answer above." Pointing directly at the prior answer puts it back in view during the check, which is precisely what step (iii) of the published method avoids by design.
• "List any mistakes you might have made." This asks the model to introspect on its own confidence rather than to re-derive a specific claim from scratch, and confidence is not the same signal as correctness.

A phrasing closer to what actually works names the exact claim and asks a narrower, standalone question about it, ideally without the earlier draft visible: "Does the Node.js documentation state that fetch is available without a flag as of the current LTS release? Answer only from what you know, without reference to any earlier draft." That is a specific, checkable question a model can get wrong on its own terms, rather than an invitation to agree with itself.

Putting it together

Verification prompting is worth using, structured deliberately rather than as a one-line follow-up. Ask for a draft, extract the specific claims, answer the verification questions independently of the draft's own wording (in a fresh conversation if you want the closer approximation), and flag anything that could not be confidently re-derived rather than letting it slide back into the final answer unchanged. That gets you real, if partial, protection against internally inconsistent output.

It does not get you protection against a confidently fabricated fact the model believes on both passes, because both passes are still the same model with the same knowledge. For that, the only thing that has ever worked is checking against something outside the conversation, which is also the entire argument of a real federal sanctions order. If you want the technique that catches a different class of error, structural and tonal gaps in a draft, see reflexion and self-critique prompting, and if you want to see how framing or persona choices interact with what a model is willing to assert in the first place, persona prompting: make ChatGPT think like an expert is worth reading alongside this one. For where priming the start of an answer changes what comes after it, a related but distinct lever from verification, see output priming: start the answer for the model.