AI, shared dependencies, and the growing risks of a software world nobody fully controls.
Chain Reaction### When One Router Disrupts a Nation
On November 13, 2026, the United States experienced a nationwide aviation ground stop.
According to the Federal Aviation Administration (FAA), a network problem caused approximately 1,000 connection attempts every four to five seconds. Legacy telecommunications equipment became unstable, affecting communications and radar feeds at 17 of the country’s 22 air traffic control centers.
Aircraft already in the air continued to land safely. The ground stop was a precaution, not evidence that the entire air traffic control system had collapsed.
Nevertheless, the consequences were enormous.
The FAA identified excessive network traffic associated with two locations, one of which had recently undergone router installation work. Investigators were still determining the precise root cause when the FAA published its initial findings.
But the most interesting question is not what went wrong with the router.
Why could a localized network disturbance have such widespread consequences?
A router can fail. Software can crash. Networks can become overloaded. None of these events should surprise an experienced engineer.
The challenge is designing systems in which an individual failure cannot propagate uncontrollably.
That is a question of architecture, not merely programming.
We Are Building Systems Nobody Fully Understands
I started programming as a child, long before modern frameworks, package managers, and cloud services existed.
Back then, you often had to understand much more about the machine itself. Memory management, hardware interrupts, file systems, networking, and the operating system were not simply hidden behind convenient interfaces.
Of course, software was much simpler in many respects, and programmers made plenty of mistakes.
I certainly did.
But one lesson stayed with me throughout my programming career: writing the program was only part of the job.
Understanding what it could do under unexpected conditions was equally important.
Today, a developer can assemble a sophisticated application from frameworks, libraries, cloud APIs, and third-party services.
That is an extraordinary achievement.
But it also creates an uncomfortable situation.
You can build a system without understanding most of the code that makes it work.
A single imported package may depend on dozens of others. Those dependencies have their own dependencies, version requirements, security problems, and update cycles.
Eventually, nobody involved in building the application may have a complete understanding of its behavior.
And the problem is no longer limited to the application itself.
The Multiplier Effect
Suppose I make a serious programming mistake in one of my WordPress plugins.
A few thousand websites might be affected.
That would be bad enough, and I would certainly be responsible for fixing it.
But imagine a comparable vulnerability in OpenSSH, OpenSSL, PHP, or the Java runtime.
Suddenly, the potential exposure is not a few thousand installations.
It could involve an enormous number of servers, applications, and connected systems around the world.
This is the multiplier effect of shared software.
For decades, we have encouraged software reuse, and for good reasons. It avoids unnecessary duplication, allows developers to build on established work, and can improve reliability through widespread testing and maintenance.
But there is another side.
We have made software reusable. We have also made its vulnerabilities reusable.
One error in a widely deployed component can create potential vulnerabilities in countless otherwise unrelated products.
The actual exposure always depends on the version, configuration, and accessibility of the vulnerable code. Not every installation is automatically exploitable.
But the concentration of risk is undeniable.
The Bugs Were Already There
Recent security disclosures demonstrate how deeply such vulnerabilities can be hidden.
In October 2026, researchers disclosed PHP2Shell, involving two critical vulnerabilities in the PHP runtime itself.
One involved a use-after-free condition, a class of memory safety error in which a program continues using memory after it has been released.
Then, on November 17, researchers disclosed Java4Shell, a heap buffer overflow in the hardware-accelerated Base64 decoder of the OpenJDK HotSpot virtual machine.
This was not an error in an ordinary Java application.
It was a memory corruption vulnerability in the runtime executing that application.
Exploitation requires specific conditions, including affected runtime versions, suitable processor capabilities, and attacker-controlled input reaching the decoder.
But consider the implications.
A developer could carefully review the entire application, validate every input, write extensive unit tests, and still depend on a vulnerable runtime component.
Similar problems can arise in operating systems, network stacks, cryptographic libraries, and database engines.
These are not entirely new classes of programming errors.
Buffer overflows, use-after-free conditions, and incorrect memory handling have been known for decades.
The surprising part is that we continue discovering them in software upon which much of our digital infrastructure depends.
And now something has changed.
AI Is Accelerating Both Sides
Artificial intelligence is making software development faster.
But it is also making vulnerability research faster.
AI-assisted analysis can examine large codebases, identify suspicious patterns, explore complex execution paths, and work alongside fuzzers, debuggers, and other security tools.
In October 2026, Anthropic published research describing how Claude had helped discover serious vulnerabilities in real-world software, including operating system components.
This is an important development.
Historically, identifying certain complex vulnerabilities required specialized knowledge and substantial manual effort.
AI does not eliminate the need for that expertise, but it can multiply what skilled researchers can investigate.
That is good news for defenders.
Previously overlooked vulnerabilities can potentially be discovered and repaired before attackers exploit them.
Unfortunately, attackers can benefit from similar capabilities.
And the resulting pressure on software maintainers is substantial.
A newly discovered critical vulnerability may affect an enormous number of deployments. Administrators need patches quickly, while developers must ensure that the fixes do not introduce new problems.
AI can accelerate the discovery of a bug. It cannot automatically guarantee the safety of the fix.
This creates a difficult tension between security and reliability.
Delay a patch, and systems may remain exposed.
Release it prematurely, and the update itself may disrupt production systems.
Faster development does not eliminate the need for thorough engineering. It makes that engineering more important.
Testing Is More Than Running Unit Tests
I have always spent considerable time testing my software.
Not because I believed I could write programs without mistakes.
Nobody can.
I tested because I wanted to understand how the software behaved in its actual operating environment.
A unit test may confirm that a function returns the expected result.
But what happens when the disk is full?
When a network connection disappears halfway through a transaction?
When a database returns an unexpected error?
When two processes access the same resource simultaneously?
Or when a supposedly redundant component fails at precisely the wrong moment?
These questions cannot all be answered by isolated tests.
Systems need integration testing, realistic operational testing, fault injection, and repeated verification after changes.
Even that cannot guarantee the absence of failures.
Which brings us to a principle I consider more important than any particular testing methodology:
A system should be designed to limit the consequences of its own failures.
What a Refrigerator Can Teach Software Engineers
Consider a connected refrigerator.
Its software may control temperature, monitor energy consumption, communicate with a mobile application, or install updates over the internet.
But imagine that some function could cause a heating element to reach a dangerous temperature.
Would it be sufficient to write software that normally prevents this?
Of course not.
The appliance needs an independent safety limit that cannot be bypassed by an ordinary application error or remote command.
That protection might involve dedicated firmware and, where necessary, independent hardware capable of disconnecting the hazardous component.
The exact engineering solution depends on the appliance, but the principle is simple.
Safety must not depend entirely on the correct behavior of the software it is supposed to protect against.
This principle is familiar in traditional engineering.
Yet in software systems, we sometimes seem content to rely on another software component, another monitoring service, or another automated recovery mechanism.
Those mechanisms are valuable, but they may share the same underlying dependencies and failure modes.
Redundancy is useful only when the redundant components do not all fail for the same reason.
The FAA incident is a reminder of why this distinction matters.
Sometimes Less Really Is More
I develop WordPress plugins, and I deliberately avoid Composer in my own projects.
Not because Composer is inherently unsafe.
It is a useful dependency manager, and properly maintained dependencies can be more secure than poorly implemented custom code.
My choice is about keeping my projects manageable.
Every additional dependency introduces code that I must trust, monitor, and potentially update.
When a straightforward function can be implemented clearly with a small amount of code, I prefer to understand and maintain that code myself.
That does not mean reinventing cryptography, complex security protocols, or other specialized components that benefit from established implementations and expert review.
The goal is not to eliminate every dependency.
It is to make every dependency a deliberate engineering decision.
A dependency should reduce the overall complexity and risk of a system, not merely reduce the amount of code its developer has to type.
The Responsibility Has Not Changed
AI-assisted coding will continue improving. More sophisticated tools will discover more vulnerabilities, generate more patches, and automate increasingly complex development tasks.
There is no reason to reject these advances.
But faster tools do not change the fundamental responsibility of software engineering.
Someone still has to understand the architecture.
Someone has to examine the dependencies.
Someone has to test the system under realistic conditions.
And someone has to ask what happens when an important component stops working.
We cannot expect any individual to understand every line of code in today’s largest systems.
But we can design systems with clear boundaries, limited dependencies, independent safeguards, and failures that remain contained.
The objective should not be software that never fails.
It should be software whose failures do not create unnecessarily widespread consequences.
Because the multiplier effect has changed the stakes.
A programming error is no longer necessarily confined to one application, one company, or even one country.
We used to worry about whether software would work.
Today, we should worry about what happens when it doesn’t.
Because the problem is no longer just a bug in a program.
It is how many other systems that bug can bring down.
Sources and further reading
- Federal Aviation Administration — Nationwide Ground Stop: Questions and Answers, November 15, 2026.
- Calif Research — PHP2Shell: A Tale of Two PHP Remote Vulnerabilities, October 2026.
- Scala Programming Language — Security Advisory: Java4Shell, CVE-2026–114938, November 18, 2026.
- Anthropic — Discovering and Exploiting Vulnerabilities in Critical, Real-World Software with Claude, October 2026.
- Cloudflare — Protections Against PHP2Shell Vulnerabilities, October 2026.
Top comments (0)