Both of my runtimes are Rust. goldengoose’s native core is Rust, and roughly 90% of the app was built using the app itself: agent teams writing the runtime they run on. gooselake, the extracted, headless version that owns durable sessions, event logs, and delivery state, is Rust end to end, and agents wrote most of that too. When I tell people this, the question is usually some version of: you let language models write the layer that holds all your state?
Yes, and Rust is the reason I sleep fine. Not because it’s fast, and not because I’m a systems purist. Because the property that made Rust famous and famously annoying, a compiler that refuses to accept code until it can prove things about it, turns out to be worth dramatically more when the author is an agent than it ever was when the author was me.
Agent code is confidently wrong
The characteristic failure of agent-written code isn’t syntax errors or obvious nonsense. It’s code that is plausible: well-shaped, idiomatic-looking, reasonable in review, and wrong in some way that surfaces three layers and two weeks away from the diff. A field that’s sometimes absent. A state that two tasks mutate without coordinating. A match that handles the variants that existed when the agent last looked.
So the question I ask of a language, now that agents write most of my code, isn’t how expressive it is or how much I enjoy it. It’s: what fraction of confident wrongness does the toolchain convert into immediate, textual, local feedback? Every bug class the compiler catches is a bug class that gets fixed inside the agent’s own working loop, seconds after it’s written, at a cost of approximately nothing. Every bug class it can’t catch has to be caught by my review machinery, including supervisors reading diffs, acceptance reviewers, and browser-driving testers, which is machinery I pay for in context windows and wall-clock time. Rust moves more classes into the first bucket than anything else I’ve shipped with.
The reviewer that reads every line
My pipelines lean hard on review: supervisors reading diffs like senior engineers, reviewers clearing branches before integration. But every reviewer in that pipeline is an agent with a finite context window, and review attention is exactly the thing that degrades as a diff grows, as a session compacts, as the tenth phase lands at whatever the model’s equivalent of 2 a.m. is.
rustc is the one reviewer in the system that reads every line of every diff, every time, with no context window, and never gets tired. And it happens to produce feedback in precisely the format agents consume best: textual, specific, located at the offending line, usually with a suggested fix. A human reading their fourth borrow-checker error in a row gets demoralized. An agent reads it, applies the fix, and re-runs cargo check with the infinite patience of something that does not experience frustration. I’ve watched implementers grind through compile-fix loops that would have sent me for a walk, and the branch that comes out the other side has had a category of review performed on it that no LLM reviewer could match, because the compiler doesn’t skim.
Conventions that can’t drift
The deeper effect shows up with parallel agents. A feature in my world is built by a rotating cast of implementers, rotated out when their context runs low, with no shared memory of each other’s decisions. Coordination between them is messages, plans, and the codebase itself. In a permissive language, that’s how conventions rot: each agent writes something locally reasonable, the styles and assumptions diverge, and integration becomes archaeology.
You can fight that with instructions, a CLAUDE.md full of “always handle the error case” and “never share mutable state,” but instructions are suggestions to a model, and suggestions decay with distance from the top of the context. Rust’s conventions aren’t suggestions. Ownership means an implementer cannot quietly share mutable state with something another agent wrote; the program won’t compile. Result means it cannot forget the error path by accident; ignoring one is a visible, greppable decision. And exhaustive matching is secretly a coordination tool: when one implementer adds a variant to a state enum, every touchpoint that other agents wrote across the codebase fails to compile until it’s handled. That’s a cross-agent contract negotiation that in any other language happens over DMs, or doesn’t happen and ships. Here the compiler conducts it, and nobody’s context window has to hold it.
The same trick guards my one boundary that isn’t Rust: goldengoose’s typed IPC bindings mean a runtime type change won’t build until the TypeScript frontend agrees with it. Agents on either side of that boundary can’t drift apart, because drift is a compile error rather than a runtime surprise.
The economics flipped
Everything above was true about Rust before agents. So why wasn’t everyone already writing their services in it? Because the strictness was a tax, and humans paid it in the currency they value most: writing speed and morale. The classic Rust trade was slower, more annoying authorship in exchange for fewer runtime failures: a good trade for critical software, a hard sell for everything else.
Agents change the exchange rate. Authorship is now nearly free; an implementer producing three compile-fix iterations instead of one costs me nothing I notice. The annoyance is paid by something that cannot be annoyed. What remains is only the benefit side of the old trade: the proofs, the enforced conventions, the impossible bug classes. A tax I don’t pay is a subsidy.
One cost does survive: compile times. The feedback loop that makes all of this work is only as fast as cargo check, and on a large workspace that’s real seconds, sometimes real minutes. That’s why my playbooks run Rust checks through the background process manager with results injected back when they finish, and never in parallel, because two cargo builds fighting over a target directory is its own special misery. Compile time is the one place agents still pay Rust’s tax on my behalf. I consider it well priced.
Where I’d spend this
The conclusion isn’t “write everything in Rust.” My frontends are TypeScript, my scripts are whatever’s closest, and a browser-testing harness gets to be a 78-line throwaway .mjs, as it should be. The conclusion is about the layer where wrongness is expensive: the service that owns durable state, the runtime other things build on, the code where a silent bug becomes corrupted data instead of a visual glitch. That layer was always the argument for Rust. What’s new is that agents removed the counter-argument. When the author is a model, confident, fast, and unembarrassable, the best co-author is a compiler that refuses to be impressed.