How AI changed software development costs

"AI made development cheaper" is the sentence every vendor now leads with. It's partly true, and the parts that aren't true cost real money. So it's worth being precise about what the evidence actually shows, because the same research gets quoted to prove opposite things.

Start with the distinction that organizes everything below. A controlled experiment randomly assigns some developers to use AI and some not, then measures what they actually build. It can show cause and effect. A self-reported survey asks developers how they feel about AI, which measures perception. Both are useful, but they answer different questions, and in the one place we can compare them directly, they disagree: METR's developers felt about 20 percent faster while measurably running 19 percent slower³.

Adoption is not in question. In the 2025 Stack Overflow survey, 84 percent of developers said they use or plan to use AI coding tools⁴, and an earlier GitHub survey found 92 percent of US enterprise developers already using them⁸. The open question is what that adoption did to the cost and quality of the software that ships. That's what the rest of this guide works through.

These are the numbers to anchor on, because they measured shipped output rather than sentiment:

Here is what each one actually did, because the details are the whole story¹²³:

1. GitHub Copilot, 2023: 55.8 percent faster (simple, greenfield)

   A randomized controlled trial with 95 developers timed how long it took to build a JavaScript HTTP server from scratch. The Copilot group finished in about 1 hour 11 minutes versus 2 hours 41 minutes without it, 55.8 percent faster. This is the strongest positive result, and it's on the easiest kind of work: a fresh, self-contained task with no existing code to respect.

2. Google, 2024: about 21 percent faster (complex enterprise task)

   A randomized controlled trial with 96 Google engineers measured time on one complex, realistic enterprise task. The AI group came in roughly 21 percent faster, though with a wide confidence interval. It's a real gain on harder work than the Copilot task, but a smaller one, and a useful midpoint between the two extremes.

3. METR, 2025: 19 percent slower (mature, familiar codebases)

   The key counterpoint. A randomized controlled trial had 16 experienced open-source developers complete 246 real tasks on their own large, mature repositories using early-2025 AI tools. They predicted a 24 percent speedup and still felt about 20 percent faster afterward, but the measured result was 19 percent slower. AI dragged on complex work in code the developers already knew intimately.

A smaller McKinsey study is often cited alongside these, reporting that AI helped developers complete some tasks up to twice as fast, with the largest gains on documentation and new code and the smallest on complex work and for junior developers¹¹. It points the same direction as the controlled trials: big help on the easy, well-defined parts, less help where the work is genuinely hard.

Line the three studies up by task difficulty and novelty and the disagreement disappears. The Copilot task was simple and greenfield: build an HTTP server from nothing. The Google task was complex but still a discrete, well-defined piece of enterprise work. The METR task was the hardest kind: real changes to large repositories that developers had built and maintained for years, where they already carried the context in their heads and AI mostly slowed them down by suggesting things they had to read, check, and often discard¹³.

So the honest rule of thumb is not "AI makes development X percent cheaper." It's that AI compresses cost most when the work is simple, new, and well-scoped, and least (sometimes negatively) when the work is complex, legacy, and already understood by the person doing it. That single pattern predicts every result in the controlled studies, and it's the pattern that matters for deciding where AI actually lowers your bill.

The perception gap is the single most important finding in the whole body of research. METR's developers didn't just guess wrong beforehand (they predicted a 24 percent speedup); they still believed they'd been about 20 percent faster after finishing, while the stopwatch said 19 percent slower³. If experienced developers can't feel a 39-point swing in their own productivity, no survey that asks "are you faster with AI?" can be trusted as a measure of real output.

Look closely and even the surveys are cooling. In the 2025 Stack Overflow survey, adoption rose to 84 percent, but favorability toward AI tools fell to 60 percent, and only about a third of developers said they trust the accuracy of AI output⁴. The friction has a specific shape: 45 percent named code that's "almost right, but not quite" as their top frustration, and 66 percent said they now spend more time fixing that almost-right output⁵.

Google's DORA research, which tracks delivery performance across thousands of teams, found the same tension in the data rather than the mood. In its 2024 report, a 25 percent increase in AI adoption correlated with a 1.5 percent drop in delivery throughput and a 7.2 percent drop in stability, with 39 percent of developers reporting little or no trust in AI⁶. The 2025 report, with 90 percent of developers now using AI, saw throughput recover into positive territory while stability stayed under pressure⁷. The lesson isn't that AI is bad; it's that faster typing does not automatically mean faster, more stable delivery.

Two independent 2025 analyses put numbers on the quality cost, and they point the same direction⁹¹⁰:

Here is what those trends actually mean for a build:

1. Duplicated code and less refactoring

   GitClear's analysis of 211 million changed lines found copy-pasted code clones rose from 8.3 percent in 2021 to 12.3 percent in 2024, while the share of lines that were refactored (cleaned up and reused) fell from 25 percent to under 10 percent. AI generates plausible code fast without knowing what already exists, so it duplicates instead of reusing. That's technical debt: software that ships quickly but is harder to change later.

2. Security vulnerabilities

   Veracode's 2025 GenAI Code Security Report tested AI output across languages and found 45 percent of samples introduced a vulnerability from the OWASP Top 10, rising to 72 percent for Java. Speed means nothing if roughly half the generated code carries a known security flaw. This is the cost that never appears in a productivity headline, and the one only a competent reviewer catches.

3. Time lost fixing almost-right code

   In the 2025 Stack Overflow survey, 45 percent of developers named code that's almost right but not quite as their single biggest frustration, and 66 percent said they now spend more time fixing that output. The routine part gets faster; the debugging part gets slower. On the wrong task, the second effect can swamp the first, which is exactly what METR measured.

4. Delivery stability regressions

   Google's DORA research found that heavier AI adoption correlated with lower delivery performance: in 2024, a 25 percent increase in AI use lined up with a 1.5 percent drop in throughput and a 7.2 percent drop in delivery stability. The 2025 report saw throughput recover but stability still under pressure. More code, shipped faster, does not automatically mean better software.

None of this makes AI useless. It makes AI output raw material, not finished work. The 45 percent vulnerability rate and the rising clone rate are exactly the problems a senior engineer exists to catch and fix. Which is why the saving is real only when someone competent reviews everything before it ships, and a fiction when nobody does.

Match your build to the curve from the controlled studies. A fresh internal tool, a customer portal, a first version of a SaaS product, a booking or quoting system: these are greenfield, well-defined, and exactly where AI-accelerated development earns the largest real saving. That's why quotes that would have been six figures a few years ago can now come in lower. Most small business software (commonly a $30,000 to $150,000 build) lives right in this zone¹⁶.

The opposite end is where the saving evaporates: deep changes to a large legacy system, heavily regulated data, or anything gnarly enough that a senior already holds the context in their head. That's the METR case, where AI ran developers 19 percent slower³. If your project is mostly that kind of work, be skeptical of any quote that assumes a big AI discount.

And AI changed none of the structural reasons software goes over budget. The durable benchmarks still hold: only about 29 percent of software projects fully succeed on time, on budget, and on scope¹²; large projects average 45 percent over budget while delivering 56 percent less value than promised¹³; and poor software quality cost the US an estimated $2.41 trillion in 2022¹⁴. Faster code generation does nothing about loose scope, hourly billing, or skipped review. If anything, the duplication and vulnerability data mean sloppy AI use makes the quality problem worse, not better.

Every finding in this guide converges on the same conclusion. AI helps most on simple, greenfield work, which is most small business software. AI hurts on complex, legacy work, which needs experienced judgement anyway. And AI output carries real quality and security risk, which only a competent reviewer catches. Put those together and the model writes itself: senior engineers, accelerated by AI, reviewing everything. Not AI instead of engineers, which is the version the data actively warns against.

That model is also why hourly rate is the wrong thing to shop on. Specialist senior talent costs more per hour (AI and machine-learning specialists command a 40 to 60 percent premium over generalists)¹⁵, but that senior is precisely who turns fast AI output into software you don't have to rebuild. Cheap, unreviewed AI code is the most expensive kind once you count the fixing.

It's how we build at AI Dev. Senior engineers use AI to compress the routine work, then review and refactor everything that ships, and we pass the genuine saving into a fixed quote against a written scope rather than pocketing it. You own the code, the repositories, the infrastructure, and the IP outright, in your name, with no license and no lock-in. Our custom software development service and our custom software build methodology both spell out exactly how that runs.

If you want to see how a build runs from idea to launch with senior review on everything AI touches, read our custom software build methodology, or the overview on our custom software development services page. If you already know it's a web app or a mobile app, our web app development and mobile app development pages cover the specifics of each.

For the money side, our companion guide on how much custom software costs lays out the 2026 cost bands, developer rates, and the fixed-price terms that keep a build honest. And you can browse the full guides library for the rest of the series.

If you'd rather just get a real number for your specific idea, our free 48-hour build plan turns a few sentences into a written scope, a milestone breakdown, and a fixed quote, with no sales call and no obligation. When you're ready to move, start your build here.