How to Reduce AI Hallucinations: 7 Research-Backed Techniques

Based on 27 peer-reviewed sources. 7 techniques to reduce AI hallucinations, each with copy-paste prompts. Plus a framework for matching effort to stakes.

The most dangerous thing about AI isn’t that it gets things wrong. It’s that it gets them wrong while sounding right.

We now rely on these tools for everything, from questions we used to Google to the work we produce every day. And they make things up while sounding completely confident.

I’ve experienced it. You’ve experienced it. We all have, whether we caught it or not.

The consequences can be very serious. Lawyers have cited cases that don’t exist. Big companies have published reports with fabricated data. This isn’t something we can afford to be careless about.

So I wanted to create a resource grounded in actual research. One that explains why hallucinations happen and how to work around them. Because this should be part of the 101 of working with AI, no matter how much you use it.

After a lot of digging, I ended up with twenty-seven sources. Mostly peer-reviewed studies, but also official documentation from Anthropic, OpenAI, and Google. All compiled in a NotebookLM project to make sense of what’s actually going on when AI makes things up.

This is that guide.

---

Here’s what we’ll cover:

• What hallucinations are

• Why they happen and whether LLMs “know” when they’re making things up

• 7 techniques to reduce them, with prompts you can copy and use

• A framework for matching your verification effort to the stakes

There’s 30 hours left to get a premium subscription to AI blew my mind at the lowest price this publication will ever be. If you’ve been thinking about it, this is the moment. After that, the price goes up and won’t come back down.

First, let’s get clear on what we’re talking about

“Hallucination” sounds almost whimsical. Like the AI is having a creative episode.

What’s actually happening is the model generates content that is factually wrong (wrong dates, wrong capitals), logically inconsistent (contradicting itself mid-response), or entirely fabricated (citations that don’t exist, events that never happened). While sounding completely confident.

Researchers break this into two main categories:

1. Intrinsic hallucination: The model contradicts the specific input you gave it. You paste a contract that says the deadline is March 15, and the model summarizes it as March 30. It's not pulling from somewhere else. It's misreading what you just gave it.

2. Extrinsic hallucination: The model makes things up from nothing. You ask about something obscure, and instead of saying “I don't know”, it invents a confident, detailed answer.

Understanding which one you're dealing with changes how you address it. Contradicting your documents is not the same problem as inventing things from scratch.

---

Why this happens (it’s not random)

Large Language Models are prediction machines.

They’ve been trained on massive amounts of text to predict what word should come next. That’s it. They optimize for plausibility, not truth. And making text sound good often conflicts with making it accurate.

It comes down to two big reasons in how LLMs are trained:

1. They get rewarded for responding, not for being right

When the model doesn’t know the answer, it faces a choice: admit uncertainty or generate something plausible.

Most training rewards the second option. The benchmarks AI companies compete on don’t give points for “I don’t know”. They reward taking a shot.

So models learn to guess confidently. And because they’re extraordinarily good at language, their guesses sound authoritative.

2. Training data is flawed

Models learn from web-scale data. That includes humanity’s best knowledge but also our mistakes, biases, and outdated information. When you ask about something rare or recent, the model fills the gap with what sounds right based on patterns, not facts.

---

But do LLMs actually know when ‘they’re lying’?

They kind of do.

Studies have found that models hold enough internal information to recognize when they’re on shaky ground. They just don’t surface that uncertainty unless you force them to.

One experiment tested this by asking models to cite papers, then repeatedly asking who the authors were. For made-up references, the model gave inconsistent answers each time. For real papers, it got the authors right consistently. The model “knew” the difference. It just didn’t volunteer that information.

Why does this matter? Because it means we can work with this. If the model has some sense of what it knows and doesn’t know, we can use the right prompts to bring that uncertainty to the surface.

And that’s exactly what we’re going to do next.

---

The practical toolkit: How to reduce hallucinations

Now for what you actually came for. Based on the research I’ve reviewed, here are the techniques that work.

1. Give explicit permission to say “I don’t know”

This is the single most effective intervention. And it’s dead simple.

Models are trained to avoid uncertainty. You have to explicitly override that by telling them it’s okay, even preferred, to admit when they’re unsure.

The core prompt:

If you’re not certain about something or if your information might be outdated, tell me explicitly. It’s better to say “I’m not sure” than to give me wrong information I’ll act on.

And you can adapt this to different situations:

For research and fact-finding

Find information about [topic]. If you’re not certain about any details, say so. If something might have changed since your training data, flag it. I’d rather have gaps than wrong information.

For analyzing your own documents

Review this [document/report/contract] and answer my question. If the document doesn’t contain enough information to answer confidently, say “The document doesn’t provide enough detail on this.” Don’t fill in gaps with assumptions.

For general questions

[Your question]. If you’re unsure about any part of your answer, tell me which parts you’re confident about and which parts are less certain. Being honest about uncertainty is more helpful than sounding confident.

Why it works: You’ve changed what “helpful” means. The model no longer needs to guess to seem useful. Research shows this significantly reduces hallucination rates, especially for models that are highly sensitive to how you frame the task.

2. Use Chain-of-Thought prompting

Chain-of-Thought (CoT) forces the model to show its reasoning step-by-step before giving a final answer. Instead of one big leap to a conclusion, it takes smaller steps you can actually follow. This makes fabrications easier to spot, and research backs it up: CoT cut hallucination rates from 38.3% to 18.1%.

Basic version, just add this:

Think through this step-by-step before giving your final answer.

More structured version:

I need you to analyze [X]. Here’s how I want you to approach it:

1. First, identify the key pieces of information relevant to this question

2. Then, explain your reasoning for each point

