Hallucinations, Explained From Zero

The most important quality problem in building with AI is also the most disarming: a model can be completely wrong while sounding completely sure. This guide starts from nothing and explains why that happens — it's not a bug you can patch, but a consequence of how models work — and builds up the handful of defences that let you use a fluent, powerful, occasionally-inventive tool responsibly.

1 · Confidently wrong

You've probably seen it: you ask an AI a question and it answers smoothly, in perfect sentences, and the answer is completely wrong — a made-up statistic, a book that doesn't exist, a legal case never filed, a product feature that isn't real. This is a hallucination. What makes it dangerous isn't just that the model is wrong — everyone is wrong sometimes — it's that the model sounds exactly as confident when it's wrong as when it's right. There's no wobble, no “I think,” no hedge. It states the falsehood with the same calm authority as the truth. And that means you can't catch hallucinations by how they sound, which is precisely what makes them a quality problem you must design around rather than hope to notice.

2 · It predicts plausible words

The root cause is simpler than people expect. A language model doesn't look up facts in a database and report them — it generates text by predicting what words are most likely to come next, based on patterns learned from vast amounts of writing. So its actual goal, the thing it's built to do, is produce text that sounds plausible, like something a knowledgeable person might write. Here's the catch: plausible and true are usually the same thing, but not always. When the model doesn't genuinely “know” something, it doesn't stop and say so — it keeps predicting plausible-sounding words, and sometimes those form a confident, well-structured, completely false statement. It isn't lying, because lying means knowing the truth and hiding it. It's doing exactly what it was designed to do: producing fluent text. The falsehood is a side effect of aiming for plausible rather than correct.

3 · It has no idea what it doesn't know

The reason it sounds so sure when wrong is that it has no reliable sense of its own uncertainty. A person asked something shaky feels that shakiness — “I think it's around 1920, but don't quote me” — and acts on that inner signal constantly. The model doesn't have a dependable version of it. It generates the most plausible continuation regardless of whether that continuation is grounded in something it truly learned or is essentially a confident guess filling a gap. So it can't naturally hedge, because it doesn't know it should. The very fluency that makes these models useful is what makes hallucinations hard to catch: the wrong answer arrives with the identical polish and certainty as the right one. You can't tell them apart from the tone — and, in a real sense, neither can the model.

4 · Where hallucinations love to appear

Hallucinations aren't spread evenly — they cluster in predictable places, and knowing where keeps you alert. They love specific facts: exact dates, precise numbers, statistics, proper names — because there the difference between plausible and correct is razor-thin, and a confident wrong number looks just like a right one. They love citations and quotes: ask for a source and a model will often produce a beautifully formatted one that's entirely invented, because it learned what citations look like without memorising every real one. And they love niche or recent topics — anything on the thin edges of what the model learned, where it has little to draw on and fills the gap with guesses. The pattern is consistent: the less the model genuinely knows about something, the more likely it is to smoothly invent. So the riskiest questions are precise, obscure, or brand-new.

5 · Grounding: give it the real facts

So what can you actually do? The most powerful fix is grounding. Instead of asking the model to answer from its own memory, you give it the real, relevant documents to read and tell it to answer from those — exactly retrieval-augmented generation, RAG. This dramatically cuts hallucinations, because now the facts come from actual source text in front of the model rather than from plausible guessing. You've changed the model's job from “recall this” — where it might invent — to “read this and tell me what it says,” which it does far more reliably. Grounding doesn't make hallucinations impossible, but it moves the model onto much firmer ground, and it's the single biggest lever you have. The next article is devoted entirely to grounding and citations — the discipline of anchoring answers to real, checkable sources.

6 · Let it say “I don't know”

A second, simpler lever: explicitly give the model permission to be unsure. By default a model tends to always produce an answer, because that's what its training rewards. But you can instruct it — in the system prompt or the request — to say “I don't know” or “the documents don't cover this” when it isn't confident, rather than guessing. Paired with grounding this is especially effective: “answer only from the provided passages, and if the answer isn't there, say so.” That single instruction turns many would-be hallucinations into honest admissions of a gap — almost always what you actually want, because a user is far better served by “I'm not certain” than by a confident falsehood they then act on. It won't catch everything, since the model's self-awareness is imperfect, but telling it that “I don't know” is acceptable removes much of the pressure that produces invented answers.

7 · Verify anything that matters

The final and most important defence is a mindset that should shape how you design any AI feature: never treat a model's confident output as automatically true, especially when it matters. Because hallucinations are fluent and certain, you cannot rely on spotting them by how they sound — you have to build verification into the process. For high-stakes uses — medical, legal, financial, or anything a person will act on — keep a human in the loop to check output before it's trusted, and design the product so checking is easy: show sources, surface the passages an answer came from, make claims traceable. Treat every confident answer as a draft to be verified, not a verdict to be obeyed. This isn't pessimism about AI; it's how you use a powerful but occasionally-inventive tool responsibly — you build the checking in rather than assuming it away.

8 · A simple test you can run this week

9 · Glossary — every term, spelled out

Hallucination

When a model states something false with confidence, because it generated plausible text rather than a verified fact.

Plausible vs correct

The model aims to sound plausible; usually that matches the truth, but not always.

Uncertainty

A model has no reliable inner signal of doubt, so it can't naturally hedge when it's guessing.

Grounding

Giving the model real source text to answer from, instead of relying on its memory — the biggest fix.

Permission to abstain

Instructing the model that “I don't know” is an acceptable answer, so it invents less.

Verification

Checking important output before trusting it, and designing products so checking is easy.