RSR ARTICLES & COMMENTARY

Could AI Be Behind the Recent Tech Outages? A Software Engineer's Perspective

By Fred Williams · November 20, 2026
← All Articles
Illustration of data-center networks and aviation infrastructure experiencing technology disruptions.

I found this article by JD Rucker to be very interesting. There was also a somewhat related Breitbart story on November 19 suggesting that software upgrades, potentially accelerated by AI-driven vulnerability discovery, may be contributing to recent technology outages.

Rucker lists three ways AI could be responsible:

1. Human nefariousness: Criminals or foreign or domestic agents using AI maliciously.

2. AI autonomously modifying code: AI agents introducing changes into online software repositories.

3. AI systems generating code designed to satisfy tests: Software that passes tests without necessarily functioning correctly under all operating conditions.

My take up front is that I believe it's unlikely any of these caused the recent Microsoft and FAA outages. That doesn't mean Rucker's ideas are without merit in other applications, though. More on that later.

I've spent much of my career developing software and firmware, including embedded systems, networking equipment, and applications that interact with specialized hardware. So I find these questions particularly interesting from an engineering standpoint.

The November 2026 Outages

Microsoft Crash - November 12–13, 2026

They have already identified the bug, the edge case they describe from an engineering standpoint is highly believable:

1. A software bug introduced in July 2026. A change to Microsoft's networking gateway software contained a latent concurrency problem involving lock contention. The bug remained undetected for more than three months.

2. An increase in server traffic. Approximately 15 hours before the outage, Microsoft Teams traffic was transferred to the networking gateway also supporting Exchange Online. The additional load made the previously dormant bug more likely to surface.

3. Reduced server capacity. Approximately 14% of the gateway's server capacity was already unavailable because of a separate issue. When the bug began causing servers to stop responding, traffic shifted to other servers, overwhelming them and triggering a cascading failure.

The question is whether the July bug was introduced by AI. But even if the defective code was AI-generated, that doesn't necessarily mean it fits any of Rucker's criteria. Rucker implies his third scenario is the most plausible, but I think it overlooks a fundamental aspect of software engineering: independent testing. AI might generate defective code, and AI-generated unit tests might fail to identify those defects, but that's hardly the end of the testing process. Major software systems undergo integration, black-box, load, and stress testing designed to exercise the software under realistic operating conditions.

Microsoft acknowledges that its testing failed to catch the July defect, specifically because its load-testing environment did not adequately reproduce production conditions. That's a familiar software engineering problem, and one that predates AI by decades.

FAA Crash – November 13, 2026

The FAA outage, in the grand scheme of things, wasn't all that different from Microsoft's issue. It came down to the installation of new Juniper routers that didn't play well with the FAA’s outdated system. They reportedly tested the router for a year before deploying it, but all that testing failed to uncover an elusive edge case that ultimately pushed the system over the cliff (it was reportedly the 69th router installation). The FAA had not yet established the precise root cause at the time of the initial reporting, so the problem might have involved configuration, firmware, or some other interaction with the existing network. I see no compelling evidence connecting any of Rucker’s AI scenarios to this outage.

The Common Thread: Software Upgrades and Maintenance

One thing that stands out to me about these outages is how many involve software upgrades, patches, or changes to existing systems.

A November 19 Breitbart article, citing the Wall Street Journal, points out that several recent outages appear to have resulted from upgrades gone wrong rather than cyberattacks.

This makes perfect sense from an engineering standpoint. When developing a new product, companies generally put considerable effort into testing before release. But once a product is in the field, maintenance updates introduce a different set of challenges. You're modifying an existing system that may have years of accumulated complexity, and a seemingly minor change can have unintended consequences.

Microsoft's July software change is a good example. The defect remained dormant for months until a particular combination of circumstances exposed it. The FAA experienced something similar when introducing new networking equipment into its aging infrastructure.

I retired just as AI coding tools such as Claude were beginning to gain traction at Micron. Based on my experience, and subject to confirming current practices with Ryan, I would expect Micron's rigorous code-review and testing procedures to provide considerable protection against the scenarios Rucker describes.

However, I do have some concerns about maintenance updates. In my experience, the processes surrounding a major product release are generally more extensive than those applied to routine maintenance changes. That's understandable, but it also creates opportunities for defects to slip through, especially when seemingly minor changes interact with older code in unexpected ways.

The Breitbart article raises another interesting possibility. AI is becoming increasingly effective at discovering software vulnerabilities, potentially forcing companies to develop and deploy security patches at a much faster pace.

Ironically, the effort to protect systems against AI-assisted attacks could itself increase the risk of outages if software changes are rushed into production without adequate testing.

