Grounding: Making a Model's Answers Checkable

What this slice covers

The single most common complaint about generative AI is that it makes things up. This note covers the prompt-side techniques that reduce fabrication and, just as importantly, make the remaining errors visible: supplying source data, demanding citations, constraining output structure, letting the model reach for an external capability, and giving it a legitimate way to decline. This is the accuracy-and-grounding slice of prompt design; prompt components and prompt layout are covered separately.

Why fabrication happens

Recall what a model is doing: producing the most likely continuation. Nothing in that process consults a source of truth. A confident, well-formed, entirely fictitious answer is not a malfunction — it is the mechanism working exactly as designed on a question the model has no grounded information about. Every technique below is a way of changing what "most likely" means by changing what the model can see, or of making the falsehood cheap to detect.

Supply the data

The strongest lever is to stop asking the model to recall and start asking it to read. Give it the material to answer from, in the prompt, and instruct it to answer exclusively from that material. Microsoft's rule of thumb is that the closer your source material already is to the final form of the answer you want, the less work the model has to do — and less work means fewer opportunities for error.

This is worth internalising as a design principle rather than a trick. If your scenario depends on current, reliable information and is not purely creative, providing grounding data is strongly recommended. It also changes what a failure looks like: an ungrounded model that gets something wrong is unfixable from the prompt, while a grounded model that gets something wrong points you at your retrieval.

Demand citations

Asking a model not to fabricate rarely works; instructing it to cite the source for each statement works considerably better. The reasoning is elegant. If every claim must carry a citation, the model has to make two errors to produce an unsupported statement — the fabricated claim, and then a fabricated citation to go with it. Requiring both is a real constraint.

Placement matters too. Inline citations, sitting immediately next to the text they support, are a better mitigation than a reference list at the end, because the model has to anticipate the citation over a much shorter distance. As a side effect, you get an artefact a human reviewer can actually check.

Constrain the output structure

Structure is an accuracy technique, not just a formatting one. Ask a model to extract facts from a paragraph in free text and it will hand you compound statements — X does Y and Z — which are hard to verify because half can be true. Ask for a fixed shape instead, such as entity-relationship-entity triples or a classification with a bracketed reason attached to each item, and each unit becomes independently checkable. Specifying the structure of the output has a significant effect on the nature and quality of what you get back.

Let the model reach outside itself

Sometimes the honest answer is that the model should not be answering from its own parameters at all. An affordance is an external capability — search being the obvious one — used in place of recall, and it mitigates both fabrication and staleness.

The simplest pattern is manual and instructive: prompt the model to emit the calls it wants, stop generation there, run them yourself, paste the results back into the prompt, and ask for the final answer over that evidence. Working through this by hand is worth doing once, because it is exactly the loop that agent tooling later automates on your behalf. Understanding the loop makes tool-enabled agents feel like an obvious convenience rather than magic.

Give the model an out

A model with no permitted way to fail will fail creatively. Include an explicit alternative path — an instruction to respond that the answer is not present, for instance, when the answer genuinely is not in the supplied text. This one line converts a fabrication into a clean signal your application can handle.

Mistakes people make

The first is believing a prohibition works: telling a model never to invent information is not a mitigation, whereas citations, structure, and an explicit out are. The second is skipping validation. Even with these techniques applied well, you still need to check what the model produces, and a prompt that works beautifully in one scenario may not generalise to another. The third is treating grounding as purely a prompt problem when the real defect is upstream — the retrieved passage never contained the answer. The fourth is not reading the published limitations of the models you use; understanding what they cannot do is as much a part of the job as knowing how to prompt them.

For the exam, carry three ideas: ground with data, make claims traceable, and always leave a legitimate way to say nothing.