Skip to content
intermac
Journal
Engineering

4 min read

Legibility to AI is now a real infrastructure design constraint

Anthropic's chaos loop post is worth reading for the technique, but the deeper takeaway is that they made explicit stack choices—Rust, minimal dependencies—based on what an AI agent can reason about clearly. That's a new dimension in infrastructure design.

By intermac

The numbers from Anthropic's post on the Claude Docs launch are striking: 60 server errors across 2 billion requests, 629 production deployments in September, zero rollbacks. The whole service ran on about 50 memory-optimized pods when early estimates pointed to more than 500. Three weeks before launch it was a proof of concept on a single node.

The technique — a "chaos loop" where Claude ran continuously against a staging cluster, breaking things and fixing them for two weeks — is straightforward to adopt. But the more interesting choice is buried in the implementation detail: Anthropic picked Rust and kept dependencies minimal not for the usual reasons, but because they needed the system to be legible to Claude.

What legibility to AI actually means

A garbage-collected runtime adds noise to memory and latency measurements because the collector runs on its own schedule. If Claude is hill-climbing on a signal — memory per document, say — GC noise makes it hard to tell whether a change actually helped. Rust gives you memory that sits in structures you defined. When one large document was using about 3 GB on its pod, Claude could trace the usage, narrow it down over several iterations, and eventually find that every keystroke was copying the document into multiple data structures. It switched those to copy-on-write. Clean signal, traceable fix. After about three days of iterating, that document topped out around 180 MB.

The same logic applied to dependencies. Every library brings data structures the agent didn't write and can't easily account for. Fewer libraries means every number Claude measures traces back to code the team wrote.

This is a new design constraint worth naming explicitly: stack choices should consider what an AI agent can reason about clearly.

What this means for small teams

The post includes a rough cost estimate for a smaller setup: $3,000 to $10,000 at API list price for a two-week hardening run on a standard Kubernetes and Postgres stack. That's not trivial, but it's well within range for a launch with serious reliability requirements.

The setup is also not exotic. Give Claude access to your telemetry via an MCP server. Have it write a load script that throws ten times real traffic at staging and kills instances, stalls the database, and deploys mid-spike. Let it fix whatever falls over. Set your most important technical invariants up front in writing. Gate anything hard to undo — schema changes, key layout changes — behind a human approval step with a clear recommendation from the agent.

One real caveat the post is honest about: this only works reliably with current frontier models. Older models suffered from goal drift — ten or twenty iterations in, they'd start forgetting what they were optimizing for. The newer ones hold a goal and a set of invariants across a long run. If you try this with a model that drifts, you'll spend more time correcting the agent than you save.

The trade-off worth naming

Choosing Rust for AI legibility when your team already has strong Go tooling is a real cost. The post acknowledges it directly — Anthropic has great Go tooling — but lands on Rust because the agent writes both fine. That's a reasonable call when the agent is doing most of the implementation. It's a harder call if your team is doing the implementation and an agent is only assisting.

The underlying principle still applies: when you're designing a system that an AI agent will monitor, debug, or improve, make the system's behavior as observable and attributable as possible. Explicit over implicit, deterministic over nondeterministic, minimal over maximal. Those aren't new engineering values. But now there's a concrete operational reason to enforce them — and a two-week pre-launch hardening run to prove it out.

Sources

Tags

  • #chaos-engineering
  • #ai-agents
  • #observability
  • #infrastructure
  • #reliability