I find this explanation more plausible than attributing these particular outages to autonomous AI agents or deliberately concealed AI-generated defects. But we don't yet have evidence that AI-driven patching caused either the Microsoft or FAA failures.

The Fallout: Public Anxiety and Political Consequences

Another interesting aspect of these outages is the public reaction.

According to a November 19 Fox Business report, Costco and Walmart experienced increased demand for emergency supplies, including generators, bottled water, and other survival essentials. One analyst reported that 21 of 26 high-ticket generators tracked on Costco's website were sold out. No word yet on whether we've seen a COVID-style run on toilet paper. :)

Apparently, a series of technology failures occurring close together is enough to convince some people that something much more sinister might be happening.

There's even been political fallout. On November 19, Fox News reported that National Cyber Director Sean Cairncross had been removed from his position amid attention to the nation's cybersecurity readiness. The timing attracted attention, although the reporting does not establish that these particular outages caused his departure.

I find this fascinating. We have several major technology failures occurring within days of each other, and people naturally start looking for a common explanation. Was it a coordinated cyberattack? Was AI somehow involved? Or were these simply independent engineering failures that happened to occur around the same time?

From what we know so far, the available evidence favors independent technical failures over a common AI-driven cause. But these incidents demonstrate just how dependent our society has become on complex software systems, and how quickly confidence can erode when those systems fail.

Rucker’s Criteria in Other Software and Hardware Applications

Now let's consider how Rucker's criteria might apply to other software-based systems. There are several broad categories: embedded firmware (software that controls hardware devices such as routers and SSDs), web-based applications (such as my football website OfficePoolStop, E*TRADE, GitHub, etc., which rely heavily on databases and back-end processing), and specialized software applications that interact with dedicated hardware, such as Trimble's GPS navigation and positioning systems,

Human Nefariousness – Criminals, Foreign Agents, Domestic Agents

This is certainly a legitimate concern. AI is making it easier for malicious actors to develop sophisticated software, identify weaknesses, and potentially compromise computer systems.

However, the risks vary considerably depending on the type of system. Embedded components such as Micron NAND flash devices, SSD controllers, and network routers and switches often have specialized firmware and hardware interfaces. Some low-level functions require physical access or dedicated debugging connections, such as serial ports, rather than being directly accessible over a network. That doesn't make these devices immune to attack, but it does present different challenges from compromising an ordinary web application.

Network-connected cameras present another interesting example. The television series Person of Interest took the idea of accessing surveillance cameras to entertaining extremes. But with so many modern cameras connected to cloud services, the underlying privacy concern isn't entirely science fiction. Unauthorized access to a cloud account or service could potentially expose camera footage. And with many cameras manufactured in China, there are legitimate questions about supply-chain security, data handling, and the degree of trust we should place in manufacturers and their software. Of course, where a product is manufactured is not, by itself, evidence of malicious behavior.

But there's another concern that has bothered me for decades: malicious code introduced by someone who already has legitimate access to the software.

When I worked at McDATA, I created a fake virus I called Fredicus. It was hidden in the bootstrap code and activated only when I entered a particular administrator phrase. Once triggered, it displayed a message asking the unfortunate victim to identify the airspeed velocity of a European swallow. They had 30 seconds to answer correctly, or I would supposedly format the hard drive!

A countdown began, and when it reached zero, I activated the hard-drive activity light to make it appear that the system was formatting the disk. After about ten seconds of manufactured terror, a banner appeared announcing that they'd been had by the Fredicus Virus. :)

It was harmless fun, but it illustrated something that has concerned me throughout my software engineering career: a programmer with sufficient access can introduce behavior that other programmers may never notice.

This is especially troubling in low-level code, including boot firmware, device drivers, and other software components that relatively few developers ever examine. And it isn't necessarily a matter of writing something blatantly suspicious. A seemingly ordinary change can conceal unintended or deliberately malicious behavior.

Rucker mentions a fascinating historical example involving Ken Thompson, one of the original creators of Unix. In his famous 1984 lecture, Reflections on Trusting Trust, Thompson demonstrated how a compromised compiler could reproduce malicious behavior in the programs it compiled, even when the source code being compiled appeared perfectly innocent. Worse, the compiler could perpetuate the deception when compiling a new version of itself.

Now introduce AI into the picture. AI-assisted programming could make it easier for a malicious insider to create complex or obscure code that is difficult for reviewers to understand. But AI could also improve detection by helping engineers analyze unfamiliar code, compare compiled output with source code, and identify suspicious changes.

