How to Stop AI Hallucinations: 9 Prompting Fixes That Work

An AI hallucination is a confident, fluent, completely wrong answer — a fabricated statistic, a paper that doesn't exist, a quote nobody said. It's the single biggest reason professionals distrust AI output, and here's the part most people miss: the majority of hallucinations are preventable with better prompting. Not eliminated by some future model — preventable now, with techniques that take one extra sentence. This guide covers why models make things up, the nine fixes that work, and how to build a workflow where fabrications get caught before they cost you.

Why AI Makes Things Up

A language model is not a database with a lookup function. It's a prediction engine: given your prompt, it generates the most statistically likely continuation, token by token. When you ask a question, you're not retrieving a stored fact — you're sampling from a probability distribution shaped by training data.

That design has a built-in failure mode. When the true answer is thinly represented in training data — or absent entirely — the most likely-sounding continuation is still a fluent, specific, confident answer. "I don't know" is rarely the highest-probability output, because the training data is full of questions followed by answers, not questions followed by abstentions. The model isn't lying; it's doing exactly what it was built to do, in a situation where that produces hallucination.

Understanding this explains both halves of the problem:

• Why it happens where it happens: niche facts, precise citations, post-cutoff events, arithmetic — all places where prediction and truth diverge
• Why prompting fixes it: every technique below works by changing what the most likely output is — anchoring it to provided text, licensing abstention, or making fabrication structurally harder

That number matters here: our study of 1,324 real prompts found the average prompt supplies almost none of the grounding that keeps a model honest. The hallucination problem and the prompt-quality problem are substantially the same problem.

The 9 Fixes, In Order of Leverage

1. Ground the Model in Your Source Material

The highest-leverage fix by a wide margin. Instead of asking from the model's memory:

❌ "What were the key findings of the Henderson report?"

Paste the material and scope the task to it:

✅ "Here is the Henderson report: [pasted text]. Using only this document, list the key findings. Do not add information from outside the document."

This converts the task from recall — where fabrication thrives — to reading comprehension, which models do far more reliably. Grounding is the difference between asking someone to recite a book from memory and handing them the book.

With 2026 context windows, "paste the source" scales further than most people think: GPT-5.5 holds 400K tokens; Gemini 3.1 Pro, Claude Opus 4.8, and DeepSeek V4 hold a million. Entire report sets fit. For choosing the right model for long-document work, retrieval accuracy at depth matters more than raw window size.

2. Give Explicit Permission to Say "I Don't Know"

One sentence, outsized effect:

"If the provided material doesn't contain the answer, say 'The source doesn't cover this' instead of guessing."

Models are trained on text where questions get answered, so answering is the default even when the honest move is abstaining. Explicit permission — better, an explicit instruction — to abstain changes the probability landscape. The model no longer has to choose between fabricating and disobeying.

This works on ungrounded prompts too: "If you're not confident this is accurate, say so" measurably reduces confident fabrication on factual questions.

3. Demand Citations Tied to Your Source

"For every claim, quote the specific sentence from the document that supports it."

Fabricating a fact is easy. Fabricating a verbatim quote that must exist in text sitting in the context window is much harder — and instantly checkable. Citation requirements do double duty: they suppress fabrication during generation and give you a ten-second verification path afterward.

Important distinction: citations to your provided source are reliable; citations to the open web from memory are one of the highest-hallucination outputs that exist. Never ask an ungrounded model for a bibliography — that's how lawyers end up citing cases that don't exist.

4. Constrain the Scope of the Question

Broad questions invite padding. "Tell me everything about our competitor's pricing strategy" will get gaps filled with plausible invention. Narrow it to what's answerable:

"Based on the pricing page copied below, list each plan, its price, and its stated limits. If a detail isn't on the page, mark it 'not stated.'"

The tighter the question maps to the source, the fewer gaps exist for the model to helpfully — and wrongly — fill. This is the same principle behind role and context in prompt structure: specificity isn't pedantry, it's error prevention.

5. Lower the Temperature for Factual Work

When you control sampling settings — in the API, a playground, or a builder tool — temperature governs randomness. High temperature encourages creative, less-probable continuations: exactly what you want for brainstorming, exactly what you don't want for facts. For factual tasks, set temperature at or near 0 so the model commits to its most probable answer.

This is a supporting fix, not a primary one — a low-temperature model still hallucinates confidently when ungrounded. But it removes the variance where a model that knows the right answer occasionally samples a wrong one.

6. Separate Generation from Verification

