AI is great at speeding up the process of developing code. LLMs can churn out code dramatically faster than humans.
The problem facing organizations that want to build and deploy software faster, though, is that coding is just one step in the broader process of software delivery. Also critical is validating software to make sure it performs as required.
Overlooking this vital part of software delivery can be easy at a time when much of the hype surrounding development and AI focuses on the development process in a narrow sense. But doing so is a fatal mistake from a quality perspective; we discuss why below.
When AI-generated code harms more than it helps
Historically, writing code was the slowest, most labor-intensive part of software delivery. Building, validating, and deploying software was comparatively easy.
Generative and agentic AI, however, have turned this equation on its head. Now, developers can tell AI models or agents what they want their application to do, then watch as they spit out code.
But when developers can code faster than ever, they can also introduce flaws into software systems faster than ever. If left undetected and unmitigated, those flaws can lead to performance, reliability, and security problems.
The key problem is all the more acute considering that developers are less likely to scrutinize AI-generated code closely. Reviewing it takes much more time than generating it, and most teams lack the resources to validate AI-generated code as quickly as their tools spit it out.
This is why organizations are increasingly drowning in what Kevin Browne calls verification debt. He’s referring to the un-reviewed, un-validated code that piles up when teams use AI to develop software faster than they can deliver.
The risks are real
These issues are far from theoretical. Research from CodeRabbit shows, for example, that major software outages have increased since the debut of ChatGPT in 2022. Other analyses show that AI models are prone to introducing “silent but deadly” failures into the code they write, and that this problem, curiously, is actually worse in more recent models.
Correlation doesn’t prove causation, of course. But if you had to explain why outages have become more prevalent since 2022, bugs in untested AI-generated code are a pretty plausible culprit.
Squaring the circle: Achieving AI speed without compromising quality
Fortunately, it doesn’t have to be this way. It’s possible to deliver software at the speed of AI without accepting the risks that AI introduces to the development process.
The solution requires validating code as quickly as it’s written – which means taking full advantage of modern software test automation tools, combined with AI-assisted orchestration and management capabilities, to ensure that code is fully validated before it’s deployed.
That’s where Leapwork Play comes in. With Play, teams that test applications using the powerful Playwright framework can execute, manage, and update tests with incredible speed and efficiency.
Play can import existing Playwright tests and repositories, and its AI-assisted authoring can generate tests from requirements and application context. Each generated step can be traced back to the source requirement that informed it, helping teams understand what the test covers and why it exists.
Once created, tests will execute deterministically without a model call during normal runtime. This allows teams to use AI to accelerate test creation and maintenance while keeping execution consistent, explainable, and governed.
The result is the ability to ensure that automated testing keeps pace with automated code generation. When it does, teams erase verification debt and enjoy all the advantages of modern AI as a software delivery booster, without the risks.
