Three weeks before Claude Docs opened to the public, it was a proof of concept running on a single node, used by a few thousand people inside Anthropic. The team was racing toward an ambitious launch date, and their own estimate said millions of docs would appear within the first few days.

They launched on September 16. By September 22, people had created over 4.6 million docs. Across 2 billion requests, the service saw only 60 server errors — and never rolled back once. The whole service ran on about 50 memory-optimized pods.

In a post on Anthropic's developer blog, engineer Vivek Nair explains how they got there. The answer is not a heroic launch-week effort. It is a two-week loop in which Claude was told, in effect, to keep breaking the service until it stopped breaking.

The loop: break it on purpose, then fix it

A few thousand internal users on one machine said nothing about whether the service would survive launch, and there was obviously no launch traffic available to test with. So on September 4, about two weeks before launch, Nair had Claude drive a staging cluster that mirrored production — generating over a million synthetic docs a day and deliberately breaking core components. Then he left it running.

The setup was a single Claude Code session acting as a coordinator, handing most of the work to sub-agents: about 11 running at a time in the busiest week, 30 at the peak. The coordinator also talked to other infrastructure teams inside Anthropic through an internal variant of Claude Tag, via the Slack MCP, so their agents could check the scaling approach against pitfalls they had already hit.

Each iteration followed the same shape. The harness picked a feature — document creation, say — and pushed it to saturation. Claude read telemetry through the Datadog MCP and came back with a short menu of options and a recommendation. If the recommendation was easy to undo, Claude wrote the change, deployed it to staging, and reran the test.

The scenarios were deliberately paranoid:

  • 10 million new docs created in a single day
  • 22,000 live connections reconnecting at once
  • One hot doc with hundreds of viewers, a server killed while it was still loading the doc, and the database stalling

Two invariants governed everything. Docs had to open almost instantly, even ones with a long history. And once the server acknowledged an edit, tests had to prove the edit was still there. Anything hard to undo — a database schema change, a key layout change, a change to how docs are stored — stopped the loop and waited for a human decision, usually with a recommendation attached.

The real work: making the service legible to Claude

The loop itself is the easy part to describe. The harder part, and the one Nair spends most of the post on, is making the service legible enough for Claude to close the loop on its own.

Every operation the service ran had telemetry. Every database query reported its name and how many rows it scanned versus how many it returned, so Claude could spot a bad query and rewrite it. And Claude kept adding telemetry as it went — writing the instrumentation it found missing, instead of waiting for a human to add it after something broke.

Memory is the best example. Early in the harness run, one large doc was using about 3 GB on its pod. Claude's first fix was to shrink a cache so the server would evict docs sooner. The next harness run showed the memory was actually in a separate cache inside one of the service's dependencies, so Claude dropped the change. Finer-grained profiling then found the real cause: every keystroke was copying the doc into several different data structures, adding a few MB each time. Claude switched those structures to copy-on-write, so they now share one reference instead of each holding its own copy.

After about three days of iterating, that doc topped out around 180 MB, and the estimate of what launch would need dropped from more than 500 memory-optimized pods to about 50.

The technology choices were picked for the same reason. The service was written in Rust, with no garbage collector, so all of a doc's memory sits in structures the team defined — when memory grew, Claude could point at the one responsible. Dependencies were kept to a minimum, and the few that were genuinely needed were vendored in, so the team could read and measure them. Nair is explicit that this is a bet, not a benchmarked comparison: Anthropic has great Go tooling too, and the two languages were never baked off against each other. The point is that every number Claude measured traced back to code the team wrote.

Launch week: the rehearsal paid off

The first million docs showed up in about 30 hours. The team deployed to production 629 times in September and never rolled back once. And launch week felt, in Nair's words, weirdly familiar: seven of the ten scenarios rehearsed on staging actually happened in production. By then the harness had already put staging through most of it, and Claude had shipped the fixes behind runtime flags. When part of the infrastructure ran into pressure, the team usually just flipped a flag.

Why this works now — and why it wouldn't have a few months ago

Nair is candid that this only worked because frontier models got better at long-running work recently. He used an internal research model roughly comparable to Claude Fable 5.2. Older models could read telemetry through an MCP server, but ten or twenty iterations into a long loop they started forgetting what was being optimized for, and he had to restate the goal — a phenomenon other Anthropic employees call goal drift. The newer model held all of the invariants across many context compactions, and he never had to repeat them.

Anthropic is not the only team doing this. Vercel used a supervised agent loop a lot like this one to make Turborepo up to 96% faster.

What it cost — and what it would cost you

At Claude Fable 5.2's API list price as of November 2026, Nair used roughly $125,000 of inference from the end of August to launch day. A couple of years ago, he estimates, work on this scale would have taken a team of engineers about six months. Most of the spend went to reading telemetry, writing proposals, generating fixes, and reviewing code — and he notes that a good chunk went to infrastructure that only makes sense at Anthropic's scale, plus tokens burned while he was still figuring out the setup. Knowing what he knows now, he thinks it could have cost about half as much.

For a smaller service, he prices out a classic small-team stack — a couple of reasonably sized Kubernetes nodes and a Postgres instance — and strips out the work that setup wouldn't need: fitting in with internal services, client and product work mixed in with the scale work, running across many pods, and fine-grained rate limiting. About a third of the changes were left. Scaled down, he puts a two-week push like this one at $3,000 to $10,000 at the same list price — a rough sense, not a number he has actually run.

The five steps, if you want to try it

The post closes with a recipe, assuming one engineer with Claude Code, a staging environment, and an observability provider:

  1. Give Claude access to your telemetry. Most observability providers have an MCP server Claude can use.
  2. Have Claude write a load script that throws ten times your real traffic at the staging copy of the service — and breaks things on purpose. Killing an instance, stalling the database, and deploying in the middle of a spike are good places to start. Then let Claude keep fixing whatever falls over.
  3. When picking your stack, lean toward whatever Claude can measure most easily. For Anthropic, that was Rust and as few dependencies as possible.
  4. Before you start, write down your most important technical invariants and give them to Claude.
  5. For anything hard to undo, have Claude stop and give you a few options with a clear recommendation.

The coordinator and sub-agents sped things up, but Nair notes that if they burn too many tokens per hour, going back to a single agent should also work quite well.

The deeper lesson is a shift in altitude. Instead of asking Claude to fix individual crashes, you ask it to make your app crash-free — and then you build the harness, the telemetry, and the invariants that let it actually do that. The chaos loop is not really about chaos. It is about giving an agent a goal it can hold for weeks, a way to measure progress, and permission to keep going until the evidence says the service is ready.

Source: Vivek Nair, "Using a 'chaos loop' to harden the Claude Docs launch: 60 server errors across billions of requests", Claude.dev, November 17, 2026 — https://claude.dev/blog/chaos-loop-claude-docs-launch/