Vaccari's Code

Systemic software collapse

11/17/2026

It hasn't been working very well lately, has it? In recent months, we've been bombarded by a series of software failures that have shaken everything from tech giants to critical infrastructure. We saw Microsoft with a two-day global outage, followed by a shutdown of all flights in the US due to an FAA (Federal Aviation Administration) failure. Not to mention the PHP2Shell vulnerability, which took 70% of the world's websites offline, or the eMudhra fiasco, where thousands of SSL certificates – the backbone of HTTPS security on the internet – were compromised by a private key so weak it was comical.

It seems 2026 has been a year of hacks, outages, vulnerabilities, and IT panic. What exactly is going on?

Software Is Failing at a Systemic Level

The first temptation is to blame Artificial Intelligence (AI), and you wouldn't be entirely wrong. AI models are a part of it. Even if companies like Microsoft don't disclose whether faulty systems were built with AI, we know that hackers and researchers can use the technology to find complex exploits – security flaws that can be exploited – in a matter of hours. AI is powerful, but also corrosive if used recklessly.

However, AI is both a cause and a symptom. What we are seeing is software failing at a systemic level. The problem is insidious because it's not just the software itself that's broken, but the entire way we've come to build it.

What does it mean for a failure to be systemic? Observe recent crises in software reliability, and you'll notice that they don't share immediate causes – that we know of – but they look strangely similar to each other.

Microsoft's outage, for example, likely stemmed from a network configuration failure that prevented the company's data centers from communicating. What happened next remains confidential, but it seems to have triggered a "cascading failure" – where an initial failure sets off a series of other failures – preventing any service from being restored to a valid state long enough to handle traffic. Former Microsoft engineers have already criticized Azure for being rushed to market under intense competitive pressure, resulting in shortcuts and the abandonment of fundamental reliability principles. Instead of addressing the growing "technical debt" – the future cost of rework caused by shortcuts today – the company has relied on quick fixes, automation, and manual repairs. The result is a highly complex system, made of low-quality parts, where no one can get a complete picture of the landscape.

The Web of Dependencies and Vulnerabilities

Another example is the PHP2Shell event. In October, security researchers at Wiz disclosed an exploit that could execute arbitrary code on any PHP website. They touted the power of AI tools to achieve exploits far beyond the abilities of human attackers. It turns out that the "PHP runtime" – the PHP execution environment – had hidden several complex memory management bugs for over a decade. PHP is widely used in e-commerce and, most notably, in WordPress, which was once the go-to choice for building simple and cheap websites.

The PHP2Shell case illustrates an internet reliant on a long chain of dependencies, hiding vulnerabilities too complex for any human to identify.

We cannot forget the Shai Hulud attack in May 2026. An attacker compromised important packages in the JavaScript (NPM) ecosystem. These packages used "GitHub Actions" to perform "Continuous Integration (CI)" – automated testing and releases – and had a crucial misconfiguration: anyone who "forked" (created an independent copy of) their projects could inject compromised code back into the original ("upstream") project. When the next CI build ran, it retrieved libraries from a cache. The JavaScript package manager, NPM, allows these libraries to include scripts – automation programs that are executed. Although intended for maintenance tasks, here they were used to hijack the projects' "secret tokens" – security keys for access. The JavaScript ecosystem has been criticized for its precarious security. NPM projects are complicated chains of dependencies that call dependencies that call dependencies. Any dependency can contain scripts. Any dependency author was one step away from having their code compromised – just copy and paste the wrong code. In other words: a highly complex system made of low-quality parts, where a single error can compromise everything.

How We Lost Control

It wasn't always like this. Just 12 years ago, technology was a different industry. Building software was difficult. Computer programs comprise millions of small instructions, and turning them into a functional system is like building a watch by hand, with hundreds of interacting components. The difference is that, unlike a watch, each computer program must do something completely new and different. It was fun, an art as much as a science. You had to be able to hold everything in your head at once: visualize how all the small parts could be orchestrated into a cohesive whole.

But it was less fun if you were a manager. Not many people can write good computer programs, and it's very difficult to scale human beings. Getting them to communicate without misunderstandings is hard. Many projects failed. There are programmers who know how to manage complexity, but they want to be well paid.

Different movements tried to solve the core problem. Some thought software development practices could help, such as transforming programming into highly structured models of "best practices" or using management styles like SCRUM. But that only helped to a certain extent.

Why This Matters

The lesson here is clear: the fragility of modern software is not an isolated problem of a bug or a company. It is a systemic problem, rooted in how we build and manage complexity. For us, builders and decision-makers in technology, this means we need to go beyond superficial fixes. We need to question the architecture of our systems, the quality of our dependencies, and the culture of "shortcuts" that the pressure for speed can impose. Understanding this systemic fragility is the first step towards building more resilient and reliable systems in the future.


Sources


📬 Enjoyed this? Subscribe to the Vaccari's Code newsletter for the next wave of software & AI trends, straight to your inbox: Subscribe here

← all posts · listen to the episode →