
Hardening Claude Docs launch with a chaos loop

Three weeks before Claude Docs went public, the service was a proof of concept on a single node used by a few thousand Anthropic employees, with an internal estimate of millions of docs in the first few days. Anthropic 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, never rolled back, and ran on about 50 memory-optimized pods. Two decisions got it there: a chaos loop at launch scale, and making the service legible to Claude.
The chaos loop started September 4. The author had Claude drive a staging cluster mirroring production, generating over a million synthetic docs a day while breaking core components on purpose, then left it running. The loop was a Claude Code session acting as coordinator, with about 11 sub-agents in the busiest week and 30 at peak; it also consulted an internal variant of Claude Tag (beta) over the Slack MCP to learn from Anthropic infrastructure teams who had scaled similar services. Scenarios were deliberately paranoid: 10M new docs in a day, 22,000 live connections reconnecting at once, one hot doc with hundreds of viewers, a server killed while loading a doc, and a stalling database. Each iteration had the harness push a feature to saturation; Claude read telemetry through the Datadog MCP and returned options with a recommendation. Easy-to-undo fixes went straight to staging and were rerun; anything hard to undo, such as database schema changes, key layout, or how docs are stored and materialized, stopped for human approval. Two invariants held throughout: docs had to open almost instantly even with long history, and acknowledged edits had to persist in tests. The author credits the framing to Felix Rieseberg’s tutorial on raising prompt “altitude”: ask for the outcome, not the individual task.
The second decision was legibility. Every operation reported telemetry, including each database query’s name and rows scanned versus returned, so Claude could spot and rewrite bad queries. Claude also added telemetry it thought was missing each iteration. The memory example is clearest: a large doc used about 3 GB on its pod. Claude first shrank one of the server’s caches, then found the memory actually sat in a separate cache inside a dependency, then used finer-grained profiling and discovered every keystroke copied the doc into several data structures. Switching those to copy-on-write brought the doc to about 180 MB after roughly three days, and the launch estimate fell from more than 500 memory-optimized pods to about 50.
Technology choices were made for clean signal. The service was written in Rust: with no garbage collector, all of a doc’s memory lives in structures the team defined, so growth could be traced to one responsible structure, changed, and re-measured next iteration. The author notes Anthropic has good Go tooling and no bake-off happened; this is simply their experience with Rust. Dependencies were kept minimal, and the few that were needed were vendored so they could be read and measured. Rust’s human difficulty mattered much less once Claude could write it.
Launch week held. The first million docs appeared in about 30 hours. The team rolled prod 629 times in September and never rolled back. Seven of the ten scenarios rehearsed on staging actually happened in prod; fixes were already behind runtime flags, so pressure usually meant flipping a flag.
The author explains why this works now: older models could read telemetry through an MCP server but began forgetting the goal after ten or twenty iterations, a pattern Anthropic employees call goal drift. The newer frontier models hold invariants across many compactions, so the author never had to restate them. The internal research model used was roughly comparable to Claude Fable 5.2. Vercel made Turborepo up to 96% faster with a similar supervised agent loop.
Cost: roughly $125,000 of inference at Claude Fable 5.2‘s API list price as of November 2026, from end of August to launch day. Most went to reading telemetry, writing proposals, generating fixes, and reviewing code. The author guesses this scale of work would have taken a team about six months a couple of years ago. A good chunk went to launch-scale infrastructure that took more inference to reason about, and process experimentation burned extra tokens; with hindsight, about half could have been saved.
The approach is claimed to transfer to much smaller services. Pricing out a small Kubernetes-and-Postgres stack and removing scale-specific work (internal service integration, client/product work, multi-pod operation, fine-grained rate limiting) left about a third of the changes. Scaling spend to that third and excluding setup mistakes gives a rough two-week estimate of $3,000–$10,000 at the same list price, though the author hasn’t run that configuration. The steps: give Claude telemetry access through an observability MCP server; have Claude write a load script throwing ten times real traffic at staging while breaking things (kill an instance, stall the database, deploy mid-spike); choose a stack Claude can measure easily, like Rust with few dependencies; write down the most important invariants and give them to Claude; and for anything hard to undo, have Claude stop and present options with a clear recommendation. The author notes a single agent also works well if sub-agents burn too many tokens per hour, and thanks the Docs team for thousands of editor fixes and the platform and storage teams.

