The cost of generating things — sentences, code, images, molecules, marketing plans, entire strategy decks — is collapsing toward zero. The cost of knowing whether the generated thing is correct, safe, and true has barely moved. When those two curves cross, the binding constraint on nearly everything flips from generation to verification, and value, margin, and power follow the constraint the way water follows a slope.
This is the single reframing I'd hand a founder trying to place a bet in the AI economy: stop asking what AI can now produce cheaply, because the answer is converging on everything. Ask what becomes expensive when production is free. The answer is verification, and it is about to be the scarcest resource in the economy.
Two cost curves, moving in opposite directions
Generation had a scaling law. Verification does not.
The price of a fixed unit of model output has been falling roughly 10x a year, which means a competent first draft of almost anything — a function, a contract clause, a landing page, a plausible research hypothesis — is now a rounding error. Marginal cost per generated artifact is approaching the cost of the electricity to emit the tokens. That curve is the whole story of the last three years, and it is not slowing.
Now look at the other curve. To know whether a generated contract clause will hold, you still need a lawyer's judgment. To know whether generated code is correct, you still need review, tests, and a security pass. To know whether a generated molecule treats a disease, you still need a wet lab, and the readout is measured in years. The per-unit cost of verification is roughly flat, because it is bounded not by compute but by contact with reality — by an expert's scarce attention, or by an experiment that runs on wall-clock time. Measurement does not have a scaling law. Neither does judgment.
Here is the part most people miss, and it is the mechanism that turns a nuisance into a crisis. Cheaper generation does not merely leave verification untouched; it floods it. This is Jevons' paradox — making a resource cheaper raises total consumption of it rather than lowering the bill. When a competent draft costs a penny, you don't generate the same number of drafts more cheaply. You generate a hundred times more of them. The pull request that used to be 200 lines is now 2,000. The one candidate compound is now 10,000. The single campaign is now forty A/B variants.
So run the arithmetic. Total verification cost equals the flat per-unit cost of checking, multiplied by an exploding volume of things to check. One term held constant; the other went up two orders of magnitude. Verification doesn't just stay the bottleneck — it becomes the dominant line item in every process it touches. The organization that 10x'd its generation without 10x'ing its verification capacity did not get 10x more productive. It got 10x more unreviewed liability, and it will find out which pieces were wrong in the most expensive possible order.
The asymmetry that decides who wins
Why doesn't AI just automate the checking too? For a large part of the space, it will, and that is the good news. The reason it can't do so uniformly is the deepest structural fact in this whole argument, and it comes from complexity theory.
For the class of problems in NP, a candidate solution can be verified in polynomial time even when finding it appears to require exponential search. Multiply two large primes and checking the product is trivial; factoring the product back into primes is, as far as anyone knows, brutally hard. The widely-believed P≠NP conjecture is precisely the formal claim that for these problems, verifying is fundamentally easier than solving. This is not a curiosity. It is the reason human-plus-AI works at all: you let the machine pay the generation-and-search cost, which just went to nearly free, and you let a much cheaper verifier confirm the result. When verification is cheaper than generation, the leverage is enormous.
The trap is assuming that asymmetry runs the same direction everywhere. It doesn't. A second class of problems is cheap to generate and savagely expensive to verify. A scientific hypothesis takes seconds to state and years to falsify. A strategy takes an afternoon to write and five years to know if it was right. A claim about the world takes one sentence to assert and a career to confirm. For these, there is no short certificate. The only verifier is reality itself, running at the speed of reality, and no amount of cheap generation shortens that loop.
That gives a clean rule for where value and human labor concentrate. Value does not sit where generation is hard — generation is no longer hard anywhere. Value sits where verification is hard, because that is where the scarcity now lives. Full autonomy arrives fast in domains with cheap machine-checkable verification and stalls indefinitely in domains where the check requires contact with a slow, expensive world.
| Domain | Cost to generate | Cost to verify | Where value lands |
|---|---|---|---|
| Formal math / proofs | high | trivial (machine-checked in Lean) | AI generation is pure leverage; verification is solved |
| Code | near-zero | real but tractable (tests, review, security) | verification layer: CI, static analysis, red-teaming |
| Agent workflows | near-zero | hard (path-dependent, no golden trajectory) | trajectory evals and guardrails |
| Open-ended science | near-zero | brutal (falsification against reality, years) | humans plus the wet lab stay load-bearing |
| Taste / strategy | near-zero | hardest (long-horizon, weakly falsifiable) | human judgment is the moat |
| Media / public claims | zero | scarce (provenance, fact-check) | trust and authentication infrastructure |
The same inversion, four times
Code is the cleanest case because the loop is fast and the verifier is partly machine-readable. Writing code was never the expensive part of software; understanding, reviewing, testing, and securing it was, and that is now the entire job. When an engineer emits a thousand lines in a minute, the constraint moves entirely to the review queue, the test suite, and the security audit. The durable products here are not better code generators — those collapse into the frontier labs. They are the verification layer: continuous integration that actually catches regressions, static analysis, dependency and supply-chain scanning, automated test generation, fuzzing. The margin migrated from writing to checking.
Science is where the asymmetry is most extreme. An LLM can generate a thousand plausible mechanistic hypotheses about a disease before lunch. Every one of them is worthless until it survives contact with an experiment, and the experiment is the part that costs a hundred thousand dollars and eighteen months. The bottleneck in AI drug discovery isn't the model, it's the ground truth — the scarce, confounded, half-reproducible labels against which any generated hypothesis has to be falsified. Generation went to zero; falsification did not move at all. Which is exactly why the field posts real wins where verification is cheap and standardized — binding-pose geometry, checked against a curated structure database — and keeps slipping where verification routes through whole-organism biology. The model was never the rate-limiting step. The verifier was.
Agents are where teams are learning this the hard way right now. An agent taking an action is cheap; knowing whether the trajectory that produced the action was sound is hard, and it is hard for a specific reason — there is no golden path to diff against, and the same final answer can come from correct reasoning or from luck. You can't evaluate an agent you can't specify, and the reason enterprise pilots die at "impressive demo, never shipped" is that the demo verifies a single sample from an unknown distribution. The generation was always going to be impressive. The verification — proving it will do this again, on an input you haven't seen, for the reason you think — is the thing nobody built, and the thing the buyer actually pays for.
Media and public trust is the inversion at civilizational scale. When producing a photorealistic image, a cloned voice, or a fluent article costs nothing, the scarce good is not content. It is provenance — the ability to verify that a thing came from where it claims and means what it appears to. Every institution we built to certify truth — peer review, the audit, the newsroom, the credential — was designed on the assumption that generating a convincing artifact was itself expensive, which made the artifact weak evidence of effort and authenticity. That assumption is now false. The verification infrastructure to replace it — cryptographic content authentication, chains of custody for evidence, fact-checking that operates at machine speed — barely exists yet.
The forecast, stated as a forecast
Here is where I'm reasoning past the data, so label it plainly: this next part is a bet, not a report.
I think the ratio inversion reorganizes institutions the way the printing press and the assembly line reorganized theirs, and along the same logic. Most durable institutions are, underneath, verification machines built for an era when generation was the expensive step. Peer review verifies claims. Courts verify facts and liability. Auditors verify books. Universities verify competence and issue a certificate that others trust. Journalism verifies events. Every one of these was calibrated to a world where the flow of things-needing-verification was throttled upstream by the cost of producing them. Remove that throttle and their throughput assumptions break at once.
My forecast: the defining institutional fights of the next decade are not about who can generate — that fight is over, and the model providers won it. They are about who has the legitimacy and the capacity to verify. Which body certifies that a piece of media is authentic, that a scientific result is real, that an AI system is safe to deploy, that a credential means anything. The new winners are organizations and protocols that can verify at scale and be trusted to have done it honestly. That is a different skill from generation, a different cost structure, and largely a different set of players. I could be wrong about the timeline. I am confident about the direction, because it falls straight out of the two cost curves, and cost curves are the most reliable predictor we have.
What to actually do about it
The frame is only worth anything if it changes a decision. It changes three.
If you build, build the verifier, not another generator. The generation layer is commoditizing into the frontier labs at 10x-a-year price declines; competing there is competing with a falling knife. The verification layer is where the defensible margin is, precisely because it is tied to reality and to a specific domain — the thing the general-purpose model can't absorb. Evals-as-infrastructure, provenance and content authentication, automated testing and security, monitoring and observability for agent systems, audit trails, domain-specific ground-truth pipelines. Ask of any AI product idea: does this generate an artifact, or does it certify one? The second question is the better business, because it sells into a bottleneck that gets tighter every quarter, not looser.
If you're building a career, become the verifier. The role AI erodes is the one that produces first drafts — the junior who generates the memo, the boilerplate, the initial analysis. The role it makes more valuable is the one that can look at a generated draft and know, fast and reliably, whether it's right, and say precisely why it's wrong when it is. That is taste, domain ground truth, and judgment — the least automatable thing you own, because in your domain it sits in the regime where no cheap certificate exists. Stop investing in your speed of production. Invest in your accuracy of discrimination. The market is about to pay a steep premium for people who can tell true from plausible, and plausible has never been cheaper to manufacture.
If you run an org, make verification capacity the thing you hire and design around. The failure mode is already visible: teams celebrate a 10x jump in output while their review capacity, their QA, their fact-checking, their compliance sits flat, and they mistake volume for progress right up until the unverified fraction detonates. Stop measuring raw output. Measure verified throughput — the amount of work that has actually cleared a check you trust — and treat verification as the binding constraint it now is. Staff reviewers and evaluators as first-class roles rather than overhead. Build the internal tooling that lets a small number of experts verify a large volume of generated work. Refuse to ship generation capacity you have no capacity to check. An agent that can do a thousand things you can't verify is not an asset. It is a thousand unpriced liabilities wearing the costume of productivity.
Generation was the moat for the entire history of knowledge work: the scarce thing was the person who could write the code, run the assay, draft the brief, make the image. AI drained that moat in three years. The water didn't disappear. It ran downhill to the next low point, and the next low point is the question generation never answered and never will: is it true?