So I consider Rucker's first scenario a legitimate concern, particularly when it comes to insider threats and software supply chains. However, there's an important distinction between recognizing that AI could make such attacks easier and concluding that AI actually caused a particular outage. The latter requires evidence.

AI Autonomously Modifying Code in Online Repositories

At first, I was a little skeptical of this scenario, but then I realized how something like this could potentially happen and go undetected.

Suppose a maliciously designed AI somehow gained access to a company's private software repository hosted on GitHub or Bitbucket. It could potentially introduce unauthorized changes to the source code that might go unnoticed if developers weren't carefully reviewing incoming changes.

Consider a major financial website such as E*TRADE. If malicious code made its way into production, it could conceivably compromise customer accounts, expose sensitive financial information, or interfere with financial transactions. The potential consequences could be enormous.

In an episode of the TV series Person of Interest, the sinister AI known as Samaritan launches a cyberattack against the New York Stock Exchange, manipulating the markets and threatening a financial catastrophe. The fictional scenario illustrates just how devastating a malicious AI could potentially become if it gained control of critical financial systems.

While Samaritan's exploits are fictional, the underlying threat of malicious code entering trusted software systems is very real. In March 2026, Microsoft reported on a significant software supply-chain attack involving Trivy, a widely used open-source security scanning tool. Attackers obtained access through compromised credentials and modified trusted software components hosted on GitHub. They redirected 76 of 77 version tags associated with Trivy's GitHub Action to malicious code designed to steal sensitive credentials. Organizations that trusted those components could unknowingly execute the malicious software as part of their normal development and deployment processes.

Microsoft published a detailed analysis of the incident, which illustrates how dangerous a compromised software supply chain can become. Importantly, this was not a confirmed autonomous AI attack, but it demonstrates that the underlying mechanism Rucker is concerned about is very real.

Here's another example, this time from my own experience. At OfficePoolStop, we use GitHub Actions to automate deployment of our website. Once we approve and merge a pull request, GitHub automatically starts a workflow that builds and updates the production website.

This is extremely convenient, but it introduces another potential vulnerability. If someone—or some malicious AI agent—managed to compromise the deployment workflow, it could potentially introduce unauthorized instructions into the build or deployment process without ever modifying the application source code itself.

Imagine approving a completely legitimate pull request, only to have a compromised deployment script execute malicious instructions behind the scenes. Unless someone reviewed the workflow, examined the deployment logs, or noticed unusual behavior, the compromise might go undetected.

This is another reason I take Rucker's second scenario seriously. It's not just about malicious code being inserted into a repository. The automated systems responsible for building and deploying that code are themselves potential targets. The Trivy incident demonstrates why even trusted components of development pipelines deserve scrutiny.

However, there's an important consideration here: modifying code in a repository doesn't mean that code automatically makes it into the released product. In many development environments, several additional steps must occur. Engineers typically pull the latest code, at which point an unexpected new file or significant changes to an existing file might raise suspicions. The modified code may also have to pass code reviews and the usual battery of tests, including unit, integration, black-box, regression, and load testing. Finally, the software must be built and deployed before the changes can affect production systems.

Each of these steps presents another opportunity to detect something suspicious. Of course, automated pipelines can sometimes bypass human scrutiny, and ordinary functional testing won't necessarily detect a deliberately concealed backdoor. But in a well-managed development environment, there are multiple layers of protection between a source-code repository and the running product.

My concern is that AI could make these attacks more sophisticated, allowing malicious code to blend in with legitimate changes and potentially escape detection. And as companies increasingly rely on AI-assisted development, engineers may become less diligent about reviewing changes they assume are trustworthy.

One other distinction is worth making. If a criminal deliberately deploys an AI agent to compromise a repository, that overlaps with Rucker's first scenario. His second scenario becomes more interesting when an AI agent with legitimate access introduces unauthorized or harmful changes without anyone explicitly directing it to do so.

Of Rucker's three scenarios, this is one I consider a legitimate concern. The Trivy incident demonstrates that unauthorized modifications to trusted software components are already happening. Whether autonomous AI will make such attacks significantly more common or difficult to detect remains to be seen, but the potential is certainly there.

AI Systems Generating Code Designed to Satisfy Tests

Of Rucker's three scenarios, this is the one I find least convincing, even though he describes it as the hardest to dismiss.

Rucker's concern is that AI-generated software might be designed to pass tests rather than necessarily function correctly under all conditions. Furthermore, if AI is also generating the tests, the same blind spots might exist in both the software and the testing process.

There is some merit to this concern, particularly when it comes to unit testing, where tests are often written with direct knowledge of the source code. But I think Rucker overlooks one of the most important aspects of software engineering: independent black-box testing.

