Essay

Everything Falls to Rust

The language stopped mattering the moment agents started writing it

By Niels Kristian Schjødt·October 2026·~14 min read
Cover illustration for Everything Falls to Rust, rusty old cars orbiting a glowing nucleus like electrons in a classic atom diagram, shedding rust dust, in warm muted tones
Listen to the podcast0:00--:--

Decay Toward Lead

Radioactive isotopes are unstable. Give them time and they fall apart, step by step, until most of them end up as lead. Lead is boring. Lead is stable. Lead is where things stop.

Programming languages are doing something similar. Give them enough time with AI agents, and they all seem to decay toward Rust.

Rust has never been a particularly nice language to write. The borrow checker argues with you. The compile times test your patience. But it is fast, and it is stable as hell. If you want high performance and decent code, it is the obvious answer these days.

What changed is who has to enjoy writing it. It is no longer a human. The AI writes it, and the AI writes it well.

When the human stops writing the code, the language no longer has to be pleasant. It only has to be fast, strict, and checkable.

It is a fun way to put it, and I will come back to Rust. But Rust is not really the point. The point is bigger: the language does not matter anymore. Agents write it. Whichever one they pick, nobody on the team has to love it, learn it, or live with it for the next ten years.

That one shift, from humans writing code to machines writing code, is breaking a whole stack of things we took for granted. Languages. Code review. Version control. Libraries. Deployment pipelines. Even the interface on top. Each of them was designed around the speed and limits of a human developer, and each of them is now turning into a bottleneck.

The Drift Is Already Visible

A few data points from the last months.

ArtCraft. A small team, started by a single developer, has been rebuilding Adobe’s creative suite with Claude: Photoshop, Illustrator, Premiere, Lightroom, After Effects, InDesign and Acrobat equivalents. All of it in Rust, from day one. Nobody chose Rust there because it is fun. They chose it because, when the agent is doing the typing, there is no reason to pick anything slower.

Bun. The JavaScript runtime was written in Zig. This summer it was ported to Rust in roughly eleven days, more than half a million lines, by dozens of Claude agents working in parallel, each one followed by adversarial review agents. A rewrite of that size used to be a multi-year decision that most teams never dared to make. Now it is a sprint.

Why the Language Used to Matter

For most of my career, choosing a language was one of the biggest decisions a team could make. You lived with it for a decade. There were three good reasons for that.

Agents dissolve all three. They are fluent in every mainstream language at once, so there is no team skill to protect. They build instead of import, so the ecosystem matters far less (more on that below). And as Bun showed, a rewrite that used to take years now takes days.

The language was
A decade-long commitment, chosen by what the team knew
→
The language is
A choice per system, made on merit, and easy to make again

Rebuild the Whole Thing

The most useful thing I have started doing lately follows directly from that.

I take one of our existing systems at AutoUncle and start an agent entirely from scratch. I give it knowledge of the code, so it understands what the system does today. I tell it about every problem the system has: what is slow, what is fragile, what we have been working around for years. And then I ask it to rebuild the entire thing. Not a module. Not a subset of the service. The whole thing.

And I let it choose the language freely. Different languages have different strengths, and different libraries for different jobs. A system that mostly crunches data has other needs than one that mostly talks to other services. The agent can weigh that without any loyalty to what we happened to pick years ago.

Rebuilding has become so cheap that sticking with what you know is a habit, not a necessity.

That would have been reckless advice a few years ago. Rewrites were where projects went to die. Now the expensive part is not producing the new system. It is deciding that you want one, and checking that it does what the old one did.

It also cuts the other way. If I can rebuild our own systems from scratch this cheaply, so can anyone else. I will get back to what that means at the end.

So Why Rust?

If agents are free to choose, why does so much of it end up in Rust, and not in Go or Zig? I will be honest: the internet answers that better than I do. Having read through it, the case for Rust goes like this.

A strict compiler is a free reviewer sitting inside the agent’s loop. Rust’s errors tend to point at the actual root cause, and an agent that gets precise feedback converges faster than one that has to chase a bug through a stack trace at runtime. Memory safety and the type system catch whole categories of mistakes before the code ever runs. If nobody is reading every line, you want the compiler to.

The counter case is real, and I think it belongs in this post. Several practitioners argue that Go gives agents a faster loop: quick compiles, simple code, and a standard library big enough that the agent rarely goes looking for packages. And a compiler that accepts the code is not the same as good code. Bun’s AI-written Rust reportedly leans on far more unsafe blocks than comparable hand-written projects.

So no, I cannot prove Rust is the end state, and for a given system the agent may well pick something else. But the trade-off has clearly moved. The cost of Rust was always paid by the human writing it. Remove the human from the keyboard and most of the cost disappears, while the speed and the guarantees stay.

The Paradigms Built for Humans

The language is just the most visible layer. Underneath it, the whole process of building software was designed around how fast a person can write, read and reason about code.

Code review was the first to go. We let go of mandatory human code review at AutoUncle a while ago. I wrote about why in Everyone Produces Code Now. Once agents write most of the code, a human reading every diff is not a safety net. It is a queue.

