AI is finding bugs faster than humans can fix them: How enterprise security teams must adapt
AI News Desk
·
ZDNet
··
9 min read
Follow ZDNET: Add us as a preferred source on Google.
Follow ZDNET: Add us as a preferred source on Google.
The good news is that AI is finding security holes faster than ever. The bad news is that AI is finding security holes faster than ever. It's both: While it's great that we're finding all those bugs, trying to fix them all is a monster of a job.
Sure, if you're Google, you can fix more bugs in Chrome in June 2026 than you had in the last two years, but most companies aren't Google. They don't have anything like the resources to fix that many security holes.
Indeed, even Apple -- yes, Apple -- has been overwhelmed by AI bug reports. As a result, in June, Apple told security researchers it "restricted the number of potentially dangerous software bugs researchers can submit to its internal security team. If you find a truly horrendous vulnerability, but you're over the limit, too bad. Try again next month.
Hence, the problem. AI-assisted vulnerability discovery is accelerating the pace of bug reports, but the real story is the growing mismatch between what machines can surface and what humans can realistically triage. Thus, we've ended up with an ever-growing burden on developers, security teams, and companies trying to separate exploitable issues from machine-generated noise.
It's not just developers, however, who are having trouble. System administrators, CISOs, and end users are all caught trying to keep up with one patch after another.
The old security workflow assumed high-value bugs would arrive in relatively manageable numbers. You'd look at the Common Vulnerabilities and Exposures (CVE) score and immediately patch the really high ones. You'd also hope that a zero-day vulnerability wouldn't come along and ruin your day. That was then. This is now.
AI has broken that assumption by making it cheap to find large volumes of flaws. While open-source programs have gotten most of the headlines, this is, in no way, shape, or form, an open-source problem. For example, Microsoft's July 2026 Patch Tuesday shipped 570 patches , including three zero-days. This set a record. I'm sure it will be broken before the end of the year.
Why? Not because Windows is less secure than it's ever been. It's because, as Microsoft explained in May, "AI helps defenders discover more issues, customers will see a higher volume of security updates included in each security release." These numbers will only increase.
As Dan Lorenc, co-founder and CEO of security company Chainguard , recently said in a webinar, AI is "now finding vulnerabilities in the software they write and the software they use at a pace that is far exceeding defenders' ability to patch and get updates and fix the vulnerabilities."
He noted that it was always easier to find vulnerabilities than to fix them, but AI has "poured another giant jug of gasoline onto the fire before inventing a better fire extinguisher."
What makes this especially difficult to manage is that not all of these issues are equal. A small number are active, urgent, and exploit-driven, while many others are part of the background hum of fixes. Security teams are being forced to triage issues where the volume itself is a risk multiplier.
For instance, I used to recommend that Windows users hold off on patching their PCs because so many patches ended up going awry, such as the January 2026 Patch Tuesday update . Now, with zero-day attacks coming fast and furious, you may not have any choice but to grit your teeth, update, and hope the patches themselves don't screw you over.
For better or worse, as Greg Kroah-Hartman, maintainer of the Linux stable kernel, put it, " If you're not using the latest stable/long-term kernel system, your system is insecure. " These days, the same is true for Windows, MacOS, and, really, pretty much all programs.
Some of you may think this is a problem mostly for Linux and open-source software. It's not. The Linux kernel is only the most visible case because its maintainers are public and opinionated, and they're already stretched thin. How bad is it? In July, there were 432 CVEs reported in two days in the Linux kernel.
The same thing is showing up across proprietary software; companies are just not telling us about it. You can tell by how much larger their patches and systems have grown. Sure, some of it is Microsoft adding more AI to Windows , but I strongly suspect a lot of it is fixes for potential AI security holes.
Also: Open weights vs. closed: An AI civil war's afoot, and the stakes are existential
For example, Adobe's Acrobat Chrome extension security foul-up, HermeticReader , exposes sensitive WhatsApp Web data with only a visit to a malicious page. These webpages look just like any other kind of page, but when you visit one, the trap springs and opens a sleeping program inside the extension. It then reaches into your WhatsApp and grabs your chat list, contact names, messages, the profile name, and the text of whatever conversation is open -- you know, pretty much everything.
The attack was created by AI linking together three different vulnerabilities that enabled "an unauthenticated, single-visit, zero-click write into the extension's own storage from any web page." Adding insult to injury, this attack was then automated by a crook using the DeepSeek LLM via the Hermes Agent framework.
Also: Microsoft goes all in on new AI-powered Windows security strategy
The one good thing about this potential disaster is that Adobe quickly released an updated version of the extension, which patched the security hole before too much damage was done.
We won't always be so lucky. As Linux Foundation CEO Jim Zemlin said at the North America Open Source Summit, "Today the mean time to exploit has disintegrated from 63 days to -7 days. Exploitation is happening before a patch is even released."
At the same time, another cost of AI-generated bug reports is not just false positives; it's the time required to prove they are false. Maintainers still have to read them, reproduce them, and decide whether they're duplicates, hallucinations, or genuine vulnerabilities buried inside bad framing. That is an expert attention tax, and it hits hardest where teams are small.
Also: AI is getting scary good at finding hidden software bugs - even in decades-old code
This issue doesn't only hit maintainers. It's a matter of concern for you sitting at your home PC and for Fortune 500 CISOs trying to decide whether to patch or not to patch their systems; that is the question. Do you want to be patching and rebooting your system every other day? Can you afford to? Can you afford not to?
The day when you could rely on a solid, stable program running for weeks or even years is over. The patching pace has sped up, and it won't be slowing down anytime soon. Severity scores help less when everyone is drowning in a sea of "high" and "critical" findings.
Companies, just like Odysseus, are caught between Scylla and Charybdis.
They want faster detection, but they also need less noise. AI can help surface real defects earlier, yet the same tooling can generate reports that look authoritative enough to demand review while adding no value. That creates a feedback loop in which security teams spend more time validating reports than fixing the underlying problems. What's a business to do?
Now you may ask yourself, "Why can't AI fix those bugs?" The answer is easy. It can't. It's far easier to find security holes than to fix them. An academic study of 20,000+ issues fixed by AI found that LLMs introduce "nearly 9x more new vulnerabilities than developers, with many of these exhibiting unique patterns not found in developers' code." In short, the cure can be worse than the disease.
Even the best patching AI-driven programs, such as PatchitPy for Python code, still have only an 80% successful repair rate . That's good, but it's far from perfect. Adding insult to injury, some developers have found that after " multiple rounds of AI fixes, the number of critical vulns can go up, not down. "
Why is it so hard? One big reason, according to Ben Hawkes, a computer security expert and former manager of Google's Project Zero , is that "it's hard to capture the fact that a bug can be super serious in one type of deployment, somewhat important in another, or no big deal at all -- and that the bug can be all of this at the same time. Vulnerability remediation is hard. " He's got that right.
So what can you do about it? Google has some suggestions . These boil down to:
Narrow scope: Ask the model for minimal, targeted changes (e.g., "mirror this upstream fix" or "update this dependency to version X") instead of "eliminate the vulnerability."
Separate remediation and verification: Treat verification as its own stage. That means re-running scanners, fuzzers, and targeted tests for the CVE after applying the patch, rather than relying on "compiles and tests pass" as proof of security.
Human review for complex changes: Use AI as a draft generator or search assistant, but keep human engineers in charge of design-level changes, multi-file refactors, and anything touching authentication, authorization, or data handling.
There is also a risk to a company's reputation. If a company appears to ignore vulnerability reports, it looks negligent. If it treats every machine-generated report as urgent, it burns staff time and delays real fixes. The practical outcome is a growing need for stronger security teams, stricter proof requirements, and better use of exploitability signals rather than raw report counts.
Also: 'I'm not a programmer' anymore: Linus Torvalds on the only two tools he uses now
Companies say they're looking for IT security people, but they're not hiring as many people as they did in 2022. Even more disturbing, " ISC2 now ranks budget constraints as the #1 cause of staffing shortages, displacing 'lack of qualified talent' for the first time (ISC2 2024). This shift matters: it means the gap is increasingly a leadership and investment problem, not a skills supply problem. ISACA data corroborates this, showing teams remain understaffed even when qualified candidates exist in the market."
The next phase of this problem is likely to be procedural rather than technical. Organizations will need more aggressive triage rules, clearer disclosure policies, and stronger automation for deduplicating and scoring reports before humans see them. Otherwise, AI will keep increasing both the number of discoveries and the amount of junk wrapped around them.
Also: Linux is getting a security wake-up call - why it was inevitable, and I'm not worried
The key lesson from Linux, Microsoft, and Adobe is that this is now an ecosystem-wide operational issue. AI is not merely finding more bugs; it is changing the economics of vulnerability management, and that shift is hitting every layer of software supply and support.
We must treat these matters seriously, or in the next few months we're going to see IT security problems that will make past major incidents, from the Morris worm to the Marks and Spencer £300 million ransomware attack, look like tempests in a teacup.
