The draft read perfectly. It was a market-sizing memo for a board meeting, written in two hours instead of two days, and the partner skimmed it once before it went out. Clean prose, confident structure, a tidy supporting statistic in the third paragraph: “the segment has grown at a 23% compound annual rate since 2021.” The number was specific. It was plausible. It was sourced to a research firm that publishes exactly this kind of figure. And it was fabricated — the model had assembled a real-sounding citation around a number that appears in no report anywhere. Nobody caught it, because nothing about it looked wrong. That is the whole problem with verification by feel.
Most senior practitioners verify AI output the way they proofread their own writing: they read it, and if nothing jumps out, they ship it. That works for catching typos. It does not work for catching a confident, well-formed, false claim, because the failure mode of a language model is precisely to produce text that reads right while being wrong. The errors that survive a skim are the dangerous ones. Spot-checking isn't a method. It is the absence of one.
This is not an abstract risk. The most rigorous controlled study of the question to date — METR's 2025 randomized trial of experienced developers — found that the participants believed AI made them roughly 20% faster while it actually made them about 19% slower. The gap between felt speed and real speed lived almost entirely in one place: the time spent reviewing, correcting, and re-prompting output that looked done but wasn't. Verification is where the productivity goes to die. The only way to make it cheaper without making it worse is to turn it from a vibe into a discipline — a set of repeatable techniques, each matched to what is actually at stake.
Five techniques. Each is concrete, each is learnable in one read, and each catches a different class of error. You will not run all five on every output. Choosing which to run is the second half of the skill.
The five techniques
These are ordered roughly by cost, from a thirty-second move to a full second-reader pass. They are also complementary: source-forcing and citation checking attack fabricated facts, claim decomposition and the junior test attack hidden logical gaps, and adversarial re-prompting attacks the things you didn't think to check at all.
Technique 01 · Source-forcing
Make the output show where each claim came from.
Before you read for content, re-prompt for provenance: “For every factual claim, statistic, and quote, mark the source it came from — and flag anything you generated without a source.” A grounded answer can do this. An ungrounded one will either fabricate plausible citations or, more usefully, confess that a claim came from its own training data. Either way you have converted an undifferentiated wall of confident prose into a map of which sentences are load-bearing and which are inventions. You are not yet checking the claims. You are finding out which ones need checking.
Technique 02 · Claim decomposition
Break the output into atomic, separately checkable assertions.
A paragraph reads as one thing; it is usually four or five things welded together. “The segment grew 23% annually, outpacing the broader market, driven primarily by enterprise adoption” is three distinct claims — a growth rate, a relative comparison, a causal attribution — and they fail independently. The growth number can be right while the causal story is invented. Decomposition forces you to verify each one on its own terms instead of letting a true claim launder a false one sitting next to it. The smaller the unit, the harder it is for a wrong assertion to hide inside a right sentence.
Technique 03 · Adversarial re-prompting
Turn the model against its own draft.
The same system that produced the output is a competent critic of it if you point it the right way: “Argue the opposite of this memo's conclusion,” or “Identify the single weakest claim here and explain why a skeptical reader would reject it,” or “What would have to be true for this recommendation to be wrong?” This catches a different category than the first two techniques — not fabricated facts, but soft reasoning, unstated assumptions, and the kind of one-sided framing that a model defaults to when it is trying to be agreeable. The output that survives an honest adversarial pass is meaningfully sturdier than the one that was only ever asked to be confident.
Technique 04 · Citation checking
Open every link. Read the actual passage.
A citation is not verification — it is a pointer to where verification can happen. The failure mode here is trusting the existence of a citation instead of its contents: the link is real, the report is real, and the specific number the model attributed to it is not in there. Open it. Find the sentence. Confirm the claim is actually supported by the source, not merely adjacent to it. This is the slowest technique by hand and the one most worth making fast, because it is the one that catches the fabricated-statistic failure that opened this piece.
Technique 05 · The junior test
Would a sharp second-year catch this?
The cheapest and most underrated check is a question, not a tool: “If I handed this to my most careful junior colleague and asked them to find one thing wrong, what would they say?” It works because it shifts you out of author-mode — where you are invested in the draft being done — and into reviewer-mode, where you are looking for the flaw. A surprising fraction of AI errors are the kind a competent human reviewer catches on instinct: a figure that doesn't pass the smell test, a claim that contradicts something two paragraphs up, a confident assertion about a thing the firm knows to be more complicated. You already have this reviewer. It is you, asked the right question.
Notice what these have in common. None of them is “read it carefully.” Each one names a specific class of error and a specific move that surfaces it. That is the difference between a discipline and a vibe: a discipline tells you what you are looking for before you start looking.
Calibrating effort to stakes
Running all five techniques on every output would erase the time savings entirely — you would be back to METR's 19% slower, this time on purpose. The skill is not maximal verification. It is proportionate verification: matching the depth of the check to two things at once — how much it costs to be wrong, and how hard the output is to verify in the first place. Plot any task on those two axes and the right verification depth falls out of the quadrant it lands in.
Technique depth by quadrant
Stakes × Verifiability
Rose · All five, plus a human
Hard to verify, expensive to get wrong.
Decompose, source-force, check every citation, re-prompt adversarially — then a qualified human signs off. AI is scaffolding, not the deliverable.
Amber · Source-force + cite-check
Easy to verify, but the downside is real.
Force provenance, open every link, run the junior test. Verification is fast here — so there is no excuse to skip it.
Slate · Decompose + junior test
Hard to verify, but bounded downside.
Treat the output as suggestive. Decompose the reasoning, ask the junior question, and don't let it become load-bearing without escalating.
Emerald · Spot-check
Easy to verify, cheap to get wrong.
A genuine ten-second read is enough. Reformatting, outline expansion, table cleanup. Most real productivity lives here.
The quadrant tells you which techniques to reach for; the verification ladder tells you how far up to climb within them. Think of the five techniques as the instruments and the ladder as the dial that sets how hard you turn each one. The discipline is matching the rung to the downside, not defaulting to the easiest rung because the draft happened to look good.
Spot-check · 10 seconds
The junior test, run silently. “Does this look approximately right?” Sufficient for emerald-zone work where a wrong answer costs minutes.
Decompose & source-force · 1–2 minutes
Break the output into atomic claims and force each to name its source. The fast first pass for anything that will be read by someone outside the room.
Cite-check & adversarial pass · 5–15 minutes
Open every link to its source passage; re-prompt the model to attack its own weakest claim. The floor for client-facing or published deliverables.
Human sign-off · variable
A person with subject-matter authority owns the output. Required for rose-zone work — attributed quotes, legal and regulatory claims, anything irreversible.
Running rung 1 on a rung-3 task is how the fabricated statistic ships. Running rung 4 on a rung-1 task is how you recreate METR's slowdown by hand, drowning a low-stakes reformatting job in verification it never needed. Calibration is not a nicety. It is the entire economic case for using AI at all: the gains are real only if verification costs less than the time saved, and the only way to keep that inequality true is to spend verification effort where the downside actually lives.
What citation checking can and can't promise
It is worth being precise about what the citation-checking technique buys you, because it is easy to over-trust. A citation tells you where a claim is supposed to come from. It does not, on its own, tell you the claim is true — the source can be misread, the number can be lifted from the wrong table, the quote can be real but stripped of its qualifying context. The technique is only as good as the human who opens the link and reads the passage. Anything that hands you a citation and lets you feel verified without reading the source has made the problem worse, not better.
A caution worth keeping
Treat citations as assistive, not authoritative. They are built to help you locate and support a claim faster — not to certify it. A linked source still has to be opened, read, and judged by a human before the claim it supports is allowed to ship. The point of good tooling is to make that human step cheap, never to remove it.
This is also where the techniques compound rather than substitute. Source-forcing tells you which claims are load-bearing; decomposition isolates them; citation checking confirms the ones with sources; the adversarial pass and the junior test catch the ones that have no source because they were reasoning rather than fact. Used together they cover the full surface of how AI output goes wrong — fabricated facts, unsupported attributions, soft logic, and the quiet contradictions that only a careful reader notices.
In Hone Studio
Citation checking gets dramatically cheaper when the citations are already attached. With Knowledge Base mode on, the Assistant grounds every answer in your own uploaded documents and surfaces source markers alongside a sources panel showing exactly which entries it retrieved — so “open every link” becomes one click into the actual passage rather than a hunt across the open web. The posture is deliberately conservative: those citations are assistive, not authoritative, and every AI output is a draft until a person signs off. The tooling does not remove the human from the loop. It makes the human's job fast enough that they actually do it.
Building it into the workflow: gates, not heroics
The reason verification fails in practice is almost never that people don't know how. It is that it depends on individual diligence at the exact moment diligence is scarcest — late, tired, under deadline, with a draft that already looks done. A discipline that survives only when everyone is at their best is not a discipline. It is luck with good intentions.
The fix is to stop relying on heroics and start building gates: explicit checkpoints where a deliverable cannot advance until the appropriate techniques have run. The reframing is small but decisive. Instead of “remember to verify,” you make the verification step a structural precondition of moving forward.
Decide the quadrant before the model runs, not after. Knowing a task is rose-zone up front changes how you prompt and tells you which techniques are non-negotiable on the way out.
A client-facing draft does not leave the building without a cite-check and an adversarial pass on the record. The requirement travels with the document type, so it doesn't evaporate when the author is in a hurry.
Source-forcing and the junior test cost almost nothing and catch a disproportionate share of errors. Run them on everything; reserve the expensive rungs for the quadrants that earn them.
For anything irreversible, the final gate is a human signature, not a tool. Every AI output is a draft until a qualified person owns it. That principle does not bend with model quality.
In Hone Studio
The highest gate is built into how the platform works: every AI output is a draft, generated for human review rather than acted on automatically. Nothing the Assistant (and, as they ship, the Generator and Review) produces takes effect without a person signing off — the same human-in-the-loop discipline this section argues for, enforced as a default rather than a policy people have to remember. Grounding answers in your own Knowledge Base makes the cheap rungs (source-forcing, opening a citation) nearly free, so the gate is fast enough to actually hold under deadline pressure.
This is the same insight the broader literature keeps arriving at from different directions. McKinsey's State of AI work finds that the organizations capturing real value are the ones that redesign the workflow around AI rather than bolting it onto the old one — and a verification gate is exactly that kind of redesign. Workday's 2026 “Beyond Productivity” research found that close to 40% of the time AI saves gets clawed back in rework; the gate is what stops that rework from arriving as a surprise after the deliverable has already gone out, when it is most expensive to fix. Verification that happens at a gate is cheap. Verification that happens after a client reads a fabricated statistic is not verification at all. It is damage control.
The practitioners who trust AI most
There is a tempting but wrong conclusion to draw from all of this — that the careful practitioner is the one who uses AI least, hedging every output with suspicion. The opposite is true. The people who get the most durable leverage out of these systems are the ones who verify most systematically, because systematic verification is what lets them lean on AI for real work instead of treating everything it produces as suspect.
Trust, in any serious professional context, is not the absence of checking. It is the presence of a checking process good enough that you can rely on what passes it. A surgeon trusts a checklist. An auditor trusts a procedure. The practitioner who has internalized these five techniques and built them into gates does not read every AI output with dread — they read it knowing that anything genuinely wrong will be caught by the move they are about to make. That is what lets them move fast.
Spot-checking by feel produces the opposite: a vague, permanent unease, and the occasional fabricated statistic that slips through precisely because it looked like all the rest. The fix was never to look harder. It was to know, before you looked, exactly what you were looking for. The practitioners who trust AI the most are the ones who never verify by vibe.