cankun.me
Jun 14, 2026 · 4 min read /

The Verifier Is the Whole Game

Why AI is razor-sharp at coding and blunt everywhere else: what matters is the verifier, not the difficulty of the work.

A broad steel blade is honed to a bright precise edge against a small dark whetstone

AI capability has developed in a strangely lopsided way, and once you see the shape of that lopsidedness, a lot of otherwise confusing behavior starts to make sense. Models have become extraordinary at coding along a curve that keeps steepening, yet they remain merely competent at most other forms of serious intellectual work. People usually explain this by saying that coding is easier or more structured, which is wrong, and the real explanation matters far more.

The asymmetry

Reinforcement learning (RL) needs a checkable reward, and coding comes with a checker for almost nothing: the test suite, the compiler, the sandbox that either runs the program or does not. Because that feedback loop is tight, cheap, and trustworthy, RL can iterate on code millions of times, with each attempt scored by an oracle that neither lies nor gets tired. That is why the capability curve is steep.

Most other domains have no such oracle. If a reward exists at all, it is slow, expensive, noisy, or contested, which leaves RL with very little to work with. Whatever competence a model shows in those domains comes mostly from passive absorption during pretraining, without the active sharpening that RL provides where a verifier exists.

As a result, the model does not get uniformly "smarter." It gets honed razor-sharp wherever a cheap verifier happens to exist and stays blunt everywhere else; the shape of its capability follows the shape of where verification is cheap.

What the verifier actually is

The easy explanation misses why coding has a cheap verifier in the first place. Software engineering did not find a verifier lying around in nature; as a social practice, the discipline manufactured one. A test is a human-written contract that specifies in advance what conditions an answer must satisfy to count as correct. The discipline compressed the question "is this right?" into a machine-checkable agreement and handed that agreement to a machine to enforce.

It is easy to forget how unusual that achievement is. In most domains, "what counts as correct" cannot be written down in advance as a contract. It stays a continuous, social, perpetually reopenable negotiation, which means it never holds still long enough to be frozen into a step-level reward function.

RL cannot be fed in those domains not because the signal is noisy, but because the notion of "correct" is the product of a process, and a process cannot be compressed into a reward at each step. Models are sharp where humans have already done the work of turning a social judgment into a machine contract, and blunt where no such contract is possible.

The dangerous move

That distinction sets up the failure mode that defines the current moment. Take the architecture that works gloriously where a verifier exists (autonomous agents, recursive self-improvement, humans pushed up to oversight) and transplant it into a domain without a cheap verifier. The architecture still runs and the agents still execute, even though the oracle that made the whole apparatus work by filtering every output for correctness is gone.

Removing the verifier does not just produce a slightly worse version of the same thing. A recursive loop that meant "get better" where a verifier existed comes to mean "get better at seeming right" once seeming-right is the only signal left. At scale, pointed at a domain without a verifier, the machine amplifies plausibility rather than truth, churning out outputs at superhuman scale and speed that look correct while having no relationship to truth.

The most capable systems are the most dangerous here, because their outputs look the most fluent and the most grounded. They will produce conclusions that are internally consistent, well-cited, methodologically tidy, and still wrong, with the polish that should signal quality serving as cover instead.

Why this is not a passing phase

It would be comforting to assume that the blunt domains are simply waiting their turn and that better models will eventually become sharp everywhere. For some domains that is true, because the verifier just has not been built yet. Where "correct" is genuinely the slow product of a collective social process, though, the blunt edge marks a structural boundary rather than a temporary lag. You cannot give a step-level verifier to work whose correctness comes from a collective process. The model can get arbitrarily good at the parts that can be contracted, and it will keep hitting the same wall on the parts that cannot.

The consequence

If the verifier is the whole game, then the frontier is not where the algorithms are. The reinforcement learning literature has largely converged on this point already: the algorithms have become commodities, while the scarce, decisive resource is reward design, which is to say, verifier design. The teams building the strongest systems are the ones that can specify and measure quality, not the ones with a cleverer optimizer.

That makes the hardest and most valuable problem not building another autonomous system but the question everyone is routing around: in a domain with no cheap verifier, where does a trustworthy reward come from, and how do you keep optimization from collapsing into the production of plausible nonsense?

People often treat that question as a technical detail, when it is actually the central problem. Wherever a verifier is missing (serious science, genuine writing, real judgment), optimizing for "what a human finds good" ends up substituting for "what is true." You can feel the cost of that substitution in the texture of the output: confident, safe, fluent, and hollow. The whole game is whether you can find something to optimize against besides the satisfaction of the reader.