Skip to content
Fast Company Executive Board

The Fast Company Executive Board is a private, fee-based network of influential leaders, experts, executives, and entrepreneurs who share their insights with our audience.

The next AI bottleneck is confidence

Four smarter ways to measure AI-assisted output.

[Photo: Getty Images]

Profile photo of Bhagwat Swaroop

CEO · Sonatype

AI makes one of the most expensive parts of software development cheap: creating code. This huge productivity win is also creating a new bottleneck. When companies can generate software faster than ever, can they trust what they produced?

The industry has worked for decades to remove friction from software creation. Cloud made infrastructure easier to access, while open source gave developers powerful building blocks. Now AI can generate, modify, and assemble code in seconds. Traditional metrics such as lines of code, pull requests, and completed tasks make AI look like an obvious win.

These metrics tell us very little about whether that code survives review, passes security checks, reaches production, and stays there without triggering a rollback or incident. Companies that measure AI by how much code it produces may simply be creating technical debt at machine speed.

Productivity measurement at the wrong point


In one controlled study, GitHub found that developers using Copilot were around 53% more likely to pass basic checks that test whether individual pieces of code work as intended, in a defined coding exercise.

But whether AI makes developers faster focuses on only one part of the software lifecycle. The business outcome that matters is how efficiently an organization can turn that code into reliable, production-ready software. And that’s where the picture becomes more complicated.

In practical terms, security teams are fixing problems faster, but they have far more software and potential problems to keep track of. Between January 2024 and May 2026, our research found that companies were creating nearly five times as many applications per month.

At the same time, the average application contained more than four times as many serious security weaknesses. Companies also reduced the typical time vulnerabilities remained unresolved, with the median age falling 59%.

It also demonstrates the AI-era paradox. Companies improve their ability to clean up software risk, even as the volume of software, dependencies, and decisions requiring evaluation expands even faster.

AI is one of many forces behind these trends. Attackers evolve, open-source ecosystems grow, and software itself becomes more complex. But AI clearly accelerates the pace at which software can be assembled, which is far faster than humans can reasonably inspect it. The bottleneck is moving downstream.


AI creates verification debt



When an AI agent generates what looks like a simple feature, it may also pull in outside software, choose an outdated version, or change who can access sensitive information.

Imagine a retailer using AI to add a customer returns feature. The feature might work as expected, but an outdated software component could expose customer account data. Teams can easily miss the risk when they focus only on whether the new feature works.

Our research found that when vulnerable dependencies were selected, a materially lower-risk version was already available. In many cases, teams could have avoided taking on that risk simply by choosing a safer available version.

Sometimes no safer alternative exists. But often, the developer or AI system lacks enough context to make that safer choice. At machine speed, these oversights accumulate into a new kind of engineering overhead, which we call “verification debt.”

After all, someone must eventually understand every piece of machine-generated output well enough to trust it. If AI saves a developer 20 minutes writing code but adds an hour of reviewing, repairing, or explaining the resulting change, the organization has merely moved work to a less visible place and lost overall productivity.

4 smarter ways to measure AI-generated work

Enterprise AI’s next stage of adoption requires a new way to measure value. Instead of asking how much AI-generated work developers can produce, executives should focus on what happens after the work is generated.

Four measures matter:

1. Production yield: What percentage of AI-assisted changes successfully reach production and remain healthy?

2. Rework: How many additional review cycles, bug fixes, rejected changes, rollbacks, or follow-up commits does AI-generated work require?

3. Risk introduced: How often do AI-assisted changes introduce vulnerable dependencies, unsafe configurations, or other avoidable problems?

4. Human oversight: How much human attention is required to turn machine-generated output into something the organization can trust?


    Together, those measures provide a more meaningful picture of AI’s value. I think of it as confidence-adjusted productivity. The relevant question to ask now is “How much trustworthy, production-ready software did AI help us deliver for each unit of human and machine effort?”

    Reconsider AI’s value

    Confidence-adjusted productivity is the starting point. Once organizations understand where AI-generated software creates rework or introduces risk, the next challenge is acting on that information. That requires balancing automation, better intelligence, and human oversight, especially as the volume of AI-generated software grows.

    AI can generate code in seconds. Accountability still rests with the organization deploying it. Companies that succeed in this next phase will set clear rules for which changes AI can make on its own, which require additional checks, and which need a person to review and approve.

    The next AI bottleneck will be our ability to move from generated to trusted software as fast as AI lets us create it.

    Bhagwat Swaroop is CEO at Sonatype.