3. Note any areas where you’re uncertain or making assumptions

4. Finally, give your conclusion based only on what you’ve established in steps 1-3

Why it works: If something's wrong in the reasoning, you can spot exactly where the logic broke. The catch is that missing information can still lead to made-up details, that's why this technique works best combined with the others.

3. Ground outputs in specific quotes (the “Quote First” method)

For any task involving documents you need to work with (contracts, reports, research papers, emails), this method works especially well because it forces the model to extract exact quotes before analyzing them.

The two-step structure:

Step 1: Extract evidence

Review this [document type]. Extract 5-7 exact quotes that are relevant to [your specific question]. Copy them word-for-word. If you can’t find relevant quotes, say “No relevant quotes found for this question.”

Step 2: Analyze based only on evidence

Now, using only the quotes you just extracted, answer my original question. For each claim you make, reference which quote supports it. If a claim isn’t supported by a specific quote, remove it.

Example for a contract review:

Step 1: I’m attaching a vendor contract. Extract exact quotes related to liability limitations, termination clauses, and auto-renewal terms. Copy them word-for-word.

Step 2: Based only on the quotes you extracted, summarize the key risks I should be aware of. Reference each quote when making a claim. Don’t add analysis beyond what the quotes directly support.

Why it works: You physically anchor the output in the actual text. The model can’t easily fabricate something when it has to cite the specific passage that supports each claim. Intrinsic hallucinations become much harder.

4. Ask the model to verify itself

After getting an answer, ask the model to cross-check its own work.

Basic self-verification prompt:

You just gave me an answer about [topic]. Now, for each factual claim you made, identify what supports it. If you can’t find support for a claim, flag it as “unverified”.

More detailed version:

Review the response you just gave. For each specific fact or claim:

1. State the claim

2. Identify the source or basis for it

3. Rate your confidence (high/medium/low)

4. If confidence is low, explain why

Then give me a revised response that removes or flags low-confidence claims.

Why it works: Models can often recognize inconsistencies in their own reasoning when prompted to look for them. The same internal mechanisms that distinguish between known and unknown information get activated when you explicitly ask for verification.

5. Test consistency with multiple attempts

For critical information (citations, specific data points, key facts), ask the same question multiple times.

How to do it:

1. Ask your question

2. Start a new conversation (or clearly separate the attempts)

3. Ask the exact same question again

4. Compare the answers

Why it works: A correct answer tends to stay consistent. A hallucinated one doesn’t. If you get the same response each time, your confidence should be higher. If the answers contradict each other, that’s a strong signal the model is guessing.

6. Role-prime for accuracy over helpfulness

By default, models try to be helpful. Sometimes that helpfulness means giving you something even when they shouldn’t. You can shift the priority explicitly.

And I’d actually encourage you to add something like this to your custom instructions or system prompt, so it applies to every conversation.

Prompt:

You are a fact-checker. Your job is to be accurate, not helpful. If you’re not certain about something, say so. If you don’t have information, say you don’t have it. I would rather have gaps in my knowledge than wrong information. Being cautious is more valuable than being comprehensive.

Why it works: You’re explicitly changing what “good performance” means for this task. The model adjusts its behavior to match the role you’ve defined.

7. Use structured output for verification

When you need information you’ll act on, ask for it in a format that forces specificity.

Prompt:

Give me information about [topic] in this format:

• Claim: [specific statement]

• Basis: [where this comes from, such as training data, inference, or assumption]

• Confidence: [high/medium/low]

• How to verify: [what I would search to check this]

Why it works: This forces transparency. The model can’t hide uncertainty behind confident prose when it has to explicitly state its confidence level and basis for each claim.

---

A framework for deciding how much verification you need

You don’t need to use all these techniques every time. That would be exhausting and overkill for most tasks. The key is matching your effort to what’s at stake.

Low stakes (creative work, brainstorming, exploration):

• Basic prompting is fine

• Hallucinations might actually spark interesting ideas

• Use: standard prompts without heavy verification

Medium stakes (research, learning, drafts you’ll review):

• Ask for sources or reasoning

• Do spot-checks on key claims

• Use: methods 1 (give the model permission to say “I don’t know”), 2 (Chain of Thought), and 6 (role prime for accuracy)

High stakes (client work, published content, decisions with real consequences):

• Use the Quote First method for any documents

• Self-verification on all outputs

• Consistency testing for critical facts

• External verification through search tools

• Use: all techniques, plus manual checking of key claims

The effort should match the consequences of being wrong.

---

What to take from all this

Models are improving. Each new generation hallucinates less than the last. The trend is clear. But hallucinations won’t disappear entirely. They’re baked into how language models work.

What matters most now is developing instincts for when AI gets it right and when it doesn’t. Learning to sense what’s off, and knowing when the stakes are high enough to double-check.

This creates a hard problem: how do you verify work in areas you haven’t mastered, when you’re asking AI precisely because you lack that expertise?

There’s no perfect answer. But there are practices:

1. Use the techniques in this article to reduce hallucinations at the source

2. Use web search and research features that cite sources, and actually check them (all models have them)

3. Match your verification effort to the stakes

4. Stay skeptical of confidence, yours and the model’s

These tools are powerful, but the work we produce is still our responsibility, regardless of how we got there. Blaming the AI doesn't hold up in court, with clients, or with your own standards.

The goal isn’t to distrust AI entirely. It’s to use it with eyes open.

---

What techniques do you use to catch hallucinations? I’d love to hear what’s working for you.

I spend a lot of time digging through research so you don’t have to. If guides like this help you work smarter with AI, premium gets you all of them, plus templates, prompts, and everything I build.