Anthropic Rewrote Its Messages API in Rust With Claude and Cut CPU Use by 40–50%

Shipping a production Rust service with zero Rust specialists

Rewriting a high-throughput API in a systems language like Rust ordinarily requires either hiring experienced Rust specialists or spending months training an existing backend team on ownership rules, borrow checking, and async runtimes. According to remarks by Katelyn Lesse on the Latent Space podcast—later summarized by AI researcher Somi—Anthropic took a different route when overhauling its Messages API: the team completed a full Rust rewrite with zero dedicated Rust developers on staff.

Instead of treating unfamiliar syntax and compiler constraints as a staffing blocker, the team split the engineering work along a clear boundary. Claude wrote the Rust implementation code, while the human engineers focused on the system architecture, migration plan, and correctness harness. After deployment, CPU utilization on the Messages API dropped by 40% to 50%.

Human planning and real-traffic parity checks kept the migration safe

The decisive factor in making an AI-authored rewrite production-ready was not blind trust in generated code, but rigorous black-box verification. Human engineers authored the overarching design plan before Claude wrote the Rust modules, ensuring that request routing, serialization, and error semantics followed explicit specifications rather than ad-hoc prompts.

Once the Rust service was running, the team validated it by comparing the old implementation against the new Rust implementation on real traffic. Verifying that both versions produced matching behavior under actual production payloads allowed engineers who were not full-time Rust specialists to sign off on the cutover with confidence while capturing the 40% to 50% CPU savings.

• Code generation by Claude

  Claude handled translating the service logic into idiomatic, memory-safe Rust without requiring dedicated Rust hires on the team.

• Architecture and planning by humans

  Human engineers defined the migration plan, service boundaries, and rollout sequence before code generation began.

• Real-traffic shadow comparison

  Engineers checked that outputs from the old implementation and the new Rust build matched on real traffic before completing the switch.

Why 'never do the big rewrite' is being reconsidered

For decades, one of software engineering's most durable warnings has been to avoid rewriting working production systems from scratch. Big rewrites traditionally stall because writing every module in a new language takes months or years, during which subtle edge-case regressions accumulate and requirements drift.

Anthropic's Messages API migration illustrates why that rule of thumb is being re-evaluated. When a frontier coding model compresses the time required to translate existing logic into Rust, and when an existing service already has live traffic that can be replayed or shadowed to prove exact behavioral equivalence, the cost-to-benefit ratio shifts sharply. Teams can harvest a 40% to 50% infrastructure efficiency gain without freezing product development for a year.