Your Vibe Coding Is Underwater
The one number that tells you whether AI is writing code for you — or you're working for the AI.
A developer ships 200 pull requests a month with Cursor. Before AI, they shipped 30. Leadership sees the number and celebrates. Productivity!
Six months later, production incidents are up 40%. The senior engineers are exhausted. Not from writing code but from reading it. Reviewing it. Debugging things that looked right but weren’t. The team is drowning in output they didn’t write and can’t fully trust.
Nobody connects these two facts. The 200 PRs live in a dashboard that gets shown at all-hands. The incident rate lives in a different dashboard that nobody shows at all-hands.
This is the most common failure mode in AI right now. And it has a name.
It’s called an inverted position.
The Market Nobody Sees
Here’s what happened, in economic terms, that would make any trader wince.
Before AI, a developer’s code lived in a simple market. Supply was limited. A human can write and verify maybe 30 solid pull requests a month. Demand was whatever the organization needed built. Where supply met demand, you got a salary.
Clean equilibrium.
AI blew up the supply side. One developer now generates 200 PRs worth of code. The marginal cost of producing a line of code dropped to nearly zero.
But here’s the part nobody talks about: the demand side didn’t change.
The organization still demands working, verified code. Not code that looks right.
Code that is right.
And verification which is the act of reading, understanding, testing, and approving code — is still bottlenecked by the same human brain running at roughly 10 bits per second of conscious processing which Zheng and Meister call “The unbearable slowness of being”. That number hasn’t changed since the Paleolithic Age.
So what actually happened? The developer didn’t become 7x more productive. They became a generator of 7x more output that now needs to pass through the same narrow verification pipe.
The supply of unverified code exploded. The supply of verified code barely moved.
The Number: Verification Cost Ratio
There’s a single ratio that tells you whether AI coding is an asset or a liability.
I call it the Verification Cost Ratio (VCR).
VCR = Cost of Verifying AI Output / Value of Verified Output
That’s it. What does it cost to take AI-generated code from “looks right” to “is right,” divided by what that verified code is worth to the business?
Here’s how to read it:
VCR below 0.3 — You’re printing money. Verification is cheap, value is high.
VCR 0.3–0.5 — Healthy. Real costs, real value. Sustainable.
VCR 0.5–1.0 — Tight. Most of the value goes to checking the work.
VCR above 1.0 — Inverted. You’re subsidizing the AI.
VCR above 2.0 — Broken. Shut it off. Hand-write it faster.
Most teams don’t know their VCR. They know their output went up. They don’t know their verification cost went up faster.
How a Real Team Goes Inverted
Let me walk through the math on a team I’ve seen variations of a dozen times.
Before AI:
Senior dev writes and self-verifies 30 PRs/month
Each PR is worth ~$500 to the business (feature value, bug fixes, shipping velocity)
Monthly value: $15,000
Verification cost: built into the dev’s workflow. Effectively zero marginal cost.
VCR: ~0.1 (surplus position)
After AI (Month 1):
Same dev generates 120 PRs/month with Cursor
Same $500/PR value
But now each PR needs review because the dev didn’t write it from scratch, so they need to read and verify
Average review time: ~25 min per AI-generated PR (vs. near-zero for self-written code) assuming the reviewer is a seasoned coder
That’s 50 hours/month just on verification. The dev only has 160 working hours.
Verification cost: 50 hrs × $80/hr = $4,000
Output value: 120 × $500 = $60,000
VCR: 4,000 / 60,000 = 0.07
Position: Deep surplus. Looks amazing.
After AI (Month 4):
Dev is now generating 200 PRs/month. Leadership loved the numbers, so they pushed for more.
But at 200 PRs, verification time is 83 hours/month. That’s over half the dev’s working time.
The other half? Prompting, debugging AI mistakes, re-generating.
Actual time spent writing new, original code: near zero.
Actual time spent on verification and AI babysitting: 130+ hours.
Worse: review quality is slipping. The dev is rubber-stamping PRs at hour 70.
Bugs are shipping. Three production incidents this month. Each costs $5,000 in remediation.
True verification cost: 83 hrs × $80 + 3 incidents × $5,000 = $21,640
But output value hasn’t changed: 200 × $500 = $100,000
Stated VCR: $6,640 / $100,000 = 0.07 (they’re not counting the incidents)
True VCR: $21,640 / $100,000 = 0.22 (still OK, but rising fast)
After AI (Month 8):
Three senior devs have quit. They didn’t sign up to be AI code reviewers.
The remaining team is junior. They can’t catch the subtle bugs.
AI output is still 200 PRs/month per dev. But review quality has collapsed.
Production incidents: 12/month. Average cost: $8,000.
The team doesn’t even know which PRs caused which incidents — the blast radius of unverified AI code is diffuse.
True VCR: 1.4
The position is inverted. Every dollar of AI-generated code costs $1.40 to make real. The team would literally be more productive writing less code by hand.
Nobody notices because the dashboard still says “200 PRs/month.”
The Verification Scarcity Problem
Here’s the variable that kills teams: verification scarcity (σ).
σ = AI output volume / Human verification bandwidth
When σ is low (say, below 3), humans can keep up. They check most of the AI output. Errors get caught. The system works.
When σ is high (above 10), most AI output goes unchecked. This is what I call a naked position. This means you’re exposed to errors you don’t even know exist.
The vibe coding movement is a bet on running σ at infinity. “Just let the AI write it, ship it, see if it works.” This is fine for a weekend hackathon. For production code that other humans and systems depend on, it’s the economic equivalent of writing naked options.
When it blows up — and it does — nobody connects it to the AI output from three months ago that nobody reviewed.
Zillow lost $500 million this way. Not in code, but in pricing. It is the same pattern. Algorithmic output at scale, verification bandwidth at zero. The algorithm’s stated VCR looked great because nobody was verifying. The true VCR was catastrophic. They just didn’t know it until the losses materialized.
The Question You Should Be Asking
Every Monday morning, for every AI-assisted workflow in your organization, one number should land on your desk:
What is the VCR?
Not “how much code did AI write.” Not “how many hours did we save.” Not “what’s our AI adoption rate.”
What does it cost to make AI output real, and is that cost less than what the output is worth?
If VCR < 0.5: scale it. You’ve found a genuine surplus.
If VCR is 0.5–1.0: invest in your team’s verification skills. The position is tight but salvageable. Train people to review faster. Build better testing infrastructure. This is the highest-leverage investment you can make.
If VCR > 1.0: stop. You are subsidizing AI with human labor. Either reduce the volume of AI output or dramatically improve your team’s ability to verify it. Do not carry this position hoping the next model release fixes it.
The Only Variable You Control
Here’s the part that matters for what you actually do tomorrow.
Of the four factors that determine whether AI coding pays off, three are outside your control:
Output elasticity ( how much more code AI can generate) — is a property of the technology.
Verification scarcity (how much goes unchecked) — is a consequence of how much you deploy.
Quality decay ( how badly unverified code hurts you ) — is a property of your system’s architecture.
The fourth factor is the only one you actually control: Human Readiness (ρ).
Rho (ρ) is how fast your team’s verification skill improves with training. It’s the elasticity of your verification supply. If ρ is high which means if your team is getting better at reading, judging, and correcting AI output then VCR falls over time, and your AI positions move into surplus.
If ρ is low — if your team is losing the ability to evaluate code because they’ve stopped writing it — then you’re watching your most valuable asset (human judgment) depreciate while your least valuable asset (raw AI output) piles up.
The companies that win with AI coding are not the ones generating the most code. They’re the ones whose humans are getting better at verifying it.
Mark It
The entire AI industry is carrying its positions at book value. “We deployed Copilot across 500 developers” is a book value statement. It tells you what you spent, not what you have.
Mark-to-market means looking at what the position is worth today, at today’s verification costs, at today’s team skill level, at today’s error rates. Not what the vendor’s ROI calculator projected. Not what it was worth last quarter before your two best reviewers left.
Today. What’s it worth today?
If you can’t answer that, you don’t have an AI strategy. You have an unhedged position and a prayer.
And the market doesn’t care about prayers.
I’m Shreya Bhattacharya, CEO of Purna Medha. Ex-risk analyst. Consciousness researcher. Currently running 20 projects because that’s how my brain works. If you’re building something you love enough to fight entropy for, I want to hear about it.