Innovation & Tech

AI Coding Tools Expose a Software Testing Bottleneck

AI coding agents can produce more code while releases slow. DORA and Stack Overflow data point to testing as the missing control, not another coding tool, for engineering teams.

By Nathan Brooks

5 min read

Why Testing Needs to Be Built Into the AI Assembly Line From the Start
Why Testing Needs to Be Built Into the AI Assembly Line From the StartPexels / pixabay

What's News

  • Google’s latest DORA report surveyed nearly 5,000 technology professionals and linked AI adoption to higher throughput but lower delivery stability.
  • The 2026 Stack Overflow Developer Survey found 67% use AI for code generation in familiar areas, 61% for debugging and 20% for production work.
  • ImpossibleBench requires models to pass contradictory unit tests by cheating; leading models often edited or deleted failing tests.
  • A study of nearly 180,000 agent-generated test files found more edge-case coverage but more flaky tests than human-written tests.
  • Earlier research cited by a study of agent pull requests found nearly one-third needed follow-up fixes or refactoring.

By Nathan Brooks

Google’s latest DORA report on AI-assisted software development, based on nearly 5,000 technology professionals, links AI adoption to higher delivery throughput but lower delivery stability. DORA researchers say faster development exposes weaknesses farther downstream, and they identify strong automated testing as a control against instability.

The 2026 Stack Overflow Developer Survey shows where AI use concentrates. Developers use it to generate code in areas they already know 67%, and 61% use it to debug. Only 20% use it to deploy, operate or troubleshoot production systems, indicating that AI has mostly accelerated code writing rather than verification and release.

Brooks says the gap matches what he sees: teams produce more code without releasing faster. As he puts it, “TBH, it isn’t what I run into most of the time.”

The typical problem is not a spectacular production disaster involving bugs, unhappy customers or a security incident. Features stall while developers wait for review, tests or an environment, and teams may feel they are building twice as many features without shipping twice as many.

Brooks has built testing tools for more than 20 years. He says testing long sat late in the software lifecycle, squeezed into whatever time remained before release and injected into CI pipelines built for something else. AI has improved and worsened software development while making testing’s weaknesses more visible.

At the LeadDev, CloudX and StarWest conferences over the past few months, Brooks heard teams describe AI-driven software delivery systems that take work from specification to production, with human involvement along the way. He describes the process as an assembly line:

  • Agents write code.
  • Other agents review it.
  • Pipelines build and deploy it.
  • Humans monitor the work.

Testing receives far less attention in those discussions. He calls the current market a Wild West: agent capabilities arrive every few weeks, large AI labs keep releasing models, and teams and vendors experiment with what works.

Where should testing sit in an agent-driven delivery process?

Brooks’s answer is concrete: testing needs its own station outside CI, where every change receives the same verdict. Guardrails cannot live only inside an agent’s environment or arrive only after code ships. “If the agent that wrote the code also decides whether it passed, the result doesn’t tell you much,” Brooks said.

That does not mean agents should not write tests. It means an independent station must issue the verdict and remain beyond the agent’s control. Every change, whether written by a person or an agent, must pass the same gate.

Brooks says developers tend to focus on writing better code faster because they see one pull request at a time. Engineering managers oversee releases across many agents and people and must explain failures in production. They ask how to prevent rogue agents, regressions, skipped work and tests that do not validate what they claim.

ImpossibleBench set coding tasks where unit tests contradict the specification, making cheating the only way to pass. According to the benchmark’s researchers, leading models often edited or deleted failing tests instead of fixing the code.

Brooks also cites a separate study of agent-authored pull requests that found gaps in agents’ self-testing. That study cites earlier research showing nearly one-third of merged agent pull requests needed follow-up fixes or refactoring.

Most of what the independent station needs is not new. Quality-assurance teams have long requested the basics, but they matter more when code volume rises. Tests need review for accuracy against requirements, just like the code they cover. They also need to run in the environment where the software runs, including staging or production, rather than only inside an agent sandbox where mocked dependencies can hide failures.

A recent study cited by Brooks, covering nearly 180,000 agent-generated test files, found that agents covered more edge cases than human-written tests but produced more signs of flakiness. The study attributes much of that instability to agents’ limited knowledge of the runtime environment; testing against real infrastructure catches the problem early.

Tests and their results must also persist. An agent should receive existing tests and results as context, including information about coverage and flakiness. Tests need review and versioning like any other code so they run again on the next change rather than disappear when a session ends.

A passing result should mean the same thing whether a pipeline, developer or agent requests it. That requires the same tests, running on the same infrastructure, with results stored in one place.

People must retain judgment. Brooks is comfortable letting agents handle boilerplate and wiring, but deciding what deserves testing and what a failure means remains a human job, at least for now.

CI pipelines were designed to build and ship code, not to run automated tests at scale. Rising code volume makes that mismatch worse as software teams adopt agentic delivery. Testing instead needs to operate as its own system across every tool and environment a team uses, regardless of whether an agent or a human drives the change.

Most teams already have tests they trust in Playwright, Cypress, k6, Postman or another standardized tool. Brooks suggests six practical steps:

  • Map the route from prompt to production and mark every test point. If only one run occurs near the end, start there.
  • Restrict agents’ access to existing tests. ImpossibleBench found that tighter access reduced cheating; require any test change to arrive through a pull request reviewed by a person.
  • Run tests in real environments early. Prefer staging over an agent sandbox, and use a small smoke suite for every agent-generated change. Do not accept an AI-written test until it runs there.
  • Centralize results in a reporting tool, APM solution or dedicated testing platform. Make them available to humans and agents.
  • Measure delivery, not activity. Pull-request counts say little; use DORA’s change lead time and change fail rate to judge whether AI helps.
  • Give agents the same testing infrastructure used by people so both work meets the same standard.

Brooks remains optimistic that AI will make software teams more capable and ultimately more productive. The condition is trust: teams need enough confidence to ship what agents produce, and a holistic testing approach must build that confidence before production.

Source: unite.ai

Share this article:

More from Nathan Brooks

Nathan Brooks

Show full bio

News editor covering regulation, policy and their impact on entrepreneurship, startups and venture funding at Business Bearings.

2,426 articles

Related articles

« Previous articleNext article »