It’s not often that I agree with an executive at Anthropic. We have different goals.

But I agree with Anthropic Deputy CISO Jason Clinton on one big thing: we’re walking largely unprepared into an era of IT where the ability to find a problem will outpace the ability to fix a problem.

Security folks have seen this coming for a while. Back in May, the Cloud Security Alliance published The “AI Vulnerability Storm”, breaking down how AI-driven vulnerability discovery is collapsing the window between finding a bug and exploiting it from weeks down to hours.

Clinton’s most recent warning comes right on the heels of two scary remote code execution issues reported in core PHP (CVE-2026-109618 and CVE-2026-109619). Both carry a 9.2 CVSS score because flaws in how PHP’s longjmp() error handling cleans up memory after an out-of-memory or fatal error leave pointers behind that a subsequent web request can hijack. Clinton’s message to security leaders this week was blunt: go to your boards, lock down the basics, and “hold on for ~18 months” until cheap verification models can catch every bug before code ships.

The nuance

I’m always skeptical when an AI vendor promises that their next model wave will magically solve the mess their current model wave just accelerated.

Even the CSA report has some messy edges when you look closely at the numbers. For example, Mozilla used Anthropic’s Mythos model to uncover 271 vulnerabilities in Firefox, though only 3 of them actually warranted CVEs. Lab benchmarks and real-world exploitability aren’t the same thing, and no board in suburban corporate America is going to re-architect twenty years of legacy middleware before Q4 closes.

Still, you don’t need every AI finding to be a 9.2 CVE for the math to break against defenders.

Models have gotten good enough to be persistent, if not always talented, red agents. They don’t get bored, they don’t sleep, and they can slam code and applications with attack paths that humans simply don’t have the bandwidth to think up. I don’t know if it’s the exact same scenario as a roomful of monkeys eventually typing up Hamlet (what mathematician Émile Borel originally framed in 1913 as the Infinite Monkey Theorem), but it’s certainly going down the same road.

Historically, it took legitimate creativity to dodge and parry your way into code in a new and dangerous way.
Now it takes some decent prompting and a lot of tokens.

The list of people who are willing to pay for those tokens, or manipulate their way into them, is only going to increase. They are going to turn Jason Clinton into a prophet.

12 hours, 400 issues

How do we get through this thunderdome era of IT?

You have two choices. You can stick your head in the sand, or you can figure out how to make better software faster.

I’ve used my BrandCast project to learn a lot about how to develop applications that do real work with agents. I like to think I’m pretty good at it. My scans look good. My tests pass. I’ve got skills, plugins, hooks, and all the things people like me say you need to have a modern agentic SDLC.

In my Leaf project, which is my interpretation of a Level 5 “Dark Factory” from Dan Shapiro’s Five Levels of AI coding framework, I run an autonomous Improvement loop.

When I first built that loop, it mostly deleted unreachable code. Two weeks ago, I wrote that I wanted it to go after a much harder target: working code that had gotten too tangled. So I updated the Improvement loop to hunt for both dead code and overly complex code using McCabe’s Cyclomatic Complexity, the graph-theoretic metric Thomas McCabe introduced in his 1976 IEEE paper, “A Complexity Measure”.

McCabe’s formula counts the number of linearly independent execution paths through a block of code:

M = E - N + 2P

Why does a 50-year-old complexity metric matter in an AI vulnerability storm? Because every extra branching path in a function multiplies the edge cases where state cleanup, error handling, or auth checks can quietly fail. Those PHP longjmp() bugs didn’t happen on the happy path; they happened in the weird corners of error recovery.

I turned the updated Improvement loop on against BrandCast for 12 hours.

Over 400 issues filed.

Were any of them massive security issues? I don’t think so. Most of them were tangled control flow, deeply nested conditionals, and dead branches that had quietly piled up across hundreds of feature merges.

But I’m good at agentic dev. Or at least I thought I was.

If an autonomous loop can find 400 legitimate structural problems in my own “clean” codebase overnight, imagine what a hostile loop is going to find in legacy enterprise code that nobody has touched since 2019.

So what?

These dark days are inevitable. Nobody is going to pause offensive token spend while your change-advisory board meets next Thursday.

You get through it by getting better at the agentic SDLC and getting out of its way:

  • Turn the monkeys loose on your own code first. Don’t wait for someone else’s red agent to fuzz your error-handling paths. Run continuous, unattended cleanup loops on your own repositories to hunt down dead code and tangled logic while you sleep.
  • Give your loops an objective math check. Agents love to add code and hate to delete it. Tie your refactoring loops to deterministic metrics like McCabe Cyclomatic Complexity and test suite pass rates so a machine can verify that the code actually got simpler.
  • Size your plumbing for machine speed. When finding a bug takes ten minutes of tokens, taking three weeks to test and ship a patch won’t cut it. As I learned the hard way when I blew through 50,000 CI build minutes this month, your build and verification harness has to be engineered for autonomous throughput.

And probably stock up on some of those emergency meal buckets from late-night TV.