Then version control itself. Git is about as foundational as developer tools get. Everyone takes it for granted. Anthropic’s merge volume reportedly went from around 2,500 merges a day in May to more than 30,000 by September, and at that volume git became the bottleneck. So they built their own source control, Scion, designed for agents and CI jobs rather than for a developer working offline on a laptop. When the company that builds the coding model has to replace git, that tells you something about where everyone else is heading.

And the time from idea to production. The other day we shipped a new feature at AutoUncle, license plate lookup. It took exactly one day from idea to a finished, production ready feature. It rides on the back of a lot of existing tooling and infrastructure, of course. But one day. A few years ago that would have been a quarter’s roadmap item.

Built for
A human writing, reading and reviewing every line
→
Now serving
Machines producing code faster than humans can read it

“There’s a Gem for That”

Anyone who has worked in Ruby on Rails knows the phrase. Need authentication, PDF generation, background jobs, pagination? There is a gem for that. That culture is a big part of why Rails development was fast and reliable. You did not write things. You assembled them.

Agents do not work like that. They hardly ever suggest adding a gem. They just build the thing. A study of agent-authored pull requests found agents happily use libraries that are already in a project, but only 1.3% of their pull requests add a new dependency.

That sounds like a small observation. It is not. A language’s ecosystem used to be its biggest advantage, and one of the main reasons you could not switch. Rails won partly on its gems. If agents build instead of import, the ecosystem stops being the thing that holds you in place. Nothing keeps you on a language except how fast and how safe it is. Which is part of why everything drifts toward Rust.

It is the same story I see everywhere right now: anything can be built, so the thing that used to be scarce stops being a moat. Here it happens one layer down. Open source libraries lose their moat too.

⚠️ The flip side: fewer dependencies means a smaller supply chain to attack, and fewer of the hallucinated package names that attackers have started to register. It also means more hand-rolled code that nobody outside your company has ever looked at. The harness has to carry that weight, which is why enforcing quality matters more than ever.

Delivery Becomes a Stream

Next in line is the pipeline. CI/CD as we know it is a sequence of gates: build, test, review, stage, release. It was designed for a world where a team shipped a handful of changes a day.

That world is going away, for two reasons. The first is competition. When AI-first companies expect a few hours from idea to production, anything slower is a disadvantage you feel every week. The second is security. Flaws and holes are found faster than ever, often by the same kind of models that write the code, and you need to respond almost instantly. Nobody has patience for a release train anymore.

I do not think the answer is simply faster pipelines. I think software starts to stream: a continuous flow of small changes, validated by machines, rolled out and rolled back automatically, more like a river than a train schedule. There is not a lot of hard evidence for this yet, mostly early talks and vendor pitches, so take it as the direction I see rather than settled practice. It ties into what I described in DevOps 3.0: the platform has to make this safe for everyone, not just for engineers.

What Comes After Rust

Lead is where the decay stops. I am not sure Rust is. Something comes after, and I keep wondering what it looks like.

Do machines just eat bytecode? If no human needs to read the code, why write it in a language designed for humans at all?

Or do we get an Esperanto for software? Esperanto was invented in the 1880s as the optimal common language for everyone, regular, logical and easy to learn. What is the version of that for machines writing code?

The first serious attempts are here. Vercel Labs released Zero this year, a systems language designed for agents first: compiler errors as structured JSON, machine-readable repair plans, and agents that edit a program graph instead of text files. And the most common criticism of it? That it is basically Rust.

Even the first language built for AI decayed toward Rust. I find that telling.

And Esperanto, for all its elegance, never became the common language. English did. Not because it was the best design, but because it was already everywhere. Maybe that is the honest prediction for software too: not a perfect new language, just the one that happened to be fast, strict and already in the training data when the machines took over the keyboard.

Is It Really a Contradiction?

One thing has bothered me while writing this. At first glance, the code and the interface seem to be heading in opposite directions. Are they?

Underneath, software is going custom. “I will just build it myself,” in whatever language fits, and rebuilt from scratch when it stops fitting.

On top, interfaces are going custom too. On 7 October, OpenAI shipped GPT-6 with what it calls Intelligent UI: answers that are no longer just text, but calculators, charts, maps and buttons, generated for that one question. The interface stops being something you design once and ship to everyone.

So far, the same direction. But there is a catch. That custom interface is generated inside somebody else’s product. Owning the UI is going to be really, really hard, because the big labs will own it through their chat harnesses, at least for now. Nobody is going to want a separate interface for their CRM, their image editing or their accounting if they can do all of it from inside ChatGPT or Claude, with the services they rely on plugged in to provide the special capabilities, knowledge and data.

Who wants to flip between five different apps? “We do not want another piece of software” has always been true. Now reality is catching up with it. It is the argument I made in Database in a Trenchcoat.

So no, it is not a contradiction. Both trends point the same way. The code underneath becomes custom and disposable, and turns into the backend. The interface on top consolidates into a handful of chat harnesses owned by the labs.

Which leaves a bigger question than which language wins. If anything can be built, rebuilt from scratch in whatever language suits it, and served through someone else’s interface, what is actually left that protects a software company? That is the next post: No Moat Left in Software.