Why Checking Is Cheaper Than Knowing

The trick works for one reason: checking is cheaper than generating. It is worth slowing down on that sentence, because it explains much more than serving speed. It explains why reasoning models became superhuman at competition mathematics and code while remaining unreliable at strategy and judgement. It explains where test-time thinking pays and where it misleads. And it is the best guide we have to where AI will advance fastest over the next decade.

I · An old asymmetry

Computer science has a whole vocabulary for this. A filled-in Sudoku can be checked in seconds; solving one can take much longer. Multiplying two primes is easy; factoring their product is believed to be hard, and modern cryptography depends on that belief. The P versus NP question, still open, asks in effect whether every problem whose solutions are easy to check is also easy to solve. Most computer scientists suspect not.

You do not need to resolve P versus NP to use the intuition. In a large and practically important class of problems, recognising a good answer is far cheaper than finding one. A unit test checks code. A proof checker checks a proof. A game engine says who won. Wherever such checks exist, an extremely powerful strategy becomes available: generate many candidates, keep the ones that pass.

II · Coverage is cheap; selection is everything

The 2024 "Large Language Monkeys" study made this concrete.² When a model is allowed many independent attempts at a problem, the fraction of problems for which at least one attempt is correct, which the authors call coverage, keeps rising with the number of attempts across orders of magnitude. In domains with automatic checkers, such as code with unit tests, that coverage turns directly into solved problems. Without a checker, the system has to select the right answer from the pile by majority vote or a learned scorer, and the gains flatten well before coverage does.

More thinking produces more candidates. Only verification turns candidates into answers.

That distinction between generating possibilities and recognising the right one is the hidden mechanism behind the meter from Article 01. It also answers the question Article 02 left open. A system can only judge the value of its next thought if it has some signal of whether its current thought is any good, and that signal is a verifier, explicit or implicit.

The reasoning boom of 2025 was largely built on this. DeepSeek-R1, for example, was trained with reinforcement learning using rule-based rewards for mathematics and code: answers that could be checked automatically.³ In 2024 Google DeepMind's AlphaProof reached silver-medal-standard performance on International Mathematical Olympiad problems by working inside the Lean proof assistant, where every step of a proof is machine-checkable.⁴ In both cases, the domain supplied a cheap, trustworthy judge, and thought turned into capability.

III · The verification map

If verification is what turns thought into capability, we can draw a map of where AI progress is cheap and where it is expensive. Two axes matter: how cheap a check is, and how trustworthy it is.

The upper left, where checks are cheap and reliable, is where AI has looked most superhuman. The upper right is where checks are reliable but slow and expensive, such as wet-lab experiments, clinical trials and fabricating a chip. There, more thinking helps propose candidates, but progress is throttled by the physical world. The lower half is where checks are cheap but unreliable, or both expensive and unreliable. That is most of business, policy and everyday judgement, and it is where extra thinking is most dangerous.

IV · When the checker can be fooled

In the lower-left quadrant, the "verifier" is usually another model: a reward model, an LLM judge, a classifier trained on human preferences. Learned judges have blind spots, and optimisation finds blind spots. Gao, Schulman and Hilton documented this in 2022. As a policy is optimised harder against a learned reward model, its true quality first rises and then falls, even while the learned reward keeps going up.⁵ This is Goodhart's law with a measured curve: once the measure becomes a target, it stops being a good measure.

For the price of thought, this is a sobering result. In a domain with an imperfect judge, letting a system think longer and search harder is not neutral. It is optimisation pressure against the judge's flaws. Past some point, more thinking makes answers worse while making them look better. The meter keeps running, the score keeps rising, and quality drops.

V · Manufacturing verifiers for messy domains

If verification is the bottleneck, the decade's most valuable engineering work is building verifiers where none exist. Several routes are already visible.

Formalise. Translate fuzzy requirements into checkable specifications: types, contracts, property-based tests, formal models. Software is the leading example, and the reason AI coding has advanced so fast is that codebases already contain many checks.

