Everything AI Fabricates When Editing an Article

"AI hallucinates" is as useful as "it crashed." After 20+ revision passes, I built the taxonomy.

In Part 2, I described a content-revision skill with 47 rules, each one a mistake I caught. But I glossed over the mistakes themselves. What exactly does AI fabricate when you ask it to edit an article?

After 20+ revision passes across four articles, the failures stopped looking random. They fell into eight categories, each with a root cause in how language models process information and a specific verification method with a measurable time cost. "AI hallucinates" tells you as much as "it crashed." "The model compressed a qualified position into a single adjective because it optimizes for conciseness over fidelity" tells you what to look for and how to prevent it.

the taxonomy

Ordered by verification cost, cheapest first. The 2-second checks catch the easy fabrications. The 10-minute checks catch the ones that destroy your credibility.

Slug errors. AI generated the-ai-doesnt-learnt-the-prompt-evolves.md for one of my articles. "Learnt" after "doesn't." A grammatical error baked into a permanent URL. The model generates filenames from title text without applying the same grammatical checking it uses for prose. Verification: read the filename aloud. Cost: 2 seconds.

Number rounding. "187 commits" became "about 200 commits." In data-driven writing, precision is the credibility. The model defaults to human rounding conventions where approximation is normal, but when your argument depends on specific data, the original number is always stronger. Thirty seconds to compare against the source.

Stale reference survival. I updated "6 tools" to "8 tools" in the headline after adding Supermemory and Wax. But "three of the six" survived in the body text. Two AI revision passes missed it. The model edits locally and doesn't propagate changes. In a later article, "identical architecture" overstated convergence across memory tools and survived two passes before I caught it on the third manual read. Verification: after any number change, full-text search for the old value and all derivative phrases. Cost: 2 minutes.

Link fabrication. AI confirmed every URL in a draft was valid. I clicked them. Four returned 404. The model constructs pattern-compliant strings, not verified addresses. github.com/user/repo follows the right pattern. The user doesn't exist. The model cannot browse the web during generation, so it builds URLs from pattern-matching, not from checking. Verification: click every link. Cost: 1-2 minutes per link.

Project misdescription. AI described MemSearch, ClawVault, and Rowboat based on their names. Each description was wrong on specifics. "MemSearch" sounds like it searches memory, which is correct at 10,000 feet and wrong on every implementation detail. The model generates descriptions from the name's semantic associations, not from the README. Verification: open the repo, read the actual description, compare claim by claim. Cost: 5 minutes per project.

Metrics fabrication. AI wrote "822,000 followers" for an account. The number was invented. Every social count across all four articles was fabricated when not explicitly provided in the source material. The model has training data with metrics from various dates. It interpolates, producing plausible numbers that match no real point in time. Verification: open the live profile, screenshot the actual number. Cost: 5-10 minutes per metric.

Timeline invention. This category is harder to catch because the dates look reasonable. AI assigned specific release dates to tools that were either wrong or unverifiable. The model has a training cutoff and fills temporal gaps with plausible dates without flagging that it's guessing. Checking requires git logs, tweet timestamps, or publication dates, and the cost varies wildly: 1 minute when the source is a tweet, 10 minutes when you're digging through git history.

Quote distortion. AI rewrote David Crawshaw's position on agent harnesses from "real but eclipsed" to "agent harnesses haven't improved much." One rewrite compressed a qualified, nuanced position into a dismissal. In a later article, AI wrote that Levelsio "posted a prompt" when he asked a question and Vadim Strizheus posted the answer. The model compressed a two-person interaction into one. This is fabricated meaning, not fabricated facts. Verification: find the original source, compare exact wording, check that qualifiers survive. Cost: 10 minutes per quote.

I caught these patterns writing the articles that describe these patterns. The taxonomy validates itself.

plausibility, not truth

Every category is a variation of one mechanism: the model generates what looks right based on token patterns. It doesn't check whether the URL resolves, the number is current, or the quote preserves the original nuance.

