DEV Community

Cover image for Is Coding with AI Actually Faster and Cheaper?
Sylwia Laskowska
Sylwia Laskowska Community Curator

Posted on

Is Coding with AI Actually Faster and Cheaper?

How has AI actually changed the way we work? Are coding agents really making us remarkably faster? And what if, instead of answering with “well, that's what I think,” we tried looking at some actual scientific research?

This is another article inspired by the upcoming AI Coding Summit in Berlin (and yes, I'll leave a link to my speaker badge at the end again, which I think might come with some discounts). I promised myself I wouldn't do this again, but, as usual, I've also signed up for three panel discussions. 😅 One of them has a title very similar to this article.

I wanted some hard data for that discussion, so I dug into the research. You'll find links to all the studies at the end.

And since today hasn't exactly been a great day for me, and I'd much rather be somewhere else, I figured I'd cheer myself up the usual way. By writing something for you!

Are we actually coding faster?

Let's start with the first question. Has AI really made us faster? If someone suddenly stopped me in the street and demanded an answer, I'd probably say yes. In my experience, we write code much faster now.

But that improvement doesn't seem to translate into an equally dramatic increase in how much software we actually deliver. After all, there's code review, analysis, discussions, and so on and so on. Sure, things are a bit faster. Maybe a little less stressful, too. But I wouldn't say the entire development process has suddenly become much quicker.

Then again, maybe it's just me? Maybe the rest of the world is already shipping features at the speed of light?

Well, apparently not.

A study by economists from MIT and Wharton, revised in September 2026, suggests that my intuition might not be entirely wrong. The researchers analyzed data from more than 500,000 GitHub developers and estimated the following cumulative changes associated with autonomous coding agents:

Metric Estimated change
Coding activity (commits) +240%
Software releases +30%
Total app usage across the marketplaces studied No overall increase

These are observational estimates. Still, the gap between the jump in commits and the increase in releases is pretty striking.

Okay, so we're committing a lot more and shipping somewhat more often. In my own work, it sometimes just feels a little less stressful. But it's hardly the revolution some people make it out to be. Maybe things look different in brand-new projects. In large, established systems like the ones I work on, I haven't seen anything close to a tenfold improvement.

Maybe that'll change when someone invents those super-self-healing-autonomous agents. For now, I sometimes feel like things are getting more complicated. With everything that's been happening around AI security lately, everyone seems to be getting a little obsessed with it. Myself very much included. 😅

But are individual developers actually faster?

Okay, we have more commits. But are we actually coding faster? Again, if I had to guess, I'd say yes, but not that much faster.

The data is mixed.

Study Result What was measured
Cui et al., Management Science, 2026 +26.08% Number of completed tasks
METR, July 2025 19% slower Time to complete tasks
Science, January 2026 +3.6% Estimated increase in quarterly coding activity on GitHub
Borg et al., June 2026 30.7% less time Median reduction in implementation time in the observational phase

Once again, the results are reasonably close to what I expected. I'm not going to spend the next ten paragraphs going over the methodology. If you're curious, the original studies are linked below. They looked at different developers, tools, and tasks, and each percentage measures something different.

Several of these studies do point to gains, though. We're not all suddenly 10x developers. xD But there are real improvements.

METR is the odd one out here. It's from 2025, which, in the current AI world, practically makes it ancient history. But I love one detail about it.

Before the experiment, developers expected AI to make them about 24% faster. The actual result? They were 19% slower! And even after the experiment, they still thought AI had made them faster.

It shows how much we can fool ourselves until we actually measure things. I swear, this applies to practically every area of life. For example, I used to think I barely ate anything. 😂

To be fair, METR published an update in February 2026. The researchers think newer tools are likely to be more helpful, but their follow-up couldn't reliably estimate the speedup because of who was willing to participate.

Okay, but is software development actually cheaper?

If someone woke me up at midnight and asked whether AI had made software development cheaper, I'd probably say no. At least not yet.

The 2025 DORA research and a follow-up published in March 2026 point to something many of us have written about. Some of the time we save writing code goes straight into auditing and verifying it. So the savings on implementation can shrink by the time the change gets to production. DORA describes where that work can shift, leaving the overall cost question open.

Yes, yes, I've heard about multi-agent teams where one agent writes the code, another reviews it, another tests it, and then it all goes into production. I'm sure that can work in some situations. I'd be very cautious about trying that trick in a mission-critical system. Financial software, for example. Good luck with that strategy 😂🤞

What about the cost of tokens?

One last question. Are we spending all the money we save by writing code faster on tokens?

I have to admit, the answer surprised me! If I had to guess, I'd have said yes, especially if you blindly use the most expensive models for absolutely everything.

But the findings are more interesting than that! Two recent studies looked at the economics of AI-assisted software development. One was published in September 2026 by Potluri and colleagues, and the other in October 2026 by Steffen Herbold.

Both suggest that the effectiveness of an AI agent can matter more than the price of the tokens it consumes. In Potluri's analysis, models that solved more tasks produced substantial estimated savings, while less effective models ended up costing more in many task categories. A cheap model can get expensive pretty quickly if it keeps failing and you have to pay for another try.

Herbold simulated 432 scenarios for teams using a mix of developers and AI agents. He included salaries, token costs, supervision, bugs, and technical debt. Teams with highly capable agents were usually cheaper than teams of developers working without AI. The results for less capable agents were mixed. In the simulation, agent capability mattered more than token price because better results cut the cost of checking and fixing the work.

Herbold's results come from simulations, and Potluri's estimates come from benchmarks and economic modeling. So we have two ways of estimating when the savings might outweigh the token bill. The actual cost of building and maintaining commercial software is a much bigger question.

So, what's the verdict?

It looks like AI really can make coding faster and cheaper. Several studies show gains on specific tasks, and the economic models suggest that capable agents can save money even after you pay for the tokens.

We still have less evidence about whether the total cost of building, delivering, securing, and maintaining software has fallen across the industry.

So far, the research mostly lines up with what a lot of us seem to feel. Skynet may already be sharpening its weapons, but it hasn't conquered the world just yet. 😅

And what about you? Do these findings reflect your experience? Has AI genuinely made your team faster and cheaper, or does it look completely different where you work?

I'd love to hear your thoughts!


If you enjoyed this article, you can also follow me on LinkedIn.

And if you'd like access to free materials from AI Coding Summit, you can register using my speaker badge.

References

https://www.nber.org/papers/w35275
https://doi.org/10.1287/mnsc.2025.00535
https://metr.org/blog/2025-07-10-early-2025-ai-experienced-os-dev-study/
https://metr.org/blog/2026-02-24-uplift-update/
https://doi.org/10.1126/science.adz9311
https://doi.org/10.1007/s10664-026-10889-1
https://dora.dev/research/2025/dora-report/
https://dora.dev/insights/balancing-ai-tensions/
https://doi.org/10.13021/jssr2026.5687
https://arxiv.org/abs/2610.20394

Top comments (2)

Collapse
 
dannwaneri profile image
Daniel Nwaneri •

Thanks for this Sylwia. You made me realize that the DORA point was actually a real cost.

The effort gained from coding has been moved to testing (which is never measured).

Not also that I did not know the METR had been updated. I mentioned the 2025 results in my last article, so I am going to correct it asap.

Collapse
 
xulingfeng profile image
xulingfeng •

Hahaha this article couldn’t come at a better time! I’ll chime in on the cost side. I just found out I’m our company’s top token consumer on the AI relay this month. I bought some snacks for the colleague who manages token quotas, asking him to bump up my limit 😂. From what I see on the dashboard, my token usage is almost equal to my monthly salary. It’s like I’ve got a clone of myself, hahaha!🤣