Simulate. Build simulators good enough to grade proposals before they touch reality, such as digital twins, physics engines and market simulators. A simulator is a verifier you can run a million times.

Cross-examine. Where no ground truth is available, structure the check adversarially. The "AI safety via debate" proposal argued that it can be easier to judge which of two competing arguments is right than to produce a right argument yourself.⁶ That is verification asymmetry applied to judgement.

Close the loop with reality. Log outcomes, tie decisions to results, and turn delayed real-world feedback into training signal. It is slow and expensive, and it is the only verifier that cannot be argued with.

VI · The verifier is the moat

Here is the strategic implication. Models diffuse quickly: open weights catch up, distillation copies capabilities, prices fall. Verifiers do not diffuse nearly as easily. A company's test suites, simulators, labelled outcomes, compliance rules and accumulated "this is what good looks like" are specific to that company, hard to copy, and exactly what turns generic thinking into reliable, domain-specific capability.

If this argument is right, the most important question an organisation can ask about AI today is not "which model should we use?" It is "what in our domain can we check cheaply, and what would it take to make more of it checkable?" The answer determines how much intelligence that organisation can actually buy with each unit of thought.

There is a further consequence. Once generation and verification are separate jobs with different costs, it makes sense to give them to different components: cheap generators, careful checkers, routers deciding who does what. A single model starts to look less like a mind and more like an economy. That shift is the subject of the next article.

Behind this article: the editorial brief

Opening hook

The most widely deployed speed-up in LLM serving lets a small model guess and a large model check, and it produces exactly the large model's output distribution, faster. It works because checking is cheaper than generating. That one asymmetry quietly explains why AI is superhuman at some things and unreliable at others.

Central argument

Test-time thinking converts into reliability only in proportion to the availability of cheap, trustworthy verification. Where verifiers exist, more thought helps. Where they don't, more thought can make things worse.

Why now

Reinforcement learning with verifiable rewards drove the reasoning boom of 2025. The obvious next question for every company is whether it can verify outcomes in its own domain. Most can't yet.

Deep-tech

Generation–verification asymmetry; speculative decoding; repeated sampling: coverage versus selection; formal verification (Lean, AlphaProof); learned reward models and over-optimisation; debate and cross-examination as verification for fuzzy domains.

Unconventional insight

Over the next decade, the frontier of AI capability will follow the frontier of cheap verification more closely than the frontier of model size. The durable moat is the verifier, not the model.

Outline

1. The guess-and-check engine inside every fast model
2. An old asymmetry
3. Coverage is cheap; selection is everything
4. The verification map
5. When the checker can be fooled
6. Manufacturing verifiers for messy domains
7. The verifier is the moat

Implications

Established: speculative decoding; RL with verifiable rewards; reward-model over-optimisation. Prediction: spec-first, test-first engineering resurges; formal methods go mainstream; firms compete on proprietary verifiers. Speculation: "verification-as-a-service" becomes its own industry.

Connection

02: machines can't judge the value of their next thought. 03: the signal that makes such judgement possible is verification. 04: if generating and checking separate, intelligence becomes an economy of specialised parts.

Closing thought

We will not trust AI because it thinks more. We will trust it where we can afford to check.

Footnotes

1. Y. Leviathan, M. Kalman, Y. Matias, "Fast Inference from Transformers via Speculative Decoding", arXiv:2211.17192, 2023; C. Chen et al., "Accelerating Large Language Model Decoding with Speculative Sampling", arXiv:2302.01318, 2023. ↩

2. B. Brown et al., "Large Language Monkeys", arXiv:2407.21787, 2024. ↩

3. DeepSeek-AI, DeepSeek-R1, arXiv:2501.12948, 2025. ↩

4. Google DeepMind, "AI achieves silver-medal standard solving International Mathematical Olympiad problems", July 2024. ↩

5. L. Gao, J. Schulman, J. Hilton, "Scaling Laws for Reward Model Overoptimization", arXiv:2210.10760, 2022. ↩

6. G. Irving, P. Christiano, D. Amodei, "AI Safety via Debate", arXiv:1805.00899, 2018. ↩