Models are meaningfully better at checking claims than at not making false ones — verification is a different task with different incentives. Use that:

"List every factual claim in your answer above. For each, state whether the provided source directly supports it, partially supports it, or doesn't mention it."

Run this as a second message after any answer that matters. Self-consistency approaches extend the idea — sample multiple answers and trust the consensus — and a chain-of-thought request ("show the reasoning that led to each claim") exposes fabrications by making the model show work it doesn't have.

For the highest stakes, verify across models: paste Model A's answer into Model B and ask it to challenge every claim against the source. Independent errors rarely agree.

7. Use Retrieval When Knowledge Exceeds the Context

When the knowledge base is too large to paste — a documentation set, a knowledge archive, a product catalog — retrieval-augmented generation automates grounding: fetch the passages relevant to each question and inject them into the prompt at ask time. The model answers from retrieved text, not memory, with all the benefits of fix #1 at scale.

RAG has its own failure modes — retrieval that misses the right passage produces a grounded-looking wrong answer — so if you're building one, start with our RAG prompt engineering guide and the fine-tuning vs prompting vs RAG decision framework.

8. Route Numbers to Execution, Current Events to Search

Two categories of hallucination are best solved by routing around the problem entirely:

• Numbers: A language model predicts arithmetic rather than computing it — plausible-looking wrong totals are the signature failure. For anything quantitative, use a model with code execution: GPT-5.5's sandbox runs real Python against your data and returns verified numbers instead of estimates
• Current events: Anything after the training cutoff is fabrication territory by definition. Use search-grounded tools — Grok's live X integration, Perplexity's cited search, or any flagship's browsing mode — so the model looks instead of remembers

The general principle: don't prompt-engineer your way through a task the model is structurally wrong for. Route it.

9. Make Uncertainty Visible

The final layer: instruct the model to expose its own doubt.

"Flag any claim you're not highly confident in with [UNVERIFIED], and note what would be needed to confirm it."

This doesn't prevent hallucination — it converts silent fabrication into reviewable doubt, which is what makes the difference in a real workflow. An answer with two [UNVERIFIED] flags tells you exactly where to spend your checking time. An answer with none and no grounding tells you to check everything.

Where Hallucination Risk Is Highest

Calibrate your checking effort to the risk zones:

A Practical Anti-Hallucination Workflow

For any output where being wrong has a cost, run this sequence:

• Ground: paste the source; scope the answer to it; permit abstention (fixes #1, #2, #4)
• Cite: require claims tied to quoted passages (#3)
• Verify: second pass — "check each claim against the source" (#6)
• Route: numbers to a sandbox, current events to search (#8)
• Spot-check asymmetrically: manually verify only the claims that carry consequences — anything you'll repeat, cite, or decide on

This takes two extra minutes per task. Against the cost of repeating a fabricated statistic in front of a client, it's the cheapest insurance in your workflow.

Model Notes: Who Hallucinates Least, Where

Model choice is the last 20%, but it's real — and it's workload-specific:

• Claude Opus 4.8 has the most disciplined citation behavior over long documents: it quotes rather than paraphrases and pushes back when the source doesn't support a claim — why it's the pick for legal and citation-bound review
• GPT-5.5 structurally eliminates arithmetic hallucination for data work via its execution sandbox, and high reasoning effort produces more visible hedging in place of confident error
• Gemini 3.1 Pro is a strong long-context reasoner but paraphrases sources more often than Claude — looser grounding for audit-grade work
• Grok 4.3 reduces current-events fabrication specifically, because live X data means it can look instead of remember
• DeepSeek V4 has a noisier output distribution than the premium tier — use it with the full workflow above and a review layer, especially at volume

The through-line: a grounded, constrained prompt on any of these beats an ungrounded prompt on the most careful one.

The Bottom Line

Hallucination isn't a bug that better models will eventually patch away — it's the default behavior of prediction engines asked to work without grounding. That's actually good news, because it means the fix is in your hands today: give the model the source, permit it to abstain, demand citations, verify before you trust, and route the structurally risky tasks to tools built for them.

The pattern behind all nine fixes is the same one behind prompt engineering generally: the quality of what comes out is set by the structure of what goes in. Our State of AI Prompting study put a number on it — the average real-world prompt scores 21.8/100, missing precisely the context and constraints that keep models honest. Fix the prompt, and most of the hallucination problem goes with it. The SurePrompts builder will do the structural work for you — so the one extra sentence that prevents a fabricated fact is never the sentence you forgot.