Marily Nika describes the core behavior: feed the model messy real data and watch it "confidently invent structure." She found the model hallucinated a roadmap from a casual Slack thread, assigned wrong owners, and turned offhand comments into commitments. The same mechanism produces every category in the taxonomy. Metrics: plausible numbers in the right range. URLs: pattern-valid addresses that don't resolve. Quotes: compressed versions that read well but lose nuance. Projects: name-inferred descriptions that are directionally correct but specifically wrong.

The model fills gaps with plausible-looking structure. In content editing, those gaps are facts.

the same failure mode in code

The parallel to my engineering projects is direct. In my deployer agent, AI generated Terraform configurations for servers it had never SSH'd into. Plausible configs. Correct syntax. Wrong environment. The deployer's CRITICAL FIXES section has 8 entries, each discovered through real-world deployment debugging: Docker images built on ARM that failed on AMD64 servers, uppercase server types that broke case-sensitive APIs, health checks pointed at wrong ports. Each one was structurally correct and environmentally wrong.

In writing, the same pattern repeats. The model generates metrics for a tweet it has never fetched and URLs for repos it has never visited. It compresses quotes from articles it cannot re-read. The deployer's 8 critical fixes and the content taxonomy's 8 categories share the same root cause: the model builds structure from patterns, not from checking the state of the world.

The harness engineering pattern from Part 2 applies directly. The 8 fabrication categories map to 8 prevention rules in my content-revision.md. The taxonomy is the harness, applied to content.

why AI can judge style but not truth

The LLM-as-a-Judge survey found that LLMs align well with expert judgment for evaluation tasks. But the survey also documents real risks: biases, hallucinations, and format brittleness. The taxonomy explains where the boundary falls.

Style is structural. Parallel construction, hedging, flow, sentence rhythm. The model judges structure well because structure is what it models. Truth is environmental. Does this URL resolve? Is this number current? Did this person actually say this? The model can't access the environment during evaluation any more than it can during generation.

StrongDM shifted from boolean testing ("tests green") to what they call "satisfaction" testing: what fraction of trajectories satisfy the user? The same distinction applies to content. AI-edited prose satisfies the style check. It may not satisfy the truth check. "Reads well" and "is true" require different verification layers.

AI can judge whether prose reads well. It cannot judge whether prose is true.

The problem compounds over longer documents. Manus fights what Anthropic calls "attention budget depletion" over roughly 50 tool calls per task. The same degradation happens during content revision: the model's grip on facts loosens over longer articles, and fabrication rates increase by the later sections. Section-by-section revision from Part 2 partially mitigates this, but the underlying mechanism remains.

Boris Cherny runs Opus at maximum effort for everything. The taxonomy still applies. A stronger model fabricates less, not zero. The categories are model-agnostic.

the irreducible human pass

Fact verification cannot be delegated to AI. Not to a better model. Not to a second pass. Not to a plugin. The human must click the link, check the number, read the original quote.

But this isn't a limitation story. The 5-pass revision system from Part 2 encodes this boundary explicitly: AI handles structure, voice, and formatting. The human handles truth. The taxonomy makes the boundary actionable by ordering verification costs. Sweep the 2-second checks first. Allocate time for the 10-minute ones.

Across all three pieces in this series, the same pattern holds: AI generates fast, humans verify slow, and the competitive advantage lives in how quickly you encode what you learn.

Postscript, Feb 2026: The evidence correlation skill I built after this article partially automates the verification I said couldn't be automated. AI now cross-references every claim against curated sources and flags VERIFIED/UNVERIFIED status. The taxonomy still holds — the human role shifted from "do all verification" to "verify the AI's verification." Part 4 explains where the boundary moved.

This is part 3 of a series on AI-assisted writing. Part 1: "AI Writes Code, I Write Prose" explains why the ratio inverts. Part 2: "47 Rules, Each from a Real Mistake" shows the system. Part 4: "The System Outgrew the Series" traces the evolution. Part 5: "I Gave My AI a Brain" builds the brain.

Built in Porto. Data from real articles, real revision passes, real fabrications caught.