The internet had a rough Tuesday. Wikipedia went down. 4chan went offline. DeviantArt stopped loading. Dutch and Finnish government sites pulled themselves down as a precaution. Even that blog where the corner bar posts pictures of people’s dogs went dark.

The culprit? Two critical remote code execution vulnerabilities in PHP, the programming language that powers something like 75% of the web’s backend infrastructure. Every site running WordPress, which is about 40% of all websites, was suddenly at risk. The NSA’s cybersecurity account on X told organizations to patch immediately. The PHP Foundation scrambled to push emergency updates across the entire 8.x line.

Here’s the weird part: these vulnerabilities were discovered by AI. OpenAI’s security scanning tools and Google’s Wiz platform found holes in code that’s been running the internet for years. Ancient bugs, just sitting there, waiting to be exploited.

This should be a win for AI in security, right? Automated tools finding critical flaws that human auditors missed. The kind of thing that makes the case for why we need AI augmenting our security teams.

Except the coordinated disclosure process leaked. By Tuesday afternoon UTC, the CVE IDs were circulating online. Exploits started appearing before most organizations even knew patches existed. The PHP Foundation’s post-mortem describes what went wrong: someone in the disclosure chain talked too early, and suddenly everyone with a packet sniffer and bad intentions had a roadmap to every vulnerable PHP server on the internet.

This is the exact nightmare scenario that makes AI-assisted security research so tricky. The same tools that can scan millions of lines of code to find critical bugs can also make those bugs accessible to anyone with an API key and questionable ethics. When AI lowers the barrier to finding vulnerabilities, it doesn’t just help the good guys find them faster. It compresses the entire window between discovery and exploitation.

The old model of coordinated disclosure assumed a certain friction in the system. Finding bugs was hard. Exploiting them required expertise. You could reasonably expect a 90-day disclosure window because most attackers wouldn’t independently discover the same flaw in that timeframe.

AI breaks all of those assumptions. When automated tools can scan entire language ecosystems and flag potential RCE vectors, the discovery process isn’t scarce anymore. It’s abundant. And that abundance doesn’t care whether you’re a security researcher trying to make the internet safer or someone looking to own as many servers as possible before the patches drop.

The PHP crisis shows both sides of this. Yes, AI found critical bugs that needed fixing. The PHP Foundation is now implementing AI-assisted scanning as part of their regular security process, which is probably the right move. But the same capability that found those bugs also meant that once the CVE numbers leaked, exploit code appeared almost immediately. There’s evidence that some of the circulating exploits were themselves AI-generated, adapted from the vulnerability descriptions faster than human exploit developers could have managed.

The disclosure dilemma

This puts us in a bind. We can’t exactly tell AI security tools to stop finding bugs. The PHP vulnerabilities were real, they were exploitable, and they needed fixing. But the traditional coordinated disclosure process assumes you can control information flow during the patch development window. When AI tools can replicate a discovery path from minimal information, that control evaporates.

The PHP Foundation is now talking about “strengthening” their security processes, which mostly means faster patch development and better operational security around the disclosure process. But operational security is only as strong as your least careful participant, and when you’re coordinating across multiple organizations and time zones, someone’s eventually going to slip.

The real problem is that AI has fundamentally changed the economics of vulnerability research. Finding bugs used to be the expensive part. Now it’s cheap. Patching is still slow because it requires human decisions, testing, and coordination. That gap between cheap discovery and slow patching is where all the damage happens.

We’re seeing the same pattern in other areas. AI coding assistants sometimes suggest insecure code patterns that human reviewers miss. Automated security scanners flag thousands of potential issues, creating alert fatigue that makes teams miss the critical ones. The tools are getting better at finding problems faster than organizations are getting better at fixing them.

What actually helps

So what do you do? The PHP Foundation’s approach is probably right: assume AI-assisted discovery is now the baseline, treat every bug as potentially already known to attackers, and compress your patch development and deployment timeline accordingly. The 90-day disclosure window is dead. You’re probably working with days, not months, from discovery to widespread exploitation attempts.

For everyone running PHP (or any other widely-deployed infrastructure), this means your patch deployment process needs to be fast. Like, same-day fast when critical RCE bugs drop. The organizations that went dark as a precaution on Tuesday made the right call. Better to take yourself offline for a few hours than to gamble that attackers won’t find you before you patch.

The broader lesson here is that AI isn’t making security simpler. It’s making it faster and more asymmetric. The tools help defenders, but they help attackers just as much, and attackers usually have the advantage of not needing committee approval before they move. When AI collapses the time between vulnerability discovery and exploitation, the only defense is to collapse your response time to match.

The PHP crisis is over for now. Patches are out, most major sites are back online, and the immediate fire is contained. But this won’t be the last time AI-discovered vulnerabilities leak before patches are ready. It probably won’t even be the last time this month. We’re going to keep seeing this pattern until either our patching processes get much faster or we accept that some percentage of critical infrastructure is just going to be briefly owned every time an AI security scanner gets lucky.

Neither option is great. But pretending AI makes security research a pure positive without considering the exploitation side is how you end up with Wikipedia going dark on a Tuesday because someone’s coordinated disclosure process sprung a leak.