Why AI makes up citations, and the fix

Ask a general AI chatbot for sources and you get beautifully formatted references: authors, years, journal names, volume numbers, DOIs. A worrying share of them do not exist. Students have submitted them, lawyers have been sanctioned over them, and examiners increasingly know to look for them. If you have ever pasted a chatbot's suggested reading into a scholarly database and found nothing, you already know the problem first-hand.

This guide explains the mechanism behind hallucinated citations, shows what a fabricated reference looks like up close, ranks the failure modes from easiest to hardest to catch, and then walks through the structural fix: a design in which a made-up reference has nowhere to exist. Understanding the why matters, because it tells you which solutions are real. If fabrication is baked into how these systems generate text, then better prompting is a mitigation, and only a different architecture is a cure.

Why AI makes up citations: models predict text, not truth

A large language model generates the most plausible next words given everything it has seen. That is the whole trick, and it is genuinely powerful. But a citation is a very regular text pattern: surname, comma, initial, year in brackets, plausible title, journal name, volume, pages. The model has read millions of reference lists, so it has learned the shape of a citation more thoroughly than almost any other structure in academic writing. It can produce one that looks perfect without any connection to a real paper, because producing the look is exactly what it was trained to do.

This is why hallucinated citations survive every prompt trick. Asking the model to 'only use real sources' changes the wording of what it produces, not the mechanism by which it produces it. The model has no internal marker separating a reference it genuinely absorbed from one it is assembling on the fly; both come out of the same next-word machinery with the same confidence. You are asking it to comply with an instruction it has no way to evaluate.

The problem is also worst exactly where you need help most. In a niche subfield, the model has seen enough of the field's citation style to fake the format flawlessly, and too little of the actual literature to know which papers exist. Strong knowledge of how references look combined with weak knowledge of what has been published is the perfect recipe for confident fabrication. Fake references in AI writing are not a bug that better models will simply outgrow: as long as citations are generated as free text, some of them will be invented, and the convincing format is exactly what makes them dangerous.

Anatomy of a hallucinated citation

Here is an invented example of the kind a chatbot produces, constructed for illustration: Larsen, M. and Chow, P. (2019), 'Working memory training and second-language attrition in adult learners', Journal of Cognitive Psychology, 31(4), 512-529. Every element is plausible. The surnames are common in the field. The journal is real. The volume and issue numbers are consistent with a 2019 date. The page range has a believable length for an empirical article. Nothing on its surface distinguishes it from a genuine reference.

Real fabrications are often hybrids, which makes them harder to catch. The model attaches genuine researchers to a paper they never wrote, because their names co-occur with the topic in its training data. Or it reproduces a real title with the wrong authors, the wrong year, or an identifier borrowed from an unrelated article. A quick search on the author names then finds real publications in roughly the right area, which feels like confirmation and is not.

The reliable test is resolution, not plausibility. Paste the identifier into the free DOI lookup and see what actually comes back: nothing at all, a different paper, or the claimed one. A reference either resolves to a specific record or it does not. Plausibility tells you nothing; resolution tells you everything.

Why 'only cite real papers' prompts don't stop fake references

Every few months a new prompt formula circulates that supposedly stops fabricated references: instruct the model to double-check itself, tell it to admit when it does not know, demand DOIs for everything. These help at the margins and fail at the core, for the reason above: the instruction asks the model to distinguish remembered references from confabulated ones, and it has no mechanism for making that distinction.

Web browsing and retrieval genuinely help, and it would be dishonest to pretend otherwise. A chatbot that fetches a real page can anchor its reference to something that exists. But the final reference is still free text the model writes down, so substitutions and transcription errors still happen, and nothing in the pipeline forces the sentence the citation supports to match what the fetched source says. Retrieval reduces the frequency of invention; it does not remove the possibility, and it does nothing for the subtler failure of a real paper cited for a claim it never makes.

There is also a workflow cost the prompt-fix framing hides. If your tool can fabricate, every reference it produces becomes your checking job, usually at the end of the project when the reference list is longest and your time is shortest. A mitigation that transfers hours of verification labour to you is not much of a fix.

The five failure modes of AI citations, ranked

Fabrication is not one failure but a family. Ranked from easiest to hardest to catch:

• Fully invented reference: authors, title, journal and identifier resolve to nothing. One database lookup catches it.
• Real authors, invented paper: genuine names from the field attached to a title that was never written. Harder, because searching the authors surfaces real, adjacent work that feels like confirmation.
• Real paper, mangled metadata: right paper, wrong year, wrong journal, wrong volume or pages. The work exists, but your reference list is still wrong, and examiners notice sloppy references.
• Real paper, wrong claim: the citation resolves cleanly, but the paper never says what your sentence claims. Every surface check passes; only reading the cited passage catches it.
• Real paper, since retracted: the work exists and once made the claim, and it has been formally withdrawn. Without a live check against retraction data, you cite it in good faith.

The fix is structural: citations as database objects, not text

First, be clear about what manual checking can and cannot do. Done diligently, it catches the first three modes. The fourth requires having the full text in front of you for every citation, re-read every time the surrounding sentence changes. The fifth requires consulting retraction data on an ongoing basis, because papers are withdrawn mid-project; you can run any paper through the free retraction checker right now. The two hardest modes are exactly the ones that survive a plausibility read of your bibliography, which is why a reference list can look immaculate and still be wrong where it matters.

CiteDash AI removes the possibility instead of discouraging it. A citation here is not text the model writes. It is a database row that links your sentence to a real paper record, and if a generated citation does not resolve to such a record, it is rejected before you ever see it. There is no free-text reference anywhere in the product, so a made-up reference has nowhere to exist.

