What shifts for verification as work with AI?

The shift

Producing plausible output — code, analysis, a legal draft, a diagnosis, a financial model — goes from bounded by human effort to near-free and unbounded, while checking whether that output is actually correct stays exactly as expensive as it ever was. The production-to-verification cost ratio inverts: verification was the cheap tail folded into the producer's job because production dominated the bill, and now it's the dominant cost and the only human-owned act left.

The axioms

• Whoever produces the thing also verifies it. Rests on verification being cheap relative to production — a small tax on the producer's time, not worth splitting into its own role, because the expensive part was making the artifact at all.
• A plausible-looking artifact is a decent proxy for a correct one. Rests on effort being a costly, honest signal: producing something fluent, internally consistent, and well-formed took competence, so form correlated with substance.
• You can check everything that gets produced. Rests on production volume being capped by human throughput — the amount of output arriving for review stayed within the amount a human could actually read.
• Verification cost scales with how much you produce, and you can budget for it. Rests on a stable ratio: check-time was a roughly fixed multiple of make-time, so more output meant proportionally more checking, predictably.
• The producer understood the thing well enough to stand behind it. Rests on production implying comprehension — you couldn't make a working artifact without holding a model of why it works.

Invalid axioms

1. Whoever produces the thing also verifies it. Production collapsed toward free; verification didn't move. The tax that was small relative to make-time is now the entire cost, so folding it into "the producer's job" under-resources the only expensive part of the work. The habit-trap: orgs still budget, staff, and price as if verification were a rounding error on production, and still assign it to the same person who (with AI) barely touched the artifact — so the check gets the least attention exactly when it needs the most.
2. A plausible-looking artifact is a decent proxy for a correct one. Fluency and internal consistency were expensive to fake; now they're the cheapest thing a model produces. Confidently-wrong is the default failure mode, and the surface signals that used to correlate with substance — clean prose, passing tests, a well-structured argument, a citation that looks real — are precisely the signals AI reproduces for free. The habit-trap: reviewers, managers, and downstream consumers still read polish as evidence of care, so the proxy that let people skip deep checks now actively hides the errors.
3. The producer understood the thing well enough to stand behind it. When output is accepted with light editing, production no longer implies comprehension — the person whose name is on it may never have built a model of why it's right. The habit-trap: accountability still routes to "whoever produced it" as if that locates someone who can explain it under questioning.

Unchanged axioms

1. Someone accountable must own whether the output is correct. A model can't be liable, can't be fired, can't sign the audit. Verification is the act of converting probabilistic output into something a human is willing to answer for, and that willingness stays scarce and human. AI didn't remove the owner — it widened the gap between the owner and the thing they're vouching for.
2. Verifying against ground truth is a different and harder act than producing. Generating a plausible answer and confirming it's the right one are not the same skill, and AI only made the first one abundant. Checking still requires an external anchor — running the code, reproducing the number, reading the primary source, examining the patient — and that anchor doesn't get cheaper because the draft did. Where no ground truth is cheaply accessible (novel judgment, contested facts, the future), verification stays genuinely expensive and partly irreducible.
3. Judgment about what's worth verifying, and how hard, has no shortcut. Not everything needs the same scrutiny; deciding which outputs are high-stakes enough to check deeply and which can pass on a glance is itself a scarce call. AI can't set that risk threshold because it can't own the consequence of getting it wrong.

New axioms

1. You cannot human-verify at the volume AI produces, so what gets checked and what ships unchecked becomes a resourcing problem nobody sized for. The old ratio (check-time as a fixed multiple of make-time) is gone: make-time went to zero and check-time didn't, so verification demand is now unbounded while verification capacity is flat. Triage — deciding what to check and how deeply — becomes a first-class function, and no field has a defensible method for it yet.
2. Verifying AI output with more AI relocates the problem without closing it. The obvious move is to scale verification with the same tool that scaled production — AI checkers, AI graders, AI reviewers. But a confidently-wrong verifier is worse than none, because it removes the felt need for human scrutiny while providing none of the protection, and its false-negative rate is unknown and drifts as both the model and the domain change. Nobody has a reliable way to know, in production, how often the automated check is silently passing wrong things.
3. As models get more reliable, the verification burden shifts but doesn't vanish — and higher reliability makes it harder to stay vigilant. This is the call that hinges on something moving fast. Mid-2026 models are wrong less often than a year ago, so the naive read is that verification shrinks toward zero. But a lower error rate that's still nonzero is arguably more dangerous: rare, hard-to-spot errors buried in mostly-correct output erode the reviewer's alertness precisely because the output is usually right. The burden moves from catching frequent obvious errors to catching rare subtle ones in a stream you've been trained by experience to trust — a harder verification task, not an easier one.
4. When verification is separated from production, who holds the model needed to verify? If the producer no longer comprehends the artifact (INVALID #3) and the verifier didn't make it, verification requires reconstructing understanding of something nobody built a model of. The skill of verifying-what-you-didn't-produce — reading for defects in code, analysis, or argument you'd never write yourself — is now the core competence, and it's neither taught nor hired for as such.

Where it breaks

The sharpest collision: orgs still treat verification as a cheap tax folded into production (INVALID #1) at the exact moment production volume made human verification-at-volume impossible (NEW #1). The result is that the check silently degrades to "whatever the barely-involved producer had time to glance at" — and because fluent output reads as trustworthy (INVALID #2), nobody notices the check stopped happening. The proxy that let everyone skip deep verification now hides that verification isn't being done at all.

The second collision is temporal and easy to miss: the more reliable models get, the more the field assumes the verification problem is solving itself (NEW #3), so it under-invests in verification capacity right as rising volume and rarer-but-subtler errors make that capacity matter most. Fewer visible errors get read as "we can check less," when the honest reading is "the errors that remain are the ones our attention is least equipped to catch."

ai-axioms.vercel.app/axioms/society/verification-as-work-ai-axioms