The Vibe Father
Honest math
"AI coding pays for itself" is easy to say and hard to prove, because the win and the cost live in different columns of the ledger and people rarely tally both. The models cost money. The agents save time. But the time saved is offset by review overhead and, sometimes, by work that just moved from writing code to fixing generated code. So does AI coding actually pay off? The honest answer is: often yes, sometimes no, and the difference is entirely about whether you're measuring the real cost or just the exciting half of it. Here's the full ledger.
The credit side: what you genuinely save
The savings are real and worth stating plainly. Agents compress the time spent on the large, boring, well-specified middle of software work: boilerplate, scaffolding, mechanical refactors, test coverage, dependency maintenance, first-draft integrations with libraries you don't know. Work that used to take an afternoon of typing takes a review of generated output. For a developer whose day is 60% execution and 40% hard thinking, offloading a big chunk of the execution to agents is a genuine reclamation of hours — hours that go back into the harder work or into shipping more. This isn't marketing; it's the observable effect of not typing the tenth variation of a pattern you've built nine times.
There's a second, subtler credit: agents lower the activation energy for tasks you'd otherwise skip. The internal tool that was never worth the time, the test suite you kept deferring, the cleanup that always lost to the roadmap — these get done when the cost of doing them drops. That's value that doesn't show up as "time saved on existing work" but as "work that now happens at all." For a lot of teams it's the bigger half of the ROI.
The debit side: what the hype leaves out
Now the costs, because the ROI is fake if you skip them. There are three, and they're the reason some teams see no real return despite heavy usage.
Token cost. The obvious one. Agents running all day on a flagship model add up, and a team that defaults to the most expensive model for every task — including work a cheap model would nail — turns a modest tool bill into a surprising one. This is the most controllable cost and the most commonly mismanaged.
Review overhead. The one people forget. Every line an agent generates is a line a human has to read, because unreviewed agent output is a liability, not an asset. Generating code faster than you can review it doesn't save time — it moves the bottleneck from writing to reading and often makes it worse, because reading unfamiliar code you didn't write is slower than reading your own. The review time is a real cost, and it scales with how much you generate. Teams that treat review as free are the ones whose ROI is a mirage.
Work that just moved. The uncomfortable one. Sometimes AI coding doesn't reduce work; it relocates it. The agent writes the feature in ten minutes, and you spend forty minutes discovering it misunderstood a requirement, tracing the wrong assumption through the code, and steering it to the correct version. Net, you may have saved little — you just did different work. This happens most on ambiguous or architectural tasks, which is exactly where the "it's so fast" excitement is loudest and the real accounting is quietest.
When it's a genuine win
Put the two columns together and a clear pattern emerges. AI coding pays off — often handsomely — when the work is well-specified and verifiable: tasks with a clear definition of done, a small blast radius, and a cheap way to check correctness. On that kind of work the agent's speed is real, the review is fast because the output is easy to verify, and the model cost is modest because you're not burning retries or flagship tokens. This is the high-ROI zone, and it's a big zone: much of professional software work is exactly this kind of well-scoped execution. Route that work to agents and the return is unambiguous.
When it just moves work around
The ROI collapses on the opposite kind of task: ambiguous, architectural, hard-to-verify work. Here the agent produces plausible output fast, but verifying it is slow and often reveals a wrong assumption that costs more to unwind than the change saved. The generation was cheap; the correction wasn't. On this work, AI coding frequently just relocates the effort from writing to reviewing-and-fixing, and if you only measured the writing you'd conclude you'd won when you'd broken even. The honest teams know this and don't pretend the fast generation on hard tasks is the same as a fast result.
How to make the ROI real
The return isn't automatic; it's a consequence of choices, and a few of them do most of the work. Match the model to the task so you're not paying flagship prices for work a cheap model clears — the single biggest lever on the token column. Route well-specified, verifiable work to agents and keep ambiguous, architectural work human-led, so you're spending agent time where the ROI is highest and human judgment where agents just relocate effort. Budget review as a real, non-optional cost rather than pretending generation is the finish line. And verify externally — gate "done" on tests and checks rather than the agent's confidence — because the alternative is paying the review cost in production incidents instead of in code review, which is far more expensive. The full cost model, including where the break-evens actually sit, is in the economics of AI coding, and the productivity claims worth being skeptical of are in the AI coding productivity myth.
The bottom line
AI coding does pay off — but as a conditional, not a slogan. It pays off when the time saved on well-specified execution genuinely exceeds the token cost plus the review overhead, which is a bar that a lot of work clears and some work doesn't. The teams seeing real ROI are the ones counting the whole ledger: routing the right work to agents, keeping the model cost matched to task difficulty, and treating review as a first-class expense rather than a rounding error. Count both columns honestly and the answer for most teams is a genuine yes — just a smaller, more earned yes than the marketing promises. To keep the model-cost column under control, our capability-per-dollar board, every score cited to source, is at /benchmarks.
