Source-Driven Development: Why Your AI Agent Fabricates Stats (and How to Stop It)
TL;DR: Your AI agent will fabricate statistics. Not might — will. Vectara’s hallucination benchmark shows rates from 3.3% to 14.3% even on frontier models [1] source, and Columbia Journalism Review found that 8 generative search tools gave incorrect answers more than 60% of the time on news-citation queries [1]. Source-Driven Development (SDD) is a 4-step process — DETECT, FETCH, WRITE, CITE — that forces every factual claim through a verifiable source before it reaches production. This post breaks down why fabrication happens, how SDD stops it, and the patterns you can implement today.
The fabrication problem is bigger than you think
The numbers are not subtle. On Vectara’s updated hallucination benchmark (7,700+ articles, documents up to 32K tokens), Google’s best model scores 3.3% hallucination rate — and several frontier models exceed 10% [1]. DeepSeek-R1 hits 14.3% on the older, simpler dataset [1] source. These are summarization tasks where the model has the source document in context. If the model can’t stay faithful to text it’s actively reading, imagine what happens when it’s generating blog posts from training data.
The Columbia Journalism Review tested 8 generative search tools on 1,600 news-citation queries. Overall error rate: above 60%. Grok-3 hit 94%. Google Gemini hit 76% [1] source. These aren’t obscure tools — they’re the products millions of people use daily to get facts.
The BBC’s own study, published February 2025, found that more than half of AI-generated answers from ChatGPT, Copilot, Gemini, and Perplexity had “significant issues” when asked 100 news questions. Around 20% introduced factual errors — wrong numbers, wrong dates, fabricated statements. Thirteen percent of quotes attributed to BBC articles were either altered or didn’t exist [2] source.
McKinsey’s 2025 AI report adds the business dimension: 51% of organizations using AI saw at least one negative consequence, and nearly one-third cited inaccuracy as the primary issue [1] source.
This isn’t a corner case. It’s the default behavior.
Why AI agents fabricate (it’s not a bug)
LLMs are prediction systems. They generate the most probable next token given the context — they don’t verify truth. There’s no step between “this sounds right” and “this is correct.” The model doesn’t know what it doesn’t know.
MIT researchers found that AI models are 34% more likely to use confident language when generating incorrect information than when stating facts [3] source. The fabrication doesn’t come with a warning label. It comes with the same authoritative tone as a verified claim.
Training data makes it worse. Models learn patterns from text that includes statistics, study results, and projections — but the training cutoff means those numbers are frozen in time. An agent writing about “current” AI adoption rates in 2026 might confidently cite a 2023 figure because that’s what’s in its weights. It won’t tell you the data is stale. It won’t tell you there’s no source at all.
The core failure mode: no verification step between generation and publication. Most agent pipelines are generate → format → publish. There’s no gate that asks “can you prove this?” before the post goes live.
The 4-step SDD process
Source-Driven Development, formalized in Addy Osmani’s agent-skills repository [4], replaces memory-driven generation with a verifiable pipeline:
DETECT ──→ FETCH ──→ WRITE ──→ CITE
│ │ │ │
▼ ▼ ▼ ▼
Claim Get the Write with Full URL
needs a relevant the source citation
source? source in hand in proseDETECT: Before writing any factual claim — a percentage, dollar amount, projection, or capability statement — flag it. Ask: “Does this need a source?” If the claim is specific and verifiable, the answer is yes.
FETCH: Get the primary source. Not a blog post about the source. Not a Stack Overflow answer that references the source. The actual documentation, research paper, or official report.
WRITE: Write the claim with the source in front of you. This is the step most agents skip — they write from memory and add citations after, which means the citation might not actually support the claim.
CITE: Include a full URL citation in the prose. The reader — and your future self — must be able to verify every decision.
Source hierarchy
Not all sources are equal. SDD enforces a strict hierarchy [4]:
| Priority | Source | Example |
|---|---|---|
| 1 | Official documentation | react.dev, docs.djangoproject.com |
| 2 | Official blog / changelog | react.dev/blog, nextjs.org/blog |
| 3 | Web standards references | MDN, web.dev |
| 4 | Primary research papers | arXiv, ACM, IEEE |
Never cite as primary sources: Stack Overflow, blog posts, tutorials, AI-generated summaries, or your own training data.
Memory-driven vs source-driven content
The difference between agents that fabricate and agents that verify comes down to one question: where does the claim originate?
| Dimension | Memory-Driven | Source-Driven |
|---|---|---|
| Claim origin | Training data / pattern matching | Verified primary source |
| Citation timing | Added after writing | Source fetched before writing |
| Confidence calibration | High (always) | Calibrated to source quality |
| Error detection | None (agent trusts itself) | Source contradicts → claim removed |
| Stale data risk | High (training cutoff) | Low (fetched at write time) |
| Fabrication rate | 3.3%–14.3%+ [1] | Near zero (for cited claims) |
The fabrication rate in the right column isn’t zero because SDD doesn’t prevent all errors — it prevents unsourced errors. If a source itself is wrong, SDD won’t save you. But it eliminates the vast majority of fabrication: claims that exist because the model found them statistically plausible, not because they’re true.
Real-world consequences
AI fabrication isn’t theoretical. Damien Charlotin maintains a database of legal cases involving AI hallucinations — it now exceeds 1,450 identified cases [1]. Lawyers submitted briefs with fabricated case citations. Judges caught some. Others didn’t get caught.
The ECRI Institute ranked misuse of AI chatbots in healthcare as the #1 health technology hazard for 2026 [1]. When an agent fabricates a drug interaction or misstates a clinical guideline, the consequence isn’t a broken build — it’s a patient safety risk.
Stanford HAI’s study of legal AI tools found hallucination rates between 17% and over 34% on challenging queries [1] source. Legal research is a domain where precision is non-negotiable and the tools are actively being used for it.
The BBC study documented specific, concrete errors: ChatGPT said Ismail Haniyeh was still part of Hamas leadership months after his assassination. Copilot falsely claimed Gisèle Pelicot uncovered crimes she had blackouts about. Gemini misrepresented NHS guidance on vaping [2]. These aren’t abstract error rates — they’re specific falsehoods presented as fact by systems people trust.
Implementation patterns for agent builders
If you’re building AI agents that generate content, here are the patterns that actually reduce fabrication:
1. Pre-publish citation check. Run a scan that flags every percentage, dollar amount, and projection that lacks a [N] citation. Reject the post until every flagged claim has a source or is removed. This is the enforce-sources.py pattern from our content pipeline.
2. Quality ratchet gate. Block deploys when aggregate content metrics drop below stored thresholds. Track citation rate, word count, and placeholder absence. The floor only goes up — quality regressions block the deploy.
3. The “prove” phase is non-negotiable. In our 7-phase content lifecycle, Phase 4 (PROVE) is mandatory. Every claim gets checked. Every citation gets verified against the actual source URL. No exceptions.
4. Event-driven post-publish verification. After publishing, fire a post-publish event hook that verifies the URL returns 200, checks that external links resolve, and logs the result. This catches the cases where a citation URL was fabricated along with the claim.
5. Source-first prompt structure. Replace “write a post about X” with “fetch sources about X, then write.” The agent must show its sources before it starts drafting. If it can’t find a source for a claim, the claim doesn’t go in the post.
The goal isn’t to make AI agents perfect. It’s to make them honest — to ensure that every factual claim a reader encounters can be traced back to something real.
The bottom line
Your agent will fabricate statistics. The question is whether you build a pipeline that catches it. Source-Driven Development isn’t a nice-to-have — it’s the difference between an agent that’s useful and one that’s dangerous. DETECT the claim. FETCH the source. WRITE with the source in hand. CITE the source in prose. Four steps. Zero unsourced claims.
Sources
[1] Suprmind, “AI Hallucination Statistics 2026: 50+ Sourced Data Points,” https://suprmind.ai/hub/insights/ai-hallucination-statistics-research-report-2026
[2] The Guardian, “AI chatbots distort and mislead when asked about current affairs, BBC finds,” February 11, 2025, https://www.theguardian.com/technology/2025/feb/11/ai-chatbots-distort-and-mislead-when-asked-about-current-affairs-bbc-finds
[3] Tendem AI, “The True Cost of AI Hallucinations in Business Data,” https://tendem.ai/blog/true-cost-ai-hallucinations-business-data
[4] Addy Osmani, “source-driven-development skill,” GitHub agent-skills repository, https://raw.githubusercontent.com/addyosmani/agent-skills/main/skills/source-driven-development/SKILL.md
← Back to all posts
