Loading...
Loading...
Some work you can check in seconds. Some you can never check at all.
We treat "good work" and "checkable work" as the same thing. They are not, and the gap between them quietly runs entire industries.
Two people do a job for you.
A locksmith says the lock is fixed. You turn the key. Five seconds, no expertise, done. You pay him on the spot.
A night watchman says nothing happened last night. How do you know?
You don't. A quiet night looks identical whether he patrolled every hour or slept until dawn. You cannot tell a good watchman from a lucky one by looking at a quiet night.
That difference has a name: verifiability. Not "is the work good?" but "how cheaply can I check that it was actually right?"
It sounds like a small distinction. It runs deeper than that. It decides how fast people trust the work, how it gets priced, how quickly it improves, and now whether AI can do it at all.
Verifiability isn't a yes or no. It's a dial. Every kind of work sits somewhere on it, and once you can see the dial you start seeing it everywhere.
Here the work produces something you can hold against a fixed standard and grade in moments.
Different fields, same shape: a closed standard, a cheap check, an instant verdict. Work like this earns trust fast. You pay on completion. You don't ask for references.
Here the truth exists, but reaching it is expensive, delayed, or drowned in noise.
Here the work produces an assertion about a system that is partly invisible, and sometimes actively fighting you.
This is a different problem from the middle of the dial. Investing is noisy, but the market isn't trying to fool you. Here, something on the other side is working to make sure a careful check and a careless one produce the same quiet result.
Security operations. The core product of a security team, thousands of times a day, is the sentence "we checked, nothing is wrong." You cannot verify that by reading it. To actually check, you would have to re-investigate reality, against an adversary whose whole job was to make the dangerous thing look boring.
Intelligence. Site reliability. Fraud and content moderation. Same shape: "we caught what mattered." Did you? The misses don't announce themselves. You are blindest exactly where it counts.
Strategy, policy, management. Did the decision cause the outcome, or would it have happened anyway? There is no counterfactual to check against, and the result arrives years later, tangled with a thousand other causes.
This is the watchman's end of the dial. Not because the people are worse — often they're the best in the building. It's because the work is structurally unprovable.
Look at what every field at the hard end reaches for. It's the same substitute every time. When you can't verify the outcome, you verify the process instead.
Medicine has clinical guidelines and board certification. Engineering has building codes. Security has audits and compliance frameworks. Education has standardized tests. Each one certifies that you followed the method believed to produce good work, not that the work was actually right.
Process is a proxy for verification, and it's necessary. You can't run a hospital or a power grid on vibes. But never lose sight of what it is: it certifies the recipe, not the meal. The gap between "followed the method" and "got it right" can widen silently for years while every audit comes back clean. That's the failure mode hiding behind a surprising share of the disasters we act shocked by afterward.
There's a second tell. Unverifiable work is trusted slowly and priced nervously. You don't pay the watchman and wave him off. You check references. You install a camera to watch the watchman. And where the work truly can't be checked, we wrap it in accountability instead: a license to revoke, an insurer behind it, a name on the line, someone to fire. Accountability is what we buy when verification isn't for sale. It's the tax the hard end of the dial pays, forever.
For most of history, verifiability was a fixed feature of the work. You couldn't move a job along the dial; you just priced it accordingly.
AI changes the stakes, because the dial turns out to predict where AI creates value with unusual precision.
Where checking is cheap, AI compounds fast. It's no accident that coding was among the first things AI got genuinely great at. That free, merciless compiler is the perfect training partner — the machine could be corrected a billion times, for free, against ground truth.
Where checking is expensive, AI stalls, no matter how capable the model gets. If you can't tell a brilliant answer from a lucky one, you can't trust the machine, and you can't teach it. A superhumanly smart agent at the watchman's end of the dial is still just a very articulate watchman. You have no way to know if it's any good.
And it sharpens over time. Producing answers keeps getting cheaper; checking them doesn't. So the dial, not raw intelligence, increasingly decides which industries AI transforms and which it merely unsettles.
Which points at an odd conclusion. The bottleneck was never the model. At the hard end of the dial, the constraint has always been the check, not the answer. So the most valuable work of the next decade isn't building a smarter machine. It's manufacturing verification where none existed — a cheap, trustworthy check for work that never came with one. Turning watchman problems into locksmith problems.
That's a strange new job, and almost nobody is hiring for it by that name yet. But it's the job. Wherever someone finds a way to verify the unverifiable, an entire industry slides left on the dial, and AI walks in right behind it.
Before you ask whether a piece of work is good, ask whether you could even tell. That's verifiability. Most people have never named it. It's been quietly sorting the winners the whole time, and it's about to decide which industries AI actually gets to keep.
What is verifiability, and why does it matter for AI? Verifiability isn't "is the work good?" — it's "how cheaply can you check that it was actually right?" It's a dial, not a yes-or-no, and it decides how fast work earns trust, how it gets priced, and increasingly whether AI can do it at all. Where a check is cheap and instant, AI compounds fast; where checking is expensive or impossible, even a brilliant model stalls, because you can't trust or teach what you can't verify.
Why is AI so good at coding but stalls on harder work? Code comes with a free, merciless judge: the compiler and test suite return a verdict in seconds, against ground truth. That let models be corrected billions of times, for free, until they got great. Most work has no such judge — the answer arrives late, drowned in noise, or never. When you can't cheaply tell a brilliant output from a lucky one, AI has nothing to learn from and no one has reason to trust it.
What is the verification bottleneck, or "verifier's law"? It's the observation that producing an answer keeps getting cheaper while checking whether it's right does not. The ease of teaching AI a task tracks how verifiable that task is: easy-to-check work gets solved fast, hard-to-check work lags no matter how capable the model gets. So the real constraint on AI's value was never raw intelligence — it's the check, not the answer.
Why can't AI fully replace security analysts or run the SOC on its own? Because security operations sits at the hard end of the dial. Its core output, thousands of times a day, is "we checked, nothing is wrong" — a claim you can't verify by reading it, about a system that's partly invisible and has an adversary working to make the dangerous thing look boring. A superhumanly smart agent that can't be checked is still just a very articulate watchman; you have no way to know if it's any good. The unlock isn't a smarter model — it's a cheap, trustworthy way to verify the work.
Can AI verify its own work? Not where the check means re-investigating reality against something trying to fool you — an AI grading its own "nothing is wrong" inherits the same blind spots that produced it. The valuable move is to manufacture verification from the outside: an independent, repeatable check that turns a watchman problem into a locksmith problem. That's the idea behind self-improving SecOps — closing a verification loop so defense compounds instead of quietly decaying.
