The 'Software Factory' Myth: AI Is Helping Companies Ship Bugs Faster

A widely shared analysis argues that most enterprises adopting AI coding tools to build a 'software factory' are really just shipping bugs faster: AI accelerates code production, but downstream testing, review and CI/CD don't scale with it, so defects and incidents climb. Data cited from Faros AI shows developer throughput up sharply -- but incidents and bugs rising even faster.

By the Numbers

+33.7% per developer
Dev Throughput
+16.2%
PR Merge Rate
+242.7%
Incidents-to-PR Ratio
+54%
Bugs per Developer
Faros AI
Data Source
Trace Cohen
By Trace Cohen · Value Add Pulse AI Desk
Founder & Editor-in-chief, Value Add VC
2 min read
The 'Software Factory' Myth: AI Is Helping Companies Ship Bugs Faster: key figures
ShareXLinkedInEmail

THE RUNDOWN

1

The productivity story around AI coding has a quality counter-story that boards are starting to notice

2

If incidents rise faster than output, AI coding can destroy value instead of creating it

3

It creates demand for AI-era testing, review and reliability tooling -- a new picks-and-shovels layer

4

It reframes the real bottleneck from writing code to verifying it

The VC Read

Value Add VC analysis

This is the most important contrarian data point in enterprise AI right now: throughput up 34%, but incidents up 243%. AI didn't remove the bottleneck, it moved it -- from writing code to verifying it -- and most orgs haven't reallocated a dollar to the new constraint. That gap is the investable thesis: AI-native testing, review and reliability tooling is the picks-and-shovels layer underneath the coding-assistant boom. Founders pitching 'we make engineers faster' should have an answer for 'faster at what, exactly' -- because boards are about to start asking whether the speed is shipping value or shipping bugs.

Analysis

A widely circulated analysis is puncturing one of enterprise AI's favorite narratives -- the idea that AI coding tools turn engineering organizations into high-output 'software factories.' The argument: AI dramatically speeds up the writing of code, but the downstream parts of the software lifecycle -- testing, code review, deployment safeguards and quality control -- don't automatically scale with it, so the net result for many companies is simply shipping bugs and incidents faster.

The data gives the thesis teeth. Figures cited from Faros AI show task throughput per developer up 33.7% and pull-request merge rate up 16.2% -- real productivity gains. But over the same period, the ratio of incidents to pull requests jumped 242.7% and bugs per developer rose 54%. In other words, the defects are climbing far faster than the output, suggesting that AI-accelerated coding without commensurate investment in quality controls can erode reliability rather than improve it.

“Figures cited from Faros AI show task throughput per developer up 33.7% and pull-request merge rate up 16.2% -- real productivity gains.”

The finding lands amid a broader reckoning over how to actually capture value from generative AI in the enterprise. The early phase was about adoption and raw productivity metrics; the maturing phase is about whether that productivity translates into better, more reliable software or just more churn. It connects to the same discipline behind efficient agent memory and rigorous agent evaluation -- the unglamorous engineering that separates production systems from impressive demos.

The competitive implication is a new market opportunity. If writing code is no longer the bottleneck, verifying it becomes the constraint -- creating demand for AI-native testing, automated code review, observability and reliability tooling. Companies like the agent-evaluation startups drawing fresh venture funding, alongside established devops and quality vendors, are positioned to sell the guardrails that AI-accelerated teams now need. The bottleneck moving from production to verification is itself an investable thesis.

The bear case for the alarm: a single vendor's dataset can be unrepresentative, the quality dip may be a transitional growing pain as teams adapt their processes, and better AI review tools could close the gap. What to watch: whether independent studies corroborate the incident surge, how engineering leaders rebalance investment toward quality controls, and whether 'AI for verifying code' becomes as big a category as 'AI for writing code.'

ShareXLinkedInEmail

More from the Pulse archive: Artificial Intelligence coverage → · All topics

Key Sources

1 source

Reported by VentureBeat · Analysis by Value Add Pulse.

← Back to Pulse

THE WIRE in your inbox— Tech, startup & VC news with The VC Read, a few times a week. Free to subscribe, no spam.

No spam, unsubscribe anytime. Sent via Substack · Privacy · or subscribe on Substack ↗

Read Next

AI
A New Agentic Memory Framework Uses 118K Tokens Per Query -- LangMem Burns 3.26M
Illustration for: A New Agentic Memory Framework Uses 118K Tokens Per Query -- LangMem Burns 3.26M
AI

A New Agentic Memory Framework Uses 118K Tokens Per Query -- LangMem Burns 3.26M

A newly detailed agentic memory framework reportedly answers queries using about 118,000 tokens, versus roughly 3.26 million for the widely used LangMem approach -- a ~28x efficiency gain. As AI agents take on longer, multi-step tasks, how they store and retrieve memory is becoming a decisive factor in both cost and capability.

AI
OpenAI Poaches Uber's India Chief to Lead Its Biggest Market Outside the US
OpenAI Poaches Uber's India Chief to Lead Its Biggest Market Outside the US logo
AI

OpenAI Poaches Uber's India Chief to Lead Its Biggest Market Outside the US

OpenAI has hired Uber's India head to run its operations in the country, signaling how seriously the company is treating India -- its largest user base outside the United States. The move pairs a frontier AI lab with a seasoned local operator as OpenAI races to convert massive Indian usage into revenue and entrench itself before rivals.

AI
OpenAI Launches GPT-5.6 -- But the Government Decides Who Gets to Use It
OpenAI Launches GPT-5.6 -- But the Government Decides Who Gets to Use It logo
AIGPT-5.6 (Sol/Terra/Luna)

OpenAI Launches GPT-5.6 -- But the Government Decides Who Gets to Use It

OpenAI unveiled its most capable models yet -- GPT-5.6 Sol, Terra and Luna -- but at the Trump administration's request limited the initial release to a small group of trusted partners whose identities are shared with the government. OpenAI complied while publicly objecting, warning that 'this kind of government access process should not become the long-term default.' The move mirrors restrictions placed on Anthropic's frontier models and marks the first time the US government is effectively vetting who can access America's leading AI systems.