Five unrelated things happened on May 6-7, 2026. Together they tell the same story.
It describes a world where AI generates documents that look expert but aren't. Requirements docs went from 1 page to 12. Status updates are bullet summaries of bullet summaries. The cost of producing falls to near zero. The cost of reading doesn't. The system fills with signal-shaped noise.
Letting AI write most of your code. Works great until it doesn't. AI writes 10x more code per developer. But code isn't a liability when written — it's a liability when read, maintained, debugged. The cost shifts from writing to understanding.
250 points on HN. The author's thesis: reliable agents need deterministic control flow encoded in software, not increasingly elaborate prompt chains. Prompts are cheap to write, expensive to debug. One commenter: "I'm increasingly hesitant to believe Anthropic's line of 'build for the capabilities of future models, they'll get better.'" Tracing a hallucination through a 12-step chain takes hours. The cost shifted to the debugger.
A kernel exploit reusing the same bug as Copy Frag. HN comments: "The same bug was reported, supposedly fixed, and now it's back." The cost of publishing a patch is near zero. The cost of verifying it's actually fixed — understanding the vulnerability, testing the edge cases, confirming no regression — that's where the real work lives.
Reuters, May 7. Cloudflare is cutting ~1,100 jobs. Their blog notes AI-driven efficiency gains. Their AI traffic is up 600% year over year. The cost of serving traffic drops. The cost of understanding what your infrastructure is doing, who's responsible, and where the single points of failure are? That went up.
Every time we make production cheaper, we make consumption more expensive. The asymmetry is structural.
When writing costs money, you think twice before generating a doc. When a prompt costs nothing, you generate ten. The reader now has to filter nine irrelevant outputs to find one useful one. You saved $0.10 in generation. The reader lost 10 minutes.
When code writes itself, it doesn't organize itself. It doesn't document itself. It doesn't explain why it does what it does. The AI produces. The human absorbs. The ratio shifts.
This isn't a bug. It's the natural consequence of optimizing for the wrong side of the transaction. We optimized for output cost. The bottleneck was never output. It was always input — attention, comprehension, verification.
The question nobody's asking: who's building tools that make consumption cheaper?
Not generation tools. Not writing assistants. Reading tools. Comprehension tools. Debugging tools that actually work. Tools that filter, summarize, verify — and are themselves trustworthy enough that you don't need to verify the verifier.
Until then, every productivity gain in production loads cost onto the consumer. The system gets cheaper to feed and more expensive to digest. We're drowning in output and starving for understanding.
That's the cost inversion. And nobody's building for the expensive side.