By Riley Tanaka · Published May 13, 2026 · Updated May 13, 2026
On the morning of April 15, 2026, Claude stopped working for a lot of people at the same time. Downdetector lit up. The chatbot threw errors. Claude Code stalled mid-task. The API spat 5xx responses. By the time the worst of it cleared, more than 30,000 user reports had piled into a single peak window, and the engineers on call at Anthropic had moved from “investigating” to “monitoring” in roughly 90 minutes [1][2]. Eight days later, on April 23, Anthropic published a written engineering post-mortem that named three specific changes, three specific dates, and one quiet line of self-criticism about how all of it slipped through code review [3].
The thing people called the April Claude outage was actually two events overlapping in public memory. There was the April 15 brownout, short, sharp, visible on the status page. And there was a longer six-week quality degradation that users had been complaining about since early March, where Claude Code felt forgetful, terse, oddly less capable. The post-mortem treats the second one as the real story. That is the anatomy worth working through.
Direct Answer
The April 2026 Claude incident bundles a brief April 15 service outage with a longer six-week Claude Code quality drift. Anthropic’s April 23 post-mortem traces the drift to three overlapping changes between March 4 and April 16: a reasoning-effort downgrade, a thinking-cache bug, and a verbosity-limit system prompt that interacted badly with prior changes [3].
April 15: What Users Saw on the Day
The timeline on the day itself is tight. Anthropic began investigating elevated errors at roughly 10:53 a.m. ET. The status page logged a window of about 15:31 to 16:19 UTC, with the API reported recovered around 16:01 UTC. Login success rates stabilized by 12:30 p.m. ET [1][2]. The status monitor counted a “major outage” for 40 minutes and a “partial outage” for 73 minutes [2].
From the user side, it looked like everything broke at once. Claude.ai threw login errors. Claude Code returned stream timeouts mid-tool-call. The API surfaced 5xx responses. Users hit messages telling them they had exceeded usage limits despite minutes of inactivity. Cowork went down with the rest. Downdetector reports climbed past 20,000 by 8:39 a.m. PT and crested above 30,000 before the curve bent back down [1][2].
Anthropic’s brief on-day update was minimal: an acknowledgement, a status page entry, a resolution note. The interesting writing came later.
April 23: The Post-Mortem Anthropic Actually Published
“An Update on Recent Claude Code Quality Reports” was published on Anthropic’s engineering blog on April 23, 2026 [3]. It is the document people are referring to when they call this a mystery solved. It is short, technical, and treats three separate changes as the root cause of complaints stretching back to early March.
Change 1: The Reasoning Effort Downgrade (March 4 to April 7)
When Opus 4.6 launched in Claude Code in February, the default reasoning effort was set to high. Users got long think-times. The UI looked frozen on certain prompts. Tokens drained faster than expected. On March 4, the team silently flipped the default from high to medium. Latency improved. Intelligence on hard tasks dropped just enough that experienced users noticed and said so on Reddit and X. The fix landed on April 7, with a new default of xhigh for Opus 4.7 and high for the others [3].
Change 2: The Thinking-Cache Bug (March 26 to April 10)
This is the one with teeth. On March 26, Anthropic shipped a header, clear_thinking_20251015, meant to clear stale thinking from a session once after an idle gap of an hour or more, with a keep:1 parameter. The intention was to reduce latency when a user resumed a long-idle session. The implementation had a bug. Instead of running once, the clear ran on every subsequent turn. Claude looked like it kept forgetting its own earlier reasoning. Worse, the same bug caused cache misses, which burned through usage limits faster than users expected. Anthropic identified and fixed it on April 10 in v2.1.101 [3].
Change 3: The Verbosity Prompt (April 16 to April 20)
On April 16, the day after the public outage, Anthropic added an instruction to the system prompt to reduce response verbosity. The instruction itself, according to the post-mortem, said something like: keep text between tool calls under 25 words; keep final responses under 100 words unless the task requires more detail. In isolation, benign. Layered onto the other prompt changes already in flight, it produced a 3% drop on internal evaluations. They reverted on April 20 [3].
The combined effect of the three changes is what made the degradation feel inconsistent. Each ran on a different schedule. Each hit a different slice of traffic. Some users were affected by all three; some by one. The pattern from outside looked like Claude getting dumber at random.
What “Anatomy of an Outage” Means in 2026 AI Infrastructure
The word outage is doing a lot of work in current AI discourse. The April 15 event was an outage in the classic sense, service down, errors up, recovery in under two hours. The six-week Claude Code degradation was something stranger. The service stayed up. Latency was fine. Authentication worked. Bills processed. The model just felt worse than it had in February. That is a quality regression masquerading as availability, and modern AI infrastructure has more of these than the status pages suggest.
Three structural reasons that gap exists:
- A modern LLM platform is a stack: model weights, inference servers, routing layer, prompt-caching layer, tool-call orchestration, system-prompt scaffolding, harness logic. A change in any one of those can degrade output without registering as an availability incident.
- Status pages were designed for HTTP. They are excellent at “is the API returning 200.” They are bad at “is the model still as smart as it was Tuesday.”
- Many of these changes are deliberately invisible. Default reasoning effort, system prompt edits, cache-pruning logic, none of it appears in a customer-facing changelog because, traditionally, none of it was supposed to matter to customers. In 2026 it matters.
Anthropic’s August 2025 post-mortem went through a similar exercise. Three bugs, overlapping windows, intermittent degradation. A context-window routing error misrouted some Sonnet 4 requests to servers configured for a 1M token build, peaking at 16% of requests in a bad hour. A TPU misconfiguration produced output corruption, occasional Thai or Chinese characters in English replies, syntactically broken code. An XLA compiler miscompilation affected Haiku 3.5 for almost two weeks [4]. The April 23 document is the second time in eight months Anthropic has had to publish a detailed accounting of what was actually wrong.
The Comparison Cases: This Is Not Just a Claude Problem
Five days after Anthropic’s post-mortem, on April 20, 2026, OpenAI had its own bad day. ChatGPT, Codex, and the API Platform took on a partial outage that lasted at least 90 minutes. Routing-layer nodes hit memory limits, failed readiness checks, and dropped out of the pool faster than capacity could absorb. Peak reports, 8,700 in the UK, 1,900 in the US. The most common surface complaint was about old conversations, not new generation: 63% of users couldn’t access prior threads [5].
Google Cloud Vertex AI customers saw their own Gemini API error spike on February 27, 2026, on the global endpoint, between 04:37 and 06:35 Pacific [6]. October 2025 had a separate Vertex AI outage. June 12, 2025 had the IAM token outage that quietly broke much of Google Cloud for the hour, a reminder that “AI infrastructure” sits on top of “ordinary cloud infrastructure,” and ordinary cloud infrastructure still fails the old-fashioned way.
For a longer historical anchor, the CrowdStrike event of July 19, 2024 remains the reference case for how a small content update propagates into mass failure. A modification to Channel File 291 on the Falcon sensor triggered an out-of-bounds memory read, an invalid page fault, and a kernel-mode crash across approximately 8.5 million Windows machines. The proximate cause was a mismatch between a 21-field IPC template and a 20-field sensor input, missed by both the content validator and a missing array bounds check in the content interpreter [7]. The relevant lesson is not the magnitude. It’s that the failure mode was a configuration update treated as routine, riding through validation it should not have ridden through, on infrastructure where a single bad file could cascade.
Claude in April 2026 is the same shape with different physics. Three changes that each passed code review, unit tests, end-to-end tests, automated verification, and dogfooding. The post-mortem says exactly that: the changes “made it past multiple human and automated code reviews, as well as unit tests, end-to-end tests, automated verification, and dogfooding” [3]. Then it adds the part everyone quoted afterward, when Anthropic ran the offending pull requests back through Code Review with Opus 4.7, the newer model found the bug; Opus 4.6 had not. The catcher was the model the bug had degraded.
Why the Mystery Framing Fits and Where It Breaks
For users, the experience was mystery-shaped. Something is wrong. The provider says nothing is wrong. The benchmarks people had in their heads, “this used to one-shot the refactor; now it loops”, were not legible to the status page. Internal state was opaque. Users compared notes on Reddit, on Hacker News, on Discord servers for Claude Code. The lore arrived before the post-mortem did [8].
From the engineering side, none of it was mysterious. Each of the three changes had an owner, a ticket, a deploy log. The mystery was the gap between “we have full internal telemetry” and “we cannot see the user-perceived quality regression in our telemetry,” combined with the standard internet pattern where complaints look like noise until they’re not.
The framing that works best is the one Anthropic settled into: these are normal engineering events with abnormal customer surface area. The instinct to call them mysteries is a function of opacity, not malevolence. There is no conspiracy where a vendor quietly nerfs the model to save compute, even though the timing of any latency-versus-quality tradeoff makes that a hard belief to dislodge.
What This Means for Anyone Building on Claude (or Any LLM)
Three practical things to take away from the April 23 document:
- Model behavior is part of your dependency graph. Pin model versions where the contract matters. Capture canonical inputs and snapshot outputs so you have a benchmark to wave at the vendor when the curve bends.
- Build a fallback that is not the same vendor. The April 15 Claude outage and the April 20 ChatGPT outage were five days apart. A dependency on one provider plus a manual cutover to a second is the minimum hygiene for production AI workloads in 2026.
- Read the post-mortems when they ship. Anthropic’s two, September 2025 and April 2026, both name specific commits, specific dates, specific affected percentages [3][4]. That is the rare, useful kind of vendor writing. It tells you which controls actually exist on the other side of the API call.
The broader pattern is that 2026 is shaping up as the year AI infrastructure gets its own equivalent of cloud outage culture. Forrester’s 2026 prediction set explicitly calls for at least two major multiday hyperscaler outages and a continuing shift of high-utilization AI workloads to controlled environments [9]. GPU lead times of 36 to 52 weeks, HBM4 delays, transformer and switchgear shortages, none of it shows up in the Claude post-mortem, but all of it is the substrate that any AI provider is building on [10]. The April Claude incident is one data point. The set is going to grow.
For more on how contemporary technology mysteries get reframed once the documentation arrives, see the Contemporary Mysteries and Theories hub. The pattern repeats: opacity for weeks, post-mortem in a single Thursday afternoon, mystery dissolves.
A Short Glossary for the Post-Mortem
Reasoning effort. A configurable parameter that controls how much internal deliberation a model performs before responding. Higher effort tends to produce stronger answers on hard tasks at the cost of latency and token use.
Thinking cache. Stored internal reasoning from earlier turns in a session, retained so the model does not have to redo work on follow-ups. Pruning logic decides what to drop and when.
System prompt. Instructions injected before user input that shape model behavior. Edits here propagate to every request and are easy to underestimate.
Harness. The scaffolding around the raw model, tool-call routing, retry logic, context management, output filtering. Most user-visible behavior is harness behavior.
Anthropic published the document. The dates are in the document. The bugs are in the document. The mystery was always a documentation lag.
Frequently Asked Questions
What caused the April 2026 Claude outage?
Two separate events get conflated. The April 15 service outage was a roughly two-hour brownout across Claude.ai, the API, and Claude Code with no public root cause beyond “elevated errors.” The longer March-through-April Claude Code quality degradation was traced to three engineering changes, a reasoning-effort downgrade, a thinking-cache bug, and a verbosity system prompt, per Anthropic’s April 23 post-mortem [3].
When did Anthropic publish the post-mortem?
April 23, 2026, on the Anthropic engineering blog. The title is “An Update on Recent Claude Code Quality Reports” [3].
Was the Claude API affected during the April 15 outage?
Yes. The Claude API, Claude.ai web and desktop, Claude Code, and Cowork all saw elevated error rates during the April 15 window. The API recovered around 16:01 UTC; full system recovery was reported by approximately 1:50 p.m. ET [1][2].
How is the April 2026 outage different from the August 2025 one?
The August 2025 incident involved three infrastructure-layer bugs, a context-window routing error, a TPU misconfiguration, and an XLA compiler miscompilation. The April 2026 incident centered on three product- and prompt-layer changes affecting Claude Code specifically. Different layers of the stack, same overlapping-changes pattern [3][4].
Did Anthropic admit fault?
Yes, in technical detail. The April 23 post-mortem acknowledges that the bug “made it past multiple human and automated code reviews, as well as unit tests, end-to-end tests, automated verification, and dogfooding.” Anthropic also reset usage limits for all subscribers as part of the response [3].
How does this compare to the CrowdStrike 2024 outage?
Scale and mechanism differ. CrowdStrike’s July 19, 2024 incident was a single bad configuration file (Channel File 291) crashing roughly 8.5 million Windows machines in kernel mode [7]. The Claude incident was a multi-week quality regression across a cloud service. The shared pattern: routine changes passing validation that should have caught them.
Should AI-dependent applications expect more outages like this in 2026?
Industry forecasts suggest yes. Forrester’s 2026 prediction set flagged at least two expected major multiday hyperscaler outages and accelerated repatriation of high-utilization AI workloads from public cloud [9]. GPU and power-infrastructure constraints compound the risk [10].
What can developers do to protect their workflows?
Pin model versions in production, snapshot canonical input/output pairs to detect quality drift, build cross-vendor fallback paths, and treat vendor post-mortems as required reading. Status pages alone do not capture quality regressions.
Why did the bug not get caught in code review?
Per the post-mortem, the offending pull requests passed multiple human reviews, automated reviews, unit tests, end-to-end tests, and dogfooding. Anthropic later ran the same PRs through Code Review with Opus 4.7, the newer model, which did find the bug, the older Opus 4.6 had not [3].
Where do I find the official status history?
Anthropic’s status history lives at status.claude.com/history. Independent sources include Downdetector for user-report aggregation and StatusGator for cross-service tracking.
Sources
[1] CNBC. “Anthropic products are operational after brief outage, status page says.” April 15, 2026.
[2] TechRadar. “Claude was down, here’s everything we know.” April 15, 2026.
[3] Anthropic Engineering. “An Update on Recent Claude Code Quality Reports.” April 23, 2026. anthropic.com/engineering/april-23-postmortem
[4] Anthropic Engineering. “A Postmortem of Three Recent Issues.” September 2025. anthropic.com/engineering/a-postmortem-of-three-recent-issues
[5] OpenAI Status. “Major Outage across ChatGPT and API.” April 20, 2026.
[6] Google Cloud Status. “Vertex AI Gemini API increased error rates.” February 27, 2026.
[7] CrowdStrike. “External Technical Root Cause Analysis, Channel File 291.” August 6, 2024.
[8] User-report aggregation: Downdetector, April 15, 2026 peak window.
[9] Forrester. “Predictions 2026: Cloud Outages, Private AI on Private Clouds, and the Rise of the Neoclouds.” 2025.
[10] Industry reporting on GPU capacity, HBM4 delays, and data-center power constraints, 2026.