I'll give an example from my own experience. When I worked at McDATA, I led the development of a product called Sysplex Timer, from the low-level boot firmware all the way up to the Windows application. We had an excellent test engineering team, particularly their lead designer, who developed software specifically designed to hammer the device, exercising its functionality and pushing it under demanding conditions. I called it “Bob’s Test from Hell.” :)

The important point is that this tester had essentially no visibility into our firmware or application source code. He tested the product through its external interfaces, evaluating its behavior rather than its internal implementation. This is the essence of black-box testing.

Now suppose AI had written all the Sysplex Timer firmware and application software, and another AI system had written the test engineer's software. How would the AI-generated product code know which tests were going to be run? How could it deliberately satisfy tests it had never seen, especially when those tests were independently developed to push the hardware to its limits?

One could speculate that the same AI system might have been used by both the developers and the tester, and perhaps even retained knowledge of the code it originally generated. In that case, it might inadvertently carry the same assumptions and blind spots into the testing software. But that assumes some shared knowledge between the development and testing environments, something that is by no means automatic. Even two independent AI systems could make similar mistakes, particularly when working from incomplete or ambiguous specifications. And no amount of testing can guarantee that every possible edge case will be discovered. Microsoft's recent outage is a good example of that.

But this is precisely why professional software development involves multiple levels and approaches to testing. Unit testing exercises individual software components, often using white-box techniques that examine the internal logic and code paths. Black-box testing takes a fundamentally different approach, evaluating the system through its external interfaces without knowledge of its internal implementation. Add integration testing, regression testing, load testing, and stress testing, and you have multiple opportunities to catch defects that earlier testing might have missed.

I also know that companies increasingly use AI to help develop automated testing tools. I see considerable promise in this. AI could help engineers generate more test cases, identify unusual boundary conditions, and exercise software in ways that might otherwise be overlooked. In fact, if there's one area of software engineering where I expect AI to significantly reduce the need for human labor, it's automated software testing.

So while I agree that AI-generated code and AI-generated unit tests could share blind spots, I don't see how that translates into a compelling explanation for the kinds of outages Rucker is discussing, particularly in environments with rigorous independent system-level testing.

Software defects have been escaping testing for as long as software has existed. The existence of a dormant bug that eventually surfaces under unusual operating conditions is hardly evidence that AI was involved.

Of Rucker's three scenarios, this is the one I find least convincing, not only as an explanation for the recent outages, but also as a broader concern across other software and hardware platforms, particularly those employing rigorous, independent testing.

A Fourth AI-Related Concern: Too Much Software, Too Fast

In the end, I think there's a fourth AI-related concern that Rucker hasn't really addressed, and one that might prove more consequential than any of his three scenarios.

What happens when AI accelerates the development and modification of software faster than our engineering and testing processes can reliably keep up?

Consider what's happening with AI-assisted programming. Developers can now generate substantial amounts of code in a fraction of the time it would previously have taken. AI is also becoming increasingly effective at discovering security vulnerabilities, potentially creating pressure for companies to release patches and upgrades more rapidly.

But generating code is only one part of software engineering.

The code still needs to be reviewed, integrated, tested, deployed, and maintained. And just because AI can produce code faster doesn't mean the surrounding engineering processes can safely accelerate at the same rate.

This is especially concerning for maintenance updates, where developers are modifying complex existing systems that may contain years of accumulated dependencies and assumptions.

A change that appears perfectly reasonable in isolation can interact with another part of the system in ways nobody anticipated.

That's essentially what happened with Microsoft's July networking gateway change. The code worked for months before the right combination of increased traffic, reduced capacity, and hardware characteristics exposed the defect.

The FAA outage illustrates a similar problem from a hardware integration standpoint. A new router was introduced into an aging infrastructure, and an unexpected interaction disrupted a critical national system despite extensive prior testing.

Neither incident has been established as AI-caused. But both demonstrate how unforgiving complex systems can be when a defect or compatibility problem escapes testing.

And this brings me back to the Breitbart article. The possibility that AI-assisted vulnerability discovery will drive increasingly frequent software upgrades is a concern worth taking seriously.

Perhaps the greatest AI-related risk isn't that AI will deliberately write code designed to fool its own tests, or that autonomous AI agents will secretly plant malicious instructions in software repositories.

Perhaps it's something much more ordinary: we'll increasingly rely on AI to develop and modify complex systems without giving independent engineering review and testing the time and attention they deserve.

I suspect that danger could prove far more widespread than any of Rucker's three scenarios.

And unlike a mysterious AI sleeper agent, it's a risk that engineers and software companies can do something about today.