As person who has made a occupation of programming tongue design, I certainly have moments of existential dread concerning the increase of LLMs. I started coding in 5th class on an x861 that ran at 5MHz, had item akin a 5MB hard-disk and 512K of RAM2. Computers were really, really distinct rear then. But honestly, programming wasn’t. For all the advances in IDEs and programming languages and so forth, the essential act of entering code into a document has remained amazingly constant3 – correct up until a few years ago, whenever everything kinda turned on its head. That’s been breathtaking and empowering at times4 but additionally scary and disorienting. Will my skills in programming matter? What concerning my skills in programming tongue design (such as they are)? This blog article is my attempt to answer those questions.
So as not to keep you in suspense, let me fair provision you the conclusion. In short, yes, I accept there volition motionless be a function for humans in programming. And yes, I think that programming tongue scheme is motionless relevant. And, naturally, I additionally happen to think Rust is a really fine fit for agentic betterment – but that’s not to say we can’t create it a better fit. And that’s what this article is ultimately about: what makes Rust and agentic betterment activity well, and anywhere we could twice downward on those strengths.
This is a benevolent of “blog article companion version” of a talk I gave this week at REBASE, part of SPLASH. You power additionally bask the slides from the conversation I gave at IWACO, IWACO and Rust: hidden links revealed, which was a bit additional of a retrospective (no soundtrack for those, though). In any case, this turned out to be a awesome conference! Jack Huey presented on the Rust Vision Doc and, fairly to my surprise, Steve Klabnik and Dorian Scheidt presented “LLMs as Collaborators in Language Specification and Design”, talking concerning their procedure in construction out Rue. It was fun to see Steve again. On top of that, there was a ton of awesome investigation presented at IWACO in particular. I was particularly taken by the activity on Reachability Types and Information Borrowing. I additionally really liked learning concerning Hylo Lang, particularly their method to projections. Clever and cool.
Rust is famous in the agentic era
Rust is famous correct now. Very popular:
Stratospheric among the breakout languages is TypeScript, cropped from the diagram and sitting currently at +1200% growth from the previous year. [..]
The second most fast latest growth is in Rust. Meta engineers have written twice as much first-party Rust code so far this twelvemonth than in the former 9 years combined.
— David Tolnay (emphasis mine)
Some of that is since agents create it extremely uncomplicated to try out new things. And several of that is since Rust has a position for being performant and, if it’s fair as uncomplicated to choice any language, why not choice one that volition output faster implementation times?
But I think Rust is famous for another reason: since Rust happens to be a really fine fit for agentic coding6. Of course, I would, wouldn’t I? The item of this article is (1) to contend for why that is and afterward (2) to conversation what we power alter concerning Rust to create it activity equal better.
Foundational Software building alongside agents
It seems to me that an productive “software factory” volition have three pillars:
- Design: fig out and define plainly what the code is expected to do.
- Construction: author code that does what it is expected to do.
- Optimization: optimize the code so that it runs efficiently.
None of these pillars are solved, but several have made additional advancement than others.
Rust and optimization: accelerated by default, knobs whenever you need ’em
Rust is designed to provision “good achievement by default”, making the idiomatic item typically additionally be the fastest thing. But another key part of Rust is that you have the knobs to eke out improved achievement whenever you need it. You authority whenever item is stack- or heap-allocated and anywhere pointer indirection occurs. If you desire to, you can power the layout of your structs to be done in a particular way, or decide anywhere to current boxing into your async stack frames. In the limit, you can put in inline assembly.
In the past, learning how to “tune the achievement knobs” could be a bit of a dreary art: but agents are making that much easier.7 It turns out that agents are really good at fine-tuning the achievement of existing code. For example, group who activity on excellent high-performance cryptographic algorithms used to do so by hand-tuning gathering code. But those group inform me that they are now turning to agents for that identical job. More prosaicly, a lot of group construction network services are finding that, using a profiler akin dial9, agents can fairly efficiently diagnose async achievement pitfalls, akin lengthy polls or blocking.
Therefore, I think the project for Rust is clear. We keep on alongside our goal of “low-level adequate for a kernel, elevated flat adequate for a GUI”. If anything, I think the change about agents method we can tolerate a bit additional “noise” in the form of definitive calls to clone() or share() – but not too much, since we motionless desire the “happy path” of the code to be apparent and evident8, equal as we exterior particulars that are crucial in particular scenarios (like tracking exactly how many clones you have of a conduit endpoint). Combined alongside a profiler, you get an productive feedback iteration to get your code operating fast:
flowchart LR Code -- Benchmark --> Profile Profile -- Analyzed by --> Agent Agent -- Propose --> PR PR -- Improve --> Code
Reliability is king, as always
As customary though, during a position for fine achievement is what brings group to Rust, what makes them desire to stay is a awareness that using Rust “just seems to activity better”. The essential theory is that Rust’s category scheme and guardrails help keep agents on track:
rust is a ideal tongue for agents, stated that if it compiles it's ~correct
— Greg Brockman (@gdb) January 2, 2026
I think there’s fact in that: languages akin Rust, Ocaml, or Haskell all portion this “if it compiles, it works” feeling, and I think that agents volition advantage from that.
Testing is not enough, category systems help
Testing can display the existence of bugs, but not their absence.
— Edsger W. Dijkstra, 1970
Writing tests has never been adequate to display that your program is accurate – but, alongside agents, it’s not equal close. It happens so frequently that my archetypal few tests appear awesome and afterward the next one goes entirely bonkers. Usually bonkers in a way anywhere I cannot equal ideate how that bug could have arrive about. Then I dig in and I acknowledge the delegate entirely missed the container on the logic I was trying to express.9
This is anywhere a category systems really shines – particularly an advanced one akin Rust. Type systems provision you several guardrails that keep the delegate on track. In Rust, those guardrails broaden beyond uncomplicated material akin “do all sectors have the accurate names” and to material akin never having to near a socket.
Type systems are not adequate either
Type systems can display the deficiency of bugs, but not the existence of correctness.
— Me, failing to coin a expression of equal eloquence10, 2026
So yeah, category systems are helpful! But they have inherent limits. A category scheme is a uncomplicated set of rules that, if you prosecute them, create certain that you evade (certain kinds of) mistakes. But they don’t inform you that you do the right item – lone that you don’t do (certain kinds of) wrong things. If you desire to go further, you need a evidence system – item that volition let you display that richer properties are actively true, not fair that you’re avoiding bugs.
As it happens, there are a lot of engaging evidence tools for Rust, akin Verus, Creusot, Aeneas, and Kani. As a starting point, you can demonstrate that your code is panic-free, which volition eliminate a lot of bugs, although it is motionless basically a “type-checker-like” asset (i.e., you evade doing things wrong). But you can additionally go additional and add assertions that display your code is computing the results you expect.
Strong guardrails provision improved performance
Deplying proofs is not fair fine for getting code right – it’s fine for getting code fast. This is slightly counterintuitive, but it’s true. Earlier I mentioned how optimized cryptographic algorithms were now being written by agents. Part of what makes that imaginable is that cryptographic algorithms have a extremely apparent mathematical definition. This method that you can basically inform the delegate “do any you want, as lengthy as you can demonstrate that the code motionless computes the accurate result”. These proofs can be done alongside theorem provers akin Lean or Rocq. The blog article “Why Lean is faster than Rust” makes the item fairly well.
For Rust, a fine example of this would be about unsafe code. Right now, group are sometimes reluctant to deploy unsafe code equal if it power create their code faster since it’s not value the hazard of getting it wrong. And I applaud that effort. But what if you could use a prover to display that your unsafe code is, in fact, harmless (i.e., incapable of causing undefined behavior)? Then you’d be liberated to optimize to your heart’s content.
If we are going to demonstrate things, do we need category systems?
You power wonder: if we’re deploying a evidence scheme on our code, do we motionless need category systems? I think the answer is certainly yes. Type systems are infinitely simpler to activity with, which is why they are much additional popular. Using a category scheme lets you regulation out all kinds of annoying bugs so that you can concentration your “proof energy” lone on the crucial stuff.
As a uncomplicated example of this, regard the following Java code:
void setFoo(Bar bar) { this.foo = bar; assert this.foo == bar; }
Without seeing additional code, it is unattainable to demonstrate whether this assertion is true or not! This is since there could be any figure of another threads operating about mutating this. In contrast, the following Rust code must be true (at least, so lengthy as the Eq controller is reflexive for Bar):
fn set_foo(&mut self, bar: Bar) { self.foo = bar; assert_eq!(self.foo, bar); }
We cognize this since the type scheme of Rust guarantees that &mut oneself implies a unique reference.
This is in fact exactly how Verus works. By trusting the Rust get checker to track individuality etc, it simplifies the job of the SMT solver, making evidence checking must faster and additional dependable than it would be otherwise.
Where I think Rust should go on reliability
So my obtain is that Rust should twice downward on if it compiles, it works. As expressive as Rust’s category scheme is, there are plentifulness of things that it cannot capture. This includes fairly average things, akin this method lone says one particular field or internal references, but additionally fancy things akin “no logging of personally identifiable information”. We should activity to lift those limits, giving agents area to demonstrate additional complex properties.
We additionally need to enhance the cognition of integrating a evidence tool by operating towards an extensible compiler. As chill as the existing Rust-based evidence tools are, using them is a janky cognition involing annoying macros and pinned compiler versions. We can do better.
A north star: No additional unsafe code
I’d akin to propose a north celebrity for Rust: no additional unsafe code. By that, I don’t average that we never use the unsafe keyword. Rather, I average that we have the power to demonstrate that all the unsafe code we compose is accurate and cannot logic undefined behavior. Don’t get me wrong: knowing exactly what code needs to be vetted is a huge stage forward, as is normalizing the idea that libraries need to be liable for protecting their users from undefined behavior via harmless API boundaries11. But stated agents’ capability to discover vulnerabilities, I think we need to up-our-game if we desire to halt the dependable stream of CVEs.12
Design is an open problem
But before you go concerning proving things or optimizing them, you need to have a apparent idea of what you are building. As far as I can inform the province of the art current is basically variations on “markdown-driven-development”, evolving docs and expecting that agents pay attention.
I don’t cognize how much of a function for Rust there is in this space. I think there are several steps we power breeze up taking that could be helpful current – for example, having ways to distinct out interface from implementation so that it’s easier to assessment the interface in isolation or to see whenever the delegate made changes there.13 Or perchance fair providing betters tools to assessment that.
I additionally think there’s area for dedicated “modeling languages”, item that let you iterate quickly alongside agents on the high-level designs and invariants without having to enter the weeds and peruse the code. I have additional thoughts on this but it merits many blog posts all of its own. For the moment, I’ll resolve for pointing you all at this article by Kari Wilhelm, “Principles of Anchor Engineering”, which I think does a nice job of describing what it method to drag out the key elements of a scheme and run the coding from there.
Conclusion
We covered a lot of dirt here, so let me put this all together. What makes Rust a fine choice for evolving alongside agents?
- It offers fine default perf (why pay more?) and, in conjunction alongside a profiler, can be tuned as much as you want.
- The category scheme gives stronger guardrails, and if you setup your agents right, you can fortify those guardrails through techniques akin new types.
And what could create it better, from a tongue scheme perspective? Overall, I think it’s extremely akin to what we were doing, apart from that the way we importance the tradeoffs is tweaked to document for agents doing the code authoring, and humans focused additional on code comprehension:
- If it compiles, it works – our category scheme is our big advantage, we need to create it additional expressive and additional functional so that agents don’t get stuck trying to activity about it!
- And as an adjunct, established a North Star: Enable Unsafe code without unsafety by supporting proof, and see the most extensively used Rust libraries proven sound.
- Low-level adequate for a kernel, high-level adequate for a GUI – create certain we disclose the knobs needed to tune for performance, during additionally making the code’s intent apparent (but don’t concern concerning golfing the code downward to an complete minimum figure of characters).
- Extensible and versatile – one of Rust’s awesome strengths is that, alongside macros + our category system, we assistance DSLs and a broad assortment of targets. We need to bring that soul of extensibility into the compiler so we can mark additional styles of betterment (e.g., GPU, profound tongue interop, etc) and additionally merge theorem provers and another tools that necessitate additional than fair tokens.
As a final close, let me item you at this engaging part by Marc Brooker, “What’s uncomplicated now? What’s difficult now?”. He posits that the additional it is imaginable to plainly define achievement criteria for a task, the easier it is, and that we may discover that tasks we traditionally think of as ‘hard’ (e.g., construction out an productive implementation of a cryptographic algorithm) may shortly rotate into automated, whereas tasks that we have thoght of as ’easy’ (e.g., making a unique, compelling website) may rotate into additional valued.
Looking at it from a PL point-of-view, I think Marc’s item reinforces my awareness that the biggest act is going to arrive from design languages, things that let you grasp the architecture and intended behavior at a extremely high-level. The goal would be to let humans intuitively define a scheme that gets translated into productive guardrails, whether that’s category scheme checks, lints, or theorems to be proven. Agents would afterward obtain on the project of translating the scheme into code written in a traditional PL akin Rust, alongside humans looking at it lone rarely. This doesn’t create the scheme of traditional PLs small interesting, but it certainly makes the tradeoffs extremely distinct than they were before.