Notice what this does to the failure modes above. The first three, the existence and metadata failures, disappear by construction: a reference that must resolve cannot be invented, and its metadata comes from the record rather than from the model's recollection. There is nothing to proofread for existence, because nothing can be displayed without resolving. That is the difference between a guardrail you must remember to apply and a data model that cannot represent the failure in the first place.

The same object design carries through to formatting. Your bibliography is derived from the same records: the Reference Manager renders them in any of twelve citation styles, and a compile produces DOCX, PDF or LaTeX with a citeproc bibliography. A reference cannot drift out of sync with the paper it points to, because there is only one object behind both.

Real papers aren't enough: the claim must match the source

The two remaining failure modes need more than resolution, and this is where most 'we cite real papers' tools stop short. A real citation attached to a claim the paper never makes passes every existence check. That is why every cited sentence in CiteDash is also checked against the source's actual full text by the Fact Checker and labeled supported, partial, unsupported, or unverified before it reaches you. If the full text is not held, the honest verdict is unverified, never a guess assembled from the model's memory of the paper.

Grounding on full text rather than the abstract is deliberate. An abstract is a compressed pitch: it rounds findings up, drops caveats, and omits the conditions under which results held. A claim can be consistent with a paper's abstract and contradicted by its results section. Verification that reads the body text catches what abstract-level checking waves through. For what each verdict means and the fastest way to fix it, read How verified citations work: the four verdicts.

Retraction, the fifth mode, is handled the same structural way: retracted papers carry a visible retraction badge in your library and are blocked from citation, so a withdrawn source cannot slip into your bibliography no matter how solid it once looked.

A worked example: one grounded paragraph, end to end

Say you are drafting a literature review paragraph on remote work and productivity measurement, with a dozen papers already saved in your project library and their PDFs attached. You ask the Thesis Editor for a paragraph on how productivity has been measured in this literature.

The draft is generated only from the full text of those papers; the AI cannot cite a paper it cannot read. Each sentence arrives with a citation that resolves to one of your library records. The Fact Checker then reads each cited sentence against the cited paper's body text. Suppose one sentence comes back partial: the draft said a study 'found productivity improved', while the paper's own results section reported self-reported productivity in a modest sample. You narrow the sentence to match what the paper measured, re-verify, and the verdict flips to supported.

Note what just happened. The failure a chatbot would have hidden, a real paper gently overclaimed, surfaced as a label you could act on in seconds, at the moment of writing rather than in the week before submission. Multiply that across every paragraph of a thesis and the difference is not convenience. It is whether your reference list is evidence or exposure.

Objections and answers

'Newer models hallucinate less, so this is a shrinking problem.' Less is not none, and a thesis is a zero-tolerance context: one fabricated reference found by an examiner is not offset by two hundred good ones. The direction of travel does not change the mechanism. Free text can always be invented; a resolved database object cannot. Build on the guarantee, not on the average.

'I will just check every reference myself.' Existence checks catch the easy failure modes and still take real hours across a full bibliography, repeated after every revision round. The hard modes require reading the cited passage for every claim, every time the sentence around it changes. That is precisely the labour you hoped the AI would save, returned to you with interest.

'My supervisor or a proofreader will catch anything wrong.' Supervisors sample; examiners sample more deeply, and they read your references against their own knowledge of the field. The defence is the single worst moment to learn that a citation does not hold. A checking process that depends on someone else's vigilance is not a process. It is a hope.

'A browsing-enabled chatbot already fixes this.' It improves the average, as covered above, and it leaves both the last-step free-text reference and the claim-source gap open. Improvement and impossibility are different products, and only one of them is a promise you can repeat to an examiner.

'I only use AI for summaries and explanations, never for references.' The failure follows the claims, not the reference list. A summary embeds assertions about what papers found, and when you later write those assertions into a chapter and attach citations by hand, the claim-source mismatch failure is alive and well. The checking burden exists wherever AI-shaped claims meet real sources; the only question is whether anything is checking systematically.

What grounded AI writing looks like in practice

Put together, the structural fix changes what writing with AI feels like day to day:

• Drafts are generated only from your project library's full text. The AI cannot cite a paper it cannot read.
• Every claim arrives with a citation that provably resolves to a real paper; unsupported prose is flagged in place, never smoothed over.
• Every cited sentence carries a verdict against its source's full text: supported, partial, unsupported, or unverified.
• Retracted papers are badged and blocked from citation at every step, and an originality pre-check runs before you compile.
• A full audit trail records every AI action and generates the AI-use disclosure your institution may ask for.

How to protect yourself today, whatever AI tool you use

If you are mid-thesis with a mixed toolkit, you can adopt the underlying discipline immediately:

• Resolve every reference before it enters your document: identifier first, title search second. If it does not resolve, it does not exist, however plausible it looks.
• Re-check retractions late in the project as well as early. Papers are withdrawn mid-write, and a citation that was sound in March can be a liability by September.
• For every important claim, keep the exact supporting passage next to the citation. If a tool cannot show you the passage, treat the claim as unverified.
• Log your AI use as you go: date, tool, task, what you kept. A disclosure reconstructed from memory months later is guesswork.
• Never let a reference into your bibliography that you have not personally seen resolve.

Try the difference yourself

The mechanism is easy to demonstrate. Paste your topic into a general chatbot, ask for sources, and check each one against a scholarly database. Then run the same topic through CiteDash and open any citation it produces: it resolves to a real record, and the cited sentence carries a verdict against that paper's full text, with the exact source passage one click away.

If your next question is whether any tool can honestly promise zero fabricated references, that is exactly what the companion piece answers: read Is there an AI that doesn't make up references? next.