---
title: "AI Is Finding Bugs Faster Than Anyone Can Fix Them"
url: "https://florea.xyz/ai-bug-finding-fix-bottleneck/"
date: "2026-11-17T14:56:54+02:00"
updated: "2026-11-17T14:56:54+02:00"
author: "Bogdan Florea"
topic: "Security"
---

# AI Is Finding Bugs Faster Than Anyone Can Fix Them

Anthropic's Project Glasswing set out to find security flaws in critical software with its most capable models. Seven months in, it has found a great many. Getting them fixed is a different story.

On November 9, VulnCheck's Patrick Garrity published his latest reading of Anthropic's public ledger: 37,966 findings as of November 2, and 217 of them marked fixed. Between September 8 and November 2 the ledger grew by 11,813 findings. The fixed count grew by 15. ([VulnCheck](https://www.vulncheck.com/blog/anthropic-glasswing-november-update))

Those numbers need care, and I'll come to the caveats. But their shape matches what Anthropic itself has said since May: finding bugs is no longer the hard part. Fixing them is. For any business that runs software built on open source, which is nearly every business, that changes what to ask for and what to pay for.

**TL;DR**

- AI has made finding vulnerabilities cheap. Triage, fixes and deployment haven't got any cheaper.
- Judge security tools and vendors by what gets fixed and shipped, not by how much they find.
- Before buying more scanning, make sure someone has the time to triage the results and the authority to fix them.
- Start with known-exploited flaws in the components you actually run. The rest is a queue, not an emergency.

## What the numbers say, and what they don't

Garrity's analysis is critical, and it should be read with its limits in mind.

The 217 is the ledger's "fixed" count. Anthropic follows the usual 90-day disclosure window, so many recent findings aren't due to be public yet. In May it also said its patch counts were likely undercounted, because some fixes ship without an advisory. ([Anthropic, May 22](https://www.anthropic.com/research/glasswing-initial-update)) The ledger includes low-severity findings, more than 1,600 duplicates and 419 withdrawn reports. Setting 217 against 37,966 overstates the gap.

Other numbers point the same way, though. When Anthropic launched its OSS Scanner on October 8, it said the team had found more than 29,000 candidate vulnerabilities over six months and manually reviewed about 6,000, and that it remained "bottlenecked on our human capacity to validate these findings." Nearly 5,000 reports went to maintainers without validation, because those maintainers asked for everything. The scanner's reports are fully model-generated, and Anthropic warns that "it is possible reports will be incorrect or invalid." ([Anthropic, October 8](https://www.anthropic.com/research/launching-opt-in-vuln-finding-service-for-open-source))

Garrity's conclusion is blunt: "the triage bottleneck didn't go away. It moved to the maintainers."

## The view from a maintainer's inbox

curl is a useful example, because its maintainers publish their assessments. Anthropic's OSS Scanner sent curl 45 reports, and by November 14 all of them were public. curl has assessed every one: 5 are low-severity vulnerabilities, and the other 40 were judged not to be vulnerabilities at all. None was rated higher than low. ([curl's issue tracker](https://github.com/curl/curl/issues?q=%22forwarded%20from%20Anthropic%22))

Daniel Stenberg, curl's lead developer, doesn't dismiss AI-assisted reports. In an October post he describes the current problem as "high volume, high quality", with reports that now run to hundreds of lines, and says the project "cannot in good faith pretend they don't exist." ([Stenberg](https://daniel.haxx.se/blog/2026/10/22/ignore-the-slop/))

That's the honest version of the problem. The reports are detailed and plausible, and each one still needs a person to read it, reproduce it, judge it and, if it's real, fix it and release the fix.

Anthropic said as much in May: "the bottleneck in fixing bugs like these is the human capacity to triage, report, and design and deploy patches for them." Several maintainers had told it they were "severely capacity constrained." ([Anthropic, May 22](https://www.anthropic.com/research/glasswing-initial-update))

## Why this matters if you don't maintain open source

Most businesses don't maintain curl. They run it, along with hundreds of other components looked after by small teams. Three things follow.

**The patch queue for your dependencies just got longer.** More reports mean more fixes waiting on the same few people. Expect more updates, some of them urgent, and expect some fixes to take longer than you'd like.

**Your own scanning can build the same backlog inside your company.** AI security tools are getting cheap, and they're good at finding problems. A tool that produces 500 findings for a team with time to fix 20 doesn't reduce risk on its own. It produces a list, and a list of known, unfixed problems is a liability of its own.

**Volume is a poor measure of value.** Garrity tracks 442 CVEs attributed to Anthropic over seven months. Two are in VulnCheck's catalogue of exploited vulnerabilities. That doesn't make the rest worthless, because fixing a bug before anyone exploits it is the whole point. It does mean that a large number, on its own, isn't evidence of lower risk.

## What I'd ask for instead

It's the argument I made about AI budgets: [fund the step where the work waits](https://florea.xyz/ai-budget-bottleneck/). In security, that step is usually triage and fixing.

Before paying for more discovery, I'd want four answers:

- Who reads the findings, and how many hours a week do they have for it?
- Who can decide that something gets fixed now, and who can ship the fix?
- How will we prioritise? I'd start with flaws known to be exploited in components we actually expose ([CISA's KEV catalogue](https://www.cisa.gov/known-exploited-vulnerabilities-catalog) is free), then severity.
- What will we report? Fixes that are deployed, and how long each took, rather than findings found.

I'd ask vendors the same thing, whether they sell a scanner, an outsourced development team or an AI security service: show me what got fixed in a codebase like ours, how long it took and who did the triage. A finding count says little on its own.

And if your business depends heavily on a particular open-source project, the most useful contribution may not be another report. It may be paying for maintainer time, or lending an engineer who can turn a valid report into a reviewed patch.

## The real shift

AI made the first step of security work dramatically cheaper. It didn't make the rest cheaper. Teams that keep measuring discovery will get impressive dashboards and slow fixes. Teams that measure the time to a deployed fix will see where the work waits, and can fund it.

That's the number I'd put in front of a board.
