The Reality Gradient
AI keeps getting better. I keep trusting it less in the places it impresses me most. Here is why that is not a contradiction.
Something strange happened to me over the last year.
The models got dramatically better. And in the same window, I got more careful, not less, about where I let them lead.
That sounds like a contradiction. A tool improves, you lean on it harder. That is how every tool I have ever used has worked. A better camera, a faster compiler, a sharper knife. Capability goes up, caution goes down.
With AI it inverted. The better it got at sounding right, the more I had to watch for where sounding right and being right come apart.
It took me a while to see the pattern under that. When I finally did, it was simple enough to draw on one screen. I have started calling it the Reality Gradient.
It is not an entirely new concept. A lot of smart people are arriving at a version of it right now, mostly from the world of code. What I think is missing is where the idea actually bites hardest, which is nowhere near a compiler.
Here is the whole idea in one line.
The usefulness of AI depends on how quickly reality can tell you it is wrong.
Not how smart the model is. How fast the world pushes back.
Three zones
Think about the work you actually hand to AI. Sort it by one question: when the answer is wrong, how long until something outside your own head tells you so?
Reality-constrained work. Reality answers in seconds. You write SQL and it runs or it throws. You debug and the test passes or it fails. You transform a file and the rows reconcile or they do not. The ground is right there, and it does not care how confident the output sounded. This is where AI is not just useful but close to magic, because the cost of a wrong answer is a few seconds and a retry. Move fast. Let it run. Verify almost for free.
Reasoning-constrained work. Now reality goes quiet. Strategy. Architecture. A research synthesis. A long argument. Nothing crashes when the thinking is subtly off. The only thing that can catch the error is your own judgment, and your judgment is working against a strong headwind, because the output is fluent. It reads finished. It has the cadence and the structure and the confidence of something true. And fluency is the most expensive illusion in this whole stack, because it feels like understanding. You are no longer checking the work against the world. You are checking it against your own ability to notice what is missing, on a piece of writing engineered to feel complete.
Market-constrained work. Reality goes fully silent, and the only thing that can answer you is other people. Products. Features. Pricing. Positioning. AI will build you the whole thing before lunch. A working prototype, a pricing page, five brand directions, a launch plan. What it cannot do, what nothing can do except the market, is tell you whether anyone wants it. And the market does not answer in seconds or hours. It answers in weeks and months, after you have already spent the time, after you are attached, after the thing exists.
Same tool across all three. The capability barely changes. What changes underneath it is the length of the loop.
The coupling that broke
Here is the mechanism, and it is the part worth slowing down for.
Every kind of work has a feedback loop, and every loop has a length. The length is how long it takes the world to tell you that you were wrong. A failing test is a loop a few seconds long. A flawed strategy is a loop measured in quarters. A product nobody wants is a loop measured in your runway.
AI did something very specific to this picture. It collapsed the cost of production to almost nothing. It did not touch the length of the loop.
That is the whole asymmetry.
We made creation cheap.
We did not make verification cheap.
And those two used to be coupled. The effort of building something was, accidentally, also the time during which you noticed it was a bad idea. The slowness was a feature. It rate-limited your mistakes. You could not get that far down a wrong path before the friction of building forced a check.
Now the friction is gone. You can produce a finished-looking answer to a question that will take the market three months to grade. The production is instant. The verification still takes three months. The gap between those two numbers is the most dangerous place to be working right now, and AI walked us all straight into it while we were admiring the speed.
So the value of AI really is inversely proportional to the distance between its output and reality. Not because the model gets dumber as the work gets harder. Because the further out you go, the longer you wait to find out it was wrong, and the more you have built on top of the error before it surfaces.
This is the part where I should name names, because the idea is in the air. The clearest version on the research side is what Jason Wei calls the asymmetry of verification, or verifier’s law. The tractable problems for AI are the ones you can cheaply check, and the real question about any task is not whether it is hard but whether you can close the loop on it. Others have put it more bluntly. Generation got cheap and validation did not. They are right.
But notice where almost all of that conversation lives. It lives in code. Tests, pipelines, formal proofs. The left end of the gradient, where verification was already cheapest to begin with. The frontier worth caring about is the other two thirds. The part with no compiler, where the verifier is a human being and the loop runs a quarter long. That is the part nobody has a clean answer for, and it is the part that decides whether a company lives or dies.
Premature closure, and the time it got me
The failure here is not hallucination. Hallucination is the one everyone talks about, and it is mostly a solved-enough problem in the reality-constrained zone, because reality catches it. You do not ship a hallucinated SQL query twice.
The real failure is premature closure. You ask a hard question, you get back something articulate and well-structured, and you stop. Not because you verified it. Because it felt verified. The fluency did the work that evidence was supposed to do.
The move: drag the work left
Here is where most takes on this stop. They say: be careful in the amber and red zones. Use AI as a thinking partner, not a decision maker. True, and useless, because be careful is not an instruction. Careful how.
And this is exactly where the code-side version of the idea runs out. In code, the loop is already short. Out here in the rest of the work, you have to build the loop yourself.
The better move is sitting in the structure of the gradient itself.
If the danger is loop length, then the skill is loop shortening.
You do not have to accept the zone the work arrives in. A lot of craft is dragging work leftward, manufacturing a cheap piece of reality so an amber question becomes a green one before you have spent a quarter on it.
The strategy memo cannot be compiled. But it implies a prediction, and a prediction can be checked against three customer calls this week. You just dragged it left.
The product idea will take the market months to grade. But the riskiest assumption inside it can be tested with a landing page and forty clicks, or ten conversations, before a line of real code. Dragged left.
The architecture decision has no compiler for its long-term consequences. But you can build the smallest load test that would break it, today, instead of discovering the ceiling in production. Left again.
This is what invalidate before reality has to actually means in practice. It is not a mindset. It is a habit of manufacturing fast feedback on purpose, of asking the same question every time: what is the cheapest, fastest piece of reality I can put in front of this idea, and how do I get to it this week instead of next quarter.
The operators who are going to win the next few years are not the ones generating the most. Generation is free now, it is a commodity, the model does it for everyone equally. The edge is in verification. In how fast you can find out you were wrong. In how cheaply you can build a reality check for an idea that does not come with one attached.
The skill worth building
So the thing I am investing in is almost the opposite of what the moment seems to reward.
Everyone is getting better at producing. The output is getting cheaper and more fluent by the month. That race is over and the model won it. Trying to out-generate the generator is a bad use of a human.
The scarce skill is the other one. Killing your own ideas early. Building the cheap test before the expensive belief. Staying suspicious of the answer precisely when it sounds most finished, because sounds finished is exactly the signal that you have left the zone where reality was doing your checking for you.
AI made creation cheap. Reality did not make verification cheap.
The whole game now is closing that gap yourself, on purpose, before the market closes it for you.
About SG
I run Dobby Ads, an AI Creative Agency. I tend to overthink. This is where that overthinking goes. Connect with me on LinkedIn.