Imagine AI can code at a much higher rate. It’s easy to think development is going to get a lot cheaper. But if writing code is ninety percent cheaper, who really saves the money? Neither developers nor customers will automatically get the gains. Value goes directly to whomever owns the next bottleneck in the lifecycle: code review, safety verification, environment context and production ownership.
Weak incentives, fuzzy engineering boundaries and missing verification pipelines will suck away savings. Employers will increase expectations of total output. Agencies are moving their pricing from hours to business outcomes. Platform providers will monetize the workflows to make generated code safe to deploy. Founders will expand project scopes instead of shrinking budgets using cheaper development. Typing code faster does not equal cheaper software delivery.
Consider the landmark METR study that came out in early 2025. This followed sixteen experienced open source developers working on almost two hundred and fifty real issues in GitHub projects with large codebases. Surprisingly, tasks where AI was allowed took 19 percent longer than tasks where AI was disallowed. Developers had expected a twenty-four percent speedup and thought they got a twenty percent improvement afterward.
A later update showed these specific metrics are historical as models and developer habits evolve fast, but the root lesson remains. It’s difficult to isolate real productivity. When you consider codebase reading, verification, and critical judgment, typing is a tiny part of the physical cost. The savings are tiny if AI speeds up writing but leaves context setup and safety untouched.
When code generation becomes cheap, the review process is the bottleneck. See the data in the DORA 2025 report surveying thousands of tech workers. AI tools can augment your existing engineering foundation. Speed is captured by teams with tight feedback loops, automated testing and clean architecture. Teams that don't do this are just adding technical debt. AI adoption was actually negatively correlated to delivery stability, although it did help with throughput.
Faros has a clear productivity paradox. In their study of more than 10,000 developers, engineering teams with high AI utilization completed 21% more tasks and submitted 98% more pull requests. But review times soared 91 percent, average pull request size grew more than 150 percent, and bugs per developer increased 9 percent. Importantly, company-level business outcomes were flat. AI makes generation cheap, but safety review, quality assurance and verification become the scarce, expensive resources.
For working developers these savings are eaten up by sprint planning. As managers witness a great deal of AI being adopted, their thinking shifts regarding what constitutes a normal workload. The DORA 2025 report tells us that more than 8 out of 10 developers feel that AI improved their individual productivity. Management responds with more tickets, more concurrent projects, and automated tests by default. The work queue grows to fill the productivity space.
The main headache here is verification. In the DORA report about thirty percent of respondents still admit they have little or no trust in AI-generated code. That is less than the thirty-nine percent in 2024, but it’s still a significant volume of code that requires heavy human vetting. Reading and checking code is the new bottleneck, when output volume outstrips raw trust.
Software agencies and service firms also absorb these savings as margin. Take Globant, for instance, which moved from hourly pricing to consumption-based subscriptions across the entire design, product and engineering cycle. They allow AI agents to generate draft assets, with human experts concentrating solely on quality assurance, strategic context, and system verification. Clients pay for results and risk reduction, not for typing hours.
Similarly, Grid Dynamics employs credit pricing models that integrate engineering labor and platform software. If clients are unable to push prices down, the agency takes the risk and gets the margin. High-end work that requires domain knowledge and system-level validation is still expensive.
Platform companies will also capture a lot of this value. Platforms govern your execution context, your repository history, your deployment pipelines, your permissions, your guardrails. In fact, the DORA report highlighted that a strong internal developer platform is key to capturing and retaining AI value, with ninety percent of organizations adopting at least one platform. Their AI Capabilities Model maps out how platforms decide whether AI gains stick.
Software vendors protect their pricing by adding a premium for AI capabilities. BCG’s analysis found that 68 percent of software companies charge premium rates for AI features or lock them inside enterprise tiers. Highly regulated software commands premium prices due to compliance, deep integrations and maintenance needs. The pricing power is in the workflow tools that verify, secure and monitor the code.
Cheaper code creation doesn’t shrink engineering budgets for founders and startups. Instead, they are creating many more features at the same price. A small team can support more integrations, build custom versions, and delay hiring. But this optionality is only valuable if the founders have processes to test and run this additional logic. Cheap generation without verification and ownership just leads to fragile codebases that can't be maintained.
What I'm building
Delegate tasks. Get software.
Give Vroni a GitHub issue, bug report, spec, or rough idea. It reads the repo, plans the change, writes code, runs checks, and works toward a review-ready pull request.
Take a look at vroni.comI respect your privacy. Unsubscribe at any time.