It started with a simple question late on a Monday night. How many CVEs has AWS published over the last three years?
I figured it would be a quick count. A few dozen a year, maybe. Something I could eyeball over a cup of matcha (Not really, matcha is disgusting…).
15 security bulletins in 2024. 32 in 2025. 184 in 2026, and the year is not even over.
That is one hell of a hockey stick. And the question that follows is the one everyone in our industry is asking right now.
Is this happening because AI is finding more bugs, or because AI is writing more of them?
So I went digging. And yes, the irony is not lost on me: I used an AI agent to do a big chunk of the digging. (More on that at the end)
What I looked at
The source of truth here is the AWS Security Bulletins page. I pulled every bulletin published from January 2024 up to bulletin 2026-184 (November 16, 2026). That came to 231 bulletins covering 298 unique CVEs.
For each one I collected:
- The bulletin ID, scope, content type and publication date.
- Every CVE it lists (some only mention them in the body, not the title, thanks for that btw).
- Who AWS credits for reporting it.
- The official CVE record from CVE List V5, with its reserved and published dates.
- Where it existed, the researcher’s own write-up with their disclosure timeline.
One thing I learned the hard way. I assumed the date a CVE ID is reserved would tell me roughly when a bug was reported. Nope. AWS reserves most of its own CVE IDs within a day of publishing them (193 of the 257 it issued itself, median gap of one day). So that date tells you nothing about when the bug was actually found.
The real timelines only come from the researchers themselves. And they are eye-opening. Miggo reported ALBeast on April 6, 2024. The CVE showed up on October 21. Rhino Security Labs waited four months for their IAM username enumeration CVE. Wiz reported CodeBreach on August 25, 2025, AWS fixed it two days later, and the world heard about it in January 2026.
Across the researcher write-ups I found, it was two to seven months from report to public.
How many CVEs has AWS published since 2024?

