AI-powered security tools are now surfacing software vulnerabilities faster than human reviewers can keep up. Engineers are racing to close these flaws before attackers exploit them. The emerging picture isn't a simple "AI strengthens security" story; it's unclear which direction the gap between discovery speed and patching speed is widening.

What happened?

Large language models, and the code-analysis tools built on top of them, have started scanning source code and flagging security flaws that previously slipped through. The volume of vulnerabilities being produced exceeds the output of traditional static analysis tools. As companies try to triage and close the flaws they find, the fact that the same capability is available to attackers is raising concern.

Why does it matter?

The security world has lived for decades with a basic asymmetry: the defender has to close every hole, while the attacker only needs to find one. AI scaling up the work of finding flaws affects this balance from both directions. On one hand, security teams can now audit their own code at a depth that was never possible before. On the other, that same tool is in the hands of an attacker scanning publicly available software.

The truly critical point is old code. Millions of lines of "legacy" code that have run in production for years, that no one has reviewed again, have suddenly become scannable. Finding a single flaw used to take an expert researcher weeks; that cost effectively kept most vulnerabilities hidden. Once models drive that cost down, flaws that sat quietly for years become visible all at once. Calling it a "flood of vulnerabilities" wouldn't be wrong — and the rain is falling on defender and attacker alike.

This isn't a new dynamic, it's an accelerated old one. Fuzzing and automated scanning have been around for years. Projects like Google's OSS-Fuzz have found thousands of bugs in open source software. What makes AI different isn't quantity but its ability to understand context: it can interpret what the code is trying to do and flag logic errors too, not just known patterns.

Which way is the gap widening?

The heart of the matter is this contradiction: the same model is both shield and sword. What decides the outcome is whether a flaw can be closed faster than it can be exploited.

FactorFavors defenseFavors offense
Finding flawsScans your own code firstScans your rival's code too
Patching processAutomated fixing is speeding upPatch deployment is slow, users don't update
Legacy codeCan finally be auditedNo one owns the patch for unmaintained code
ScaleEnterprise teams winSmall/abandoned projects left exposed

The table doesn't show a one-sided victory. A well-resourced company can close and deploy a fix for a discovered flaw within hours. But in a library that's been left unmaintained, there's no one to write a patch; there, finding the flaw means direct risk. Because much of the software supply chain falls into this second category, the overall impact is far from clearly in defense's favor.

Another problem is the cost of verifying the flaws that are found. As models produce large numbers of candidate vulnerabilities, a significant share can be false positives. When a human engineer has to sort out which ones are real, the "flood of vulnerabilities" can turn into distracting noise instead.

What's next?

There are a few indicators worth watching. First, whether responsible disclosure windows will shorten — as tools speed up, the classic 90-day window will come under pressure. Second, the maturing of automated patch generation; if the AI that finds the flaw can also reliably write the fix, the gap closes in defense's favor. Third, how open source maintainers will handle this influx — the burden falling on the shoulders of volunteer developers isn't sustainable.

The cautious assessment is this: AI isn't fundamentally tilting the security balance toward defense; it's accelerating the existing asymmetry. The winners will be the actors who can deploy patches fast and who have the resources. The piles of unmaintained, aging code are the most fragile side of this acceleration — and a large part of the software world sits in exactly that place.