AI has changed how quickly we can write, revise, and prepare software for release. Coding agents can draft code, update dependencies, and propose changes across repositories in minutes. Yet the systems receiving those changes are built from layers of services, legacy infrastructure, and dependencies that are difficult to see in full. That gap between the speed of change and the ability to understand its effects has become a central operational risk.
Four outages, one common thread
Four infrastructure outages in a single week show how a technical change can ripple through complex systems. On Thursday, November 12, a global Microsoft 365 outage took Outlook, Teams, Copilot, and other services offline for more than 24 hours, affecting organizations in more than 70 countries. Microsoft attributed the incident to an issue introduced during an earlier network capacity upgrade and explicitly ruled out a cyberattack or AI involvement.
The following day, the FAA halted departures nationwide for roughly four to five hours after communications problems affected 17 of 22 of its regional Air Route Traffic Control Centers. The FAA traced the problem to data flooding the network during work at a remote site, where a contractor was replacing copper lines with fiber and deploying a router.
Then on Monday, November 16, a software bug in JPMorgan Chase’s on-premise hardware systems disrupted online banking, in-person transactions, and Zelle payments for thousands of customers. The DOJ confirmed there was no evidence of any attack, and the FBI found no indication of malicious or external cyber activity. Customers at Bank of America, Wells Fargo, and U.S. Bank experienced delays primarily where they were parties to transactions involving Chase.
That same day, United Airlines resolved a widespread system outage that had briefly affected departing flights for about an hour, including the system pilots use to calculate aircraft weight for takeoff. United said there was no indication the outage was a cyberattack, and the FAA confirmed it was not an FAA equipment issue.
None of these incidents were cyberattacks. None were caused by AI. All four were infrastructure-change failures: a network capacity upgrade at Microsoft, a copper-to-fiber upgrade at the FAA, a software release at Chase, a web-based system outage at United. Each cascaded through complex, interdependent systems. The common thread: the accelerating pace of change flowing through systems that mix new and legacy components, and the verification gap that opens when change outpaces our ability to understand its impact.
But calling them “not cyberattacks” undersells what happened. These were system failures. The cause was different from a breach, but the downstream impact was indistinguishable: payments failed, flights grounded, communications went dark, and organizations lost hours or days they couldn’t recover. The distinction between a malicious attack and a non-malicious failure matters for attribution and response, but it doesn’t matter to the customer whose service is down. As AI accelerates the volume and velocity of changes flowing through those systems, these failures will become more frequent, and in some ways harder to prevent, because they originate in routine changes rather than deliberate attacks.
Why modernization makes every change riskier
New technology rarely replaces the old all at once. It arrives in layers: new services connected to existing applications, modern interfaces built over aging infrastructure, automated workflows spanning systems designed decades apart. Most businesses must modernize while continuing to operate. The difficult work is understanding what happens where those layers meet.
The FAA’s ground stop brought that challenge into view. A change in one part of a complex system can have consequences far beyond it. Enterprises face that problem whenever they modernize systems that support mission-critical applications. Few have the option of starting over.
The Microsoft outage illustrates the same pattern at cloud scale. An issue introduced during an earlier network capacity upgrade surfaced after a subsequent network change, causing front-end servers to fail automated health checks. As servers were removed and clients reconnected, each reconnection triggered the exact operation that was already overloaded, a self-sustaining cascade Microsoft described as a metastable failure. The trigger was removed, but the failure persisted, because the system’s own recovery mechanisms kept amplifying the load.
The Chase and United incidents reinforce the same lesson. A software release at Chase propagated delays across the financial system through Zelle’s interconnected payment network. A web-based outage at United grounded departures because the digital systems that support safe operations were temporarily inaccessible. In both cases, the change itself, not a cyberattack, was the source of the disruption.
AI Widens the Verification Gap
AI accelerates the work entering those environments. It does not automatically accelerate our understanding of them. GitHub reports that more than 40% of pull requests began with an agent’s first draft by September 2026, up from 17% in March. The resulting code still enters environments shaped by years of dependencies, architectural decisions, and operating constraints.
Attackers now leverage AI to build malware and automated campaigns, which increases the pressure on companies to deploy security patches from weeks to mere days. That increases the volume of changes flowing through their systems, and as all four incidents showed, it’s the change itself, not just its security intent, that can break a complex system.
As code becomes easier to produce, it’s become much harder to decide what’s ready to release. Teams must determine whether a change preserves expected behavior, introduces a security weakness, or affects a service elsewhere in the business. Functional tests answer some of these questions. Others require security analysis, knowledge of the environment, and engineering judgment. The capacity to verify changes must grow alongside the capacity to generate them.
Context is What Makes Verification Trustworthy
The same change can carry different risks depending on the system it enters, the data it touches, the privileges it inherits, and the services that depend on it. Assessing code in isolation cannot deliver that full picture. Verification must account for those relationships, including the constraints of legacy components and the potential impact on mission-critical applications.
How Veracode Closes the Gap
This is where Veracode’s platform comes in. The challenge is understanding what a change could do in the context of the system it’s entering, and that requires more than scanning code in isolation.
Hybrid SAST AI combines deterministic, compliance-ready static analysis with LLM-based contextual risk detection. Veracode SAST has over two decades of scan data across millions of applications, supporting 100+ languages and frameworks. That data advantage means fewer false positives, more accurate risk prioritization, and remediation guidance that reflects production reality. The AI layer catches business-logic flaws, like authorization issues and broken authentication, that traditional pattern-based scanners miss, while deterministic SAST provides the repeatable, auditable baseline that regulated environments require.
Veracode Fix turns detection into action. AI-powered remediation generates expert-curated fix suggestions directly in the developer’s IDE, CLI, or CI/CD pipeline, covering over 70% of detected flaws across 10 supported languages. Nothing runs unattended; nothing merges without human review.
Software Composition Analysis (SCA) extends the same discipline to the open-source dependencies that modern systems rely on. Vulnerability Method Analysis pinpoints where code actually interacts with risks in libraries, so teams fix what matters instead of chasing every flagged dependency. Auto-pull requests apply the best fix with breaking-change context, and dependency graphs show which transitive components sit on the execution path.
Dynamic Analysis (DAST) validates running applications and APIs through simulated attacks, catching runtime vulnerabilities that static analysis can’t see. Together with SAST and SCA, it gives teams a unified view of risk across code, dependencies, and deployed behavior, from code to cloud.
The point isn’t more scanning. It’s verification that understands the system and produces evidence that change is safe to ship.
Securing Agentic Development
Agentic development adds another layer. Agents become participants in established workflows, using development tools, accessing repositories, and proposing changes to existing applications. Securing their work requires understanding both what they produce and what they are authorized to do. Organizations need clear boundaries for their actions, security checks informed by the systems being changed, and an accountable owner for decisions to release. For more on how agentic development changes the security landscape, watch this discussion on securing agentic development.
The Standard: Verification that Keeps Pace with Change
All of this week’s outages were caused by infrastructure changes, not cyberattacks. As AI accelerates the pace of code changes flowing through those systems, the verification gap widens. Organizations need to govern what gets built, guide how it gets built, verify that it’s safe to deploy, and prove it.
That requires investment in the whole path from proposal to production: reliable tests, security review, dependency and architecture context, controlled deployment, monitoring, and recovery. It also requires measures that assess more than output volume. Teams should know whether changes are safe, whether they create rework or incidents, and whether the organization can recover quickly when assumptions prove wrong.
For Veracode, this is the central challenge of modernization: helping organizations introduce new technology securely into the systems they depend on today. Established development practices and agentic workflows will coexist, and security must connect them through a shared understanding of risk and the environment in which changes will operate. As AI expands the pace and scope of those changes, the standard should remain clear: verification that keeps pace with change, and accountability that keeps pace with autonomy.
AI can help developers and agents produce software at a pace that was difficult to sustain manually. The lasting gains will depend on whether the organizations using it can evaluate and govern those changes with equal discipline. Development speed matters; confidence in what’s being released matters just as much.
For a deeper look at how AI-generated code is performing in practice, read our Fall 2026 GenAI Code Security Update.