Two things jump out.
First, 2024 and 2025 were both small years, even if 2025 doubled. Then nothing much happened in early 2026 either. January and February had four bulletins between them. The curve only breaks in the second quarter, and it has not slowed down since. October 2026 alone had 41 bulletins. That is more than the whole of 2025.
Second, it is not one product dragging the numbers up. Yes, the new AI developer tools (MCP servers, Kiro, Amazon Q, the Amazon Bedrock AgentCore and Strands Agents frameworks) went from zero bulletins in 2024 to 50 in 2026. But plain old database drivers went 1, 2, 26. Developer tooling like the CDK, SAM and the SDKs went 0, 6, 30. Someone is going through the entire catalog.
Is AI finding the AWS bugs, or writing them?
There are three explanations I keep hearing, and all of them sound convincing.
- AI is finding the bugs. Security researchers now have agents that can read a whole codebase and poke at it 24 hours a day. More eyes, tireless eyes, more CVEs.
- AI is writing the bugs. Teams are shipping code with Kiro, Amazon Q, Claude Code and friends at a pace nobody could keep up with two years ago. Faster code, more holes.
- AWS is simply telling us more. The boring answer. And sometimes the boring answer is the right one.
There is evidence for all three in the bulletins themselves.
On the finding side, outside reporters were credited on 13 bulletins in 2025 and 102 in 2026. And for the first time, the credits name AI directly: Anthropic on three bulletins (Firecracker, FreeRTOS-Kernel and FreeRTOS-Kernel again, with Claude itself named on that last one), the AISLE research team, plus AI security startups like pwn.ai and Corsen AI. All of them in 2026. Outside AWS’s own pages, the CVE record for the Node.js Brotli bug credits OpenAI Codex Security as the finder.
On the disclosure side, AWS assigned 45% of the CVEs in its own bulletins in 2024, 79% in 2025 and 92% in 2026. AWS now issues CVEs for things like sample code and a setup guide. That shift started a year before the surge, so it explains part of the curve, but not the 2026 jump on its own.
And on the writing side? The bulletins can’t tell you. A bulletin says what broke, not who (or what) wrote it.
So the only way to answer that one is to go to the code.
Tracing CVEs back to the commit with git blame
Most of the affected code is open source, which means the evidence is sitting right there in git. So the plan was simple (on paper):
- Find the commit that fixed each CVE
- Look at the lines that fix changed, and run git blame on them to find the commit that introduced the vulnerable code
- Check both commits for AI fingerprints
Step 2 looks something like this:
# the lines the fix touched, blamed in the commit just before the fix
git blame -w --line-porcelain -L 120,148 <fix_commit>^ -- src/server.py
For the fingerprints I looked for the things AI tools leave behind when they are allowed to: a Co-Authored-By: Claude trailer, a “Generated with Claude Code” footer, Kiro, Amazon Q, Copilot, Cursor or Codex co-author lines, and bot accounts like copilot-swe-agent.
I cloned 111 AWS-maintained repositories to do this. Finding the fix commit was the hard part. Some CVE records point straight at a commit or a PR. Many only point at a release, so I had to search between two release tags for the commit that matched the vulnerability. Where I could not tell for sure, I threw the guess away. I rejected 35 of those rather than pretend.
In the end I traced 109 of the 298 CVEs all the way back to the commit that introduced them. Not everything, but a big enough sample to say something.
Is AI-generated code behind the AWS CVEs?
Of the 109 CVEs I traced, exactly two came from code with an explicit AI marker.
- CVE-2026-120497, a stored XSS in the AI-DLC (AI-Driven Life Cycle) traceability tool
- CVE-2026-107322, an OS command injection in the Aurora DSQL plugin for Agent Plugins
Both vulnerable commits carry a Co-Authored-By: Claude trailer. Both were written in 2026. And here is the part I love: both fixes were also co-authored by Claude. AI wrote the bug, AI fixed the bug. There is something almost poetic about that.
But two out of 109 is about what you would expect by chance. Only around 3% of the commits in these repos carry an AI marker at all, so the marked code has not had much chance to produce bugs yet. It tells us nothing either way.
The bigger surprise was the age of the code. Of the 79 traced CVEs published in 2026, 40 are in code written before 2025. The oldest goes back to 2013. The typical bug had been sitting in the code for about 2.3 years before someone fixed it.
Think about that for a second. Code written in 2013 was not written by an AI. Nobody was vibe coding in 2019. Those bugs were written by humans, missed by humans, and are only now being found.
That looks a lot more like better finding than worse writing.
The CVEs in the shiny new AI tools (MCP servers, Kiro, the agent SDKs) tell a slightly different story. Almost all of them trace back to one big initial commit. Things like feat: AWS API MCP Server or feat(MySql): Add MCP support for Aurora MySQL. Most of those landed in 2025, and none of them carry an AI marker.
Which does not mean a human wrote them.
The devil is in the details here. Inline completions from Kiro, Amazon Q or Copilot leave no trace in the commit at all. A missing marker is not proof of anything. It is a lower bound, nothing more.
Does faster AI-assisted coding produce more CVEs?
So if the markers can’t be trusted, what can?
My hunch was cadence. If a repo suddenly starts producing far more commits and far more code per person than it ever did before, something changed. And in 2025 and 2026, that something is very often an AI agent.
So I measured it. For 57 repos I counted every human commit since 2022 (bots out), and per quarter looked at active authors, commits per author and lines added per author. I left out lockfiles, vendored and generated code, and any single commit over 5,000 lines, so a dependency bump or an SDK migration would not skew the numbers. (One SSM Agent commit added 21 million lines. Not written by anyone, AI or human.)
I flagged a repo as having a velocity jump when lines added per author in 2026 were at least 2x its 2023-2024 average, and either its total commits or its commits per author were at least 1.5x higher too. For new repos with no history, I used the same multipliers against the median of the established repos.
Here is what came out.
The established repos did not speed up. Median lines per author per quarter went 535, 287, 300 and 446 from 2023 to 2026. No upward trend, and 2026 is still below 2023. Only 8 of 42 established repos crossed my threshold in 2026, and only about half of those look like a real change. The rest started from such tiny numbers that a couple of busy weeks was enough.
The new AI-era repos are on a different planet. In 2026, per author output compared to the established median:
| Repo | Output vs the established median |
|---|---|
| aws/agentcore-cli | 17.4x |
| awslabs/aidlc-workflows | 16.6x |
| agentic-community/mcp-gateway-registry | 12.9x |
| awslabs/loom | 6.1x |
Their authors average around 20 commits a quarter. Everyone else does 3 to 4.
And the speed does line up with AI use. Repos with a velocity jump have a median of 1.5% AI-marked commits in 2026. The rest have 0%. In aidlc-workflows it is 20%.
So far so good for the hypothesis. Then I looked at the CVEs.
The fast repos are not producing more CVEs, at least not yet. Counting only bugs from commits of 5,000 lines or less (so both sides of the ratio match), they have 0.26 CVEs per 100,000 lines since 2025, against 0.58 for the rest. But most of their code was written in 2026 and has had less time to be found. Adjust for that and the gap almost disappears (0.58 against 0.69 per 100,000 line-years). It also rests on small numbers, 8 CVEs against 14.
It holds up even when you zoom in. Of the eight established repos that crossed my threshold, only three have a CVE in code written since 2025:
- aws-efs-csi-driver: per author output went from 98 to 408 lines a quarter (4.2x), and commits from 120 to an estimated 192 a year. Zero AI-marked commits. Two CVEs: a mount option injection and unverified access point ownership.
- aws-load-balancer-controller: from 246 to 1,022 lines per author a quarter (4.2x), and commits from 150 to an estimated 407 a year, with the same number of people. Zero AI-marked commits. One CVE: cross-namespace traffic interception.
- projen: from 290 to 1,163 lines per author a quarter (4.0x), while the team shrank from 17.5 to 13.5 active authors. And 6.2% of its 2026 commits are AI-marked, the highest of the eight. One CVE: path traversal and OS command injection.
Four CVEs across three repos. Projen is the only one where speed, a smaller team and explicit AI use all show up together. And even there, it is one CVE.
What does stand out is the big commit. That was true before AI too. Before 2025, only 4.6% of all commits across the 57 repos I measured were over 1,000 lines, yet 56% of the commits that introduced a CVE were that big. Since 2025, commits over 1,000 lines are 6.5% of the total but 72% of the ones that introduced a CVE. Big commits are around 11 times over-represented among the bad ones. When a whole new product lands in one giant commit, nobody properly reviews tens of thousands of lines. Human or machine.
And that is also the catch. A big code drop looks exactly the same in git whether an agent wrote it, or a team built the thing internally for six months and then pushed it to GitHub in one go. Which, if you have ever worked at a large company, you know happens. A lot.
Why are there so many AWS CVEs in 2026?
Here is my take (IMHO, of course).
Right now, the explosion is mostly about finding, not writing. Three things happened at the same time:
- A lot more people are looking. External credits went up almost 8x in a year, and AI-assisted research shows up in the credits for the first time.
- There is a lot more to look at. MCP servers, Kiro, Amazon Q and the agent frameworks went from zero bulletins in 2024 to 50 in 2026. That is 27% of all bulletins this year. MCP servers alone account for 21.
- AWS is disclosing more. It now issues its own CVE for almost everything, including sample code. Good for transparency, not so good for drawing graphs.
But I don’t think AI-written code is off the hook. Not even close.
Remember how fast new code gets found? For bugs in code written since 2025, the typical gap from commit to public CVE is about 9.5 months. And AI-marked commits across the 111 repos I cloned only really took off in 2026, going from basically zero in early 2025 to about 6% of all commits by late 2026, but nearly all of that comes from two AI-first projects (Kiro Crew and AI-DLC). Leave them out and it is under 2%, still up from zero.
So the code that agents are writing right now has only just started its clock. The bill for all of this fast-shipped code has not arrived yet. My guess is that it starts showing up during 2027.
How should teams review AI-generated code right now?
So what should you do in the meantime?
- Treat velocity as a review signal. If a repo or a team suddenly ships 10x more code than last year, that code deserves 10x more scrutiny, regardless of who (or what) typed it.
- Be very suspicious of big drops. The data is clear on this one. Giant initial commits are where the bugs live.
- Mark your AI commits. If your tools can add a co-author trailer, let them. Future you, the one doing the incident review, will thank you.
- If you build MCP servers or agent tooling, assume you are a target. Researchers clearly have. (I wrote about agentic supply chain risks earlier this year.)
Limitations of this analysis
I promised myself I would be honest about the limitations, so here they are:
- This is a sample. I traced 109 of the 298 CVEs back to the code. For the AI tools specifically it is 21 of their 57 CVEs. Kiro IDE is closed source, so none of its CVEs can be traced at all.
- Missing markers prove nothing. Inline AI completions leave no trace in git. Everything I say about AI-written code is a lower bound.
- Cadence is a proxy, not proof. A velocity jump can be an agent, a new team, a re-org or a big internal code drop.
- Upstream code is out of scope. Linux kernel, runc, containerd and friends show up in the bulletins, but they are not AWS code, so I left them alone.
- The bulletins are what AWS chooses to publish. Part of the curve is AWS publishing more, not more bugs existing.
And now the confession I promised at the start. I did this analysis together with an AI agent. It pulled the bulletins, cloned the repos, ran the blames and crunched the numbers. I asked the questions, pushed back when the first answer was not good enough (“markers are not enough, look at the commit cadence”), and then again, and once more, and made the calls on what to believe. I asked the AI to check, double check and triple check. Which, I suppose, is exactly the kind of collaboration this whole post is about.
The full dataset, every bulletin, every traced CVE with its fix and introducing commit, and the cadence numbers for every repo, is in a spreadsheet. Ping me on Linkedin if you would like a copy. Go and poke holes in it.
I plan on running this again in mid 2027. If I am right, that is when the AI-written bugs start to show up.
I would be very interested to hear your thoughts or comments, so please feel free to ping me on Twitter or LinkedIn.