By Stan Chang · · 4 min read · #artificial-intelligence
Software Is Oxidising
As agents make rewrites cheaper, teams are revisiting what runs on servers and phones.
#ai #agents #rust #software-development
Whatever can be written in Rust will eventually be written in Rust.
I started thinking of this as Rustification. Canonical has a better word: oxidising. Its Ubuntu 26.04 LTS release makes Rust implementations of core utilities and sudo the defaults, while keeping the original versions available.
More teams are oxidising their software. Bun rewrote its core from Zig to Rust and shipped the result in Bun 1.4. The React team has merged an experimental Rust port of React Compiler.
Bun shows how the economics have changed. Anthropic acquired Bun in December 2025. Bun creator Jarred Sumner says a pre-release Claude Fable 5 helped complete the port in 11 days of agent workflows. He puts the model usage at about $165,000 at API prices. That is an estimate, not a disclosed bill. As I argued in The Great Token Arbitrage, the effective price of model work depends on how you access it. Sumner estimates the port would have taken three engineers roughly a year by hand. A rewrite the team would not previously have attempted became feasible.
Anthropic took the idea to an extreme. In its Opus 5.5 announcement, it used translating HAProxy from C to Rust as an internal benchmark. Both models passed nearly all of HAProxy’s regression tests. Opus 5.5 completed the translation in 9.5 hours, at 51% less cost than Fable 5.1.
This was a benchmark, not a HAProxy project migration. But the fact that a substantial, widely used C program can serve as a test of how fast and cheap a model can rewrite software says something about what teams may try next.
The reaction is part of the story
At Rails World, DHH described moving HEY toward a Rust backend and native frontends. The original keynote video has since been made private, but a public transcript preserves the announcement. It landed differently because it came from the creator of Rails. The reaction in the Rails community was angry, anxious, and sometimes quite personal.
Some people worry about maintaining large amounts of agent-written code. Others wonder what happens to Rails if a company that has shaped it for years builds its next version of HEY elsewhere.
There is an emotional part to this too. Ruby and Rails made writing software pleasant for people. Agents taking on more implementation changes how much that quality weighs in a stack decision. For a community built around developer happiness, that can feel like a loss. I expect similar frustration as other teams make the same calculation.
The move back to native
The broader pattern appears on phones too. Shopify says it is moving its mobile apps from React Native back to Swift and Kotlin. Shop has already shipped as a fully native app; the Shopify app is being rebuilt, with the rest planned to follow.
Shopify says React Native worked well for it. Building a feature once saved time and helped its teams keep the two platforms in sync. Coding agents have since reduced the work of implementing and maintaining separate versions for iOS and Android. That lets Shopify put more weight on native platform capabilities, first-party tooling, and fewer framework dependencies.
Rust on the server and Swift and Kotlin on phones have different payoffs. The common change is that teams can revisit technology choices made when the cost of human implementation dominated the decision.
In an earlier post, I argued that getting code written is becoming easier, while deciding what deserves to become software takes more of our attention. There is a second consequence: after deciding what to build, we can spend more effort on what it costs to run.
The initial rewrite is an upfront expense. Running the software is a recurring one.
On servers, CPU and memory show up on every request and every monthly bill. If agents lower the cost of a rewrite, it becomes easier to justify work that makes each request cheaper. When Cloudflare replaced its NGINX-based proxy infrastructure with the Rust-based Pingora, it reported using about a third as much CPU and memory.
On mobile, the recurring returns may come through app performance, closer access to platform features, and less framework upkeep. In both cases, the new code still has to be tested and maintained. The economics become compelling when those ongoing gains outweigh the rewrite and maintenance costs.
Like iron left out in the weather, software is going to get rusty.