Skip to content
Novandri.

How AI Is Changing the Economics of Software Development

AI coding assistants lower the cost of writing code but shift the bottleneck to design, review, and maintenance. Learn what gets cheaper, what does not, and where the economics

Rachmadwipa Novandri8 min read

AI can generate code faster than a human types it. That does not mean software is cheaper to build; it means the constraint has moved from writing code to deciding what code to write and whether it is correct.

Direct answer: AI coding assistants reduce the marginal cost of generating code, but they do not reduce the cost of specifying requirements, reviewing correctness, managing technical debt, or operating software in production.

The economics shift from "cost per line of code" to "cost per correct, maintainable system."

Teams that treat AI as a way to write more code faster often find they have more code to maintain, not better software.

A four-step flow: generate code faster, specify requirements, review correctness, then manage the debt.
Conceptual: cost per correct system, not per line. The economics shift from cost per line of code to cost per correct, maintainable system.

What gets cheaper

AI lowers the cost of:

  • Boilerplate and scaffolding: standard API endpoints, CRUD operations, configuration files, test stubs.
  • Language translation: converting code between languages or frameworks.
  • Documentation generation: docstrings, comments, README sections.
  • Exploratory spikes: quickly trying an approach to see if it is feasible.

For a skilled developer, these tasks already took little time relative to system design and debugging. The absolute savings are real but bounded.

What does not get cheaper

AI does not meaningfully reduce the cost of:

  • Requirements and design: deciding what the system should do, how components interact, and what trade-offs to make.
  • Code review: AI-generated code still needs human review for correctness, security, and maintainability—and reviewing code is often harder than writing it.
  • Testing strategy: deciding what to test, what edge cases matter, and what constitutes sufficient coverage.
  • Operations and maintenance: deploying, monitoring, incident response, and refactoring legacy code.

In fact, these costs may rise. If AI increases code volume without increasing review capacity, the bottleneck shifts downstream. More code means more surface area for bugs, more dependencies to track, and more refactoring work.

The review bottleneck

Reading code to find subtle errors is cognitively harder than writing code to implement a clear requirement. AI-generated code can look correct at a glance while containing logic flaws, security issues, or mismatched assumptions. A reviewer must understand the code well enough to verify it, which requires nearly as much expertise as writing it from scratch.

That is not a productivity gain; it is deferred risk.

Technical debt accumulates faster

AI tends to produce locally coherent but globally inconsistent code: each snippet makes sense in isolation, but the system as a whole may lack consistent architecture, naming, or abstraction. Over time, this creates technical debt that is harder to refactor because no single developer wrote the whole thing and understands its rationale.

The economic effect is a shift in the cost curve: early development is faster, but long-term maintenance is more expensive. The net present value depends on how long the software is expected to live and how much it must change.

Where the economics actually change

AI changes software economics most where:

  • The task is well-specified and repetitive: migration scripts, test data generation, boilerplate APIs.
  • The cost of error is low: internal tools, prototypes, non-customer-facing features.
  • The codebase is small or disposable: scripts, one-off analyses, proof-of-concept implementations.

It changes economics least where:

  • Requirements are uncertain: new products, ambiguous user needs.
  • The cost of error is high: financial systems, medical devices, security infrastructure.
  • The system must evolve over decades: core platforms, enterprise systems.

For teams, the implication is to use AI for acceleration within boundaries, not as a replacement for engineering judgment. Measure outcomes—features shipped, bugs escaped to production, time to incident resolution—not lines of code generated.

For the related question of how AI models scale and where their limits are, see Chinchilla and the Scaling Laws: Why "Just Make It Bigger" Stopped Being the Rule. For how to distinguish tool use from system understanding, see The Difference Between Knowing a Tool and Understanding a System.

What the measurements actually show

The METR study cited at the end of this article is valuable precisely because it measured rather than asked. Experienced open-source developers worked on tasks they knew well, some with AI tools and some without. The counter-intuitive result was that the developers were slower when using the tools, even though they believed the tools made them faster. That gap between perception and measurement is the most important economic fact in this debate.

It fits the earlier sections. The tasks in that study were familiar codebases where the developers already understood the context, so the generation savings were small while review and verification costs remained. This is the review bottleneck in experimental form: time saved typing is spent checking output, and the checking is easy to underestimate because it feels like part of the work rather than a delay.

Brynjolfsson, Li, and Raymond add the workforce-level view. Rapid adoption of generative AI does not by itself demonstrate a productivity payoff; adoption and measured gains can diverge. The same pattern appears at both scales: usage spreads quickly, while evidence of economic benefit accumulates more slowly and unevenly across tasks. Teams should therefore treat productivity claims as hypotheses to measure against their own outcomes, not as settled facts.

The cost that does not appear in the editor

Software economics usually counts developer time, but the full cost of AI-assisted development has an infrastructure component. The IEA's analysis of data centres and electricity demand points to the physical layer beneath code generation: model inference consumes energy, and demand for it is growing. For a team adopting AI tools at scale, that cost is real even when it is hidden in a subscription price or a cloud bill.

This does not overturn the earlier argument; it sharpens it. If generation becomes cheap at the margin, the scarce resources shift to the ones that remain expensive: engineer attention for review, the energy and hardware to run models, and the long-term maintenance of code that was produced quickly. A decision to generate more code is also a decision to consume more of each.

The practical consequence is to measure the whole system. The closing advice to track features shipped, escaped bugs, and incident resolution time already points the right way. Adding the cost of the tooling and its infrastructure to that measurement prevents a local saving in typing time from being mistaken for a net gain. The economics change where the task is well-specified and disposable, as noted above, but only when the full bill is counted.

A worked example

The following is hypothetical and illustrative. Consider a team maintaining a small internal tool that converts configuration files between two formats. The task is well-specified: the input and output shapes are known, and a mistake produces a failing test rather than a customer-facing outage. A developer asks an assistant to generate the conversion script and the accompanying test data. Generation that once took a morning takes minutes, and the economics argument above applies: the task is repetitive, the cost of error is low, and the codebase is disposable.

Now consider the same assistant used on the billing service. The requirement is ambiguous because the finance team has not settled how proration should work, and a mistake could overcharge customers. Here the generation saving is small relative to the work of specifying the requirement, reviewing the output, and validating it against edge cases. The METR measurement discussed earlier is the relevant warning: in familiar codebases, the time saved typing was outweighed by verification time, and reviewers underestimated that cost.

Three checks decide which case applies. First, is the task well-specified enough that a test can define correctness? Second, is the cost of an error low enough that review can be lightweight? Third, will the code need to evolve over years, with maintenance costs that compound? When all three answers are favourable, assistance changes the economics; when any answer is unfavourable, the local saving in typing time can hide a net loss. This is the same boundary the earlier sections draw, now applied to a concrete choice.

A counterargument

A reasonable critic would say the article turns a narrow measurement into a structural law. METR studied experienced developers on codebases they already knew, where generation savings were small and verification dominated; Brynjolfsson, Li, and Raymond show only that adoption outpaces measured gains so far. Neither establishes that review and design are a permanent bottleneck rather than tasks the same tools might also help with. The article names test stubs and documentation as things AI cheapens, yet treats testing strategy and code review as fixed human costs, an asymmetry it does not defend.

By its own advice, outcomes should be measured rather than assumed, but the central claim that the constraint 'moves' downstream is asserted more confidently than the evidence supports.

References & Further Reading