--- title: Rust Is Winning the AI Code Generation Race description: 'Why Rust is becoming the go-to language for AI-generated code. Strong types, cargo conventions, LLM training data representation, and embeddability into Python and Node.js ecosystems make it a perfect fit.' date: 2026-02-07 tags: - rust - ai - code-generation - developer-experience --- I've been generating a lot of code with AI agents lately. Most of it in Rust, and nice about it is that it consistently better than what I get for other languages like Python and Typescript. Not marginally better. Noticeably better. One-shot implementations that actually work. Here is why I think Rust is probably winning the AI code generation race. ## Why Rust Works So Well for AI Generation ![Rust benefits for AI code generation](benefits.png) ### Clear Semantics and Structure Rust is a compiled language with strong type system, clear semantics, and well-defined structure. This alone makes it good candidate for code generation. Compiler catches a lot of issues that in dynamic languages would only show up at runtime. When AI generates Rust code, it gets immediate feedback from the compiler: "this is wrong, fix it." This tight feedback loop is super important for agents. But this is only the first reason. ### LLM Training Data Representation Second reason is probably more interesting, and this is more like an assumption. Rust is well-represented in LLM training data sets. There are many other languages that share characteristics with Rust: compiled, structured, strong types. But they are less represented in training data. This is why, at least from personal feel, I have much more chances to get a good one-shot implementation in Rust compared to other languages. AI just "knows" Rust better. ### Cargo and Standard Project Structure Rust has a first-class standard toolchain. There is `cargo`, there is well-defined project structure, well-defined dependency management, well-defined testing. This is super important for code generation because agent doesn't have to guess how to set up a project. Compare this with Python or Node.js. Yeah, they could be easily generated too. But Python has pip, poetry, conda, uv. Node.js has npm, yarn, pnpm, bun. Which one? What structure? Where do tests go? Every project is different. Rust has one way. `cargo init`, `src/main.rs`, `Cargo.toml`, `cargo test`. Done. Agent doesn't waste tokens figuring out project conventions. ### Type System Matters Technically, the closest competitor to Rust here would be Go. Go has good toolchain, good structure, good representation in training data. But Go's type system is simpler. Rust's type system gives AI more information to work with. More constraints mean fewer valid programs, which means AI has higher chance of generating the correct one. So why Go if you have Rust? ### No Hidden Magic This one is underrated. Rust doesn't support monkey-patching, dynamic imports, or runtime metaprogramming. Code works the way it looks. There are no strange side effects where something breaks because another module was imported later, or something silently adds magical functionality like SQLAlchemy does in Python. For AI code generation this matters a lot. When agent generates Rust code, it can reason about what the code does just by reading it. No need to track down what got patched at runtime, what decorator rewired the behavior, or what import order dependency exists somewhere. Macros are the exception here, but even macros are explicit and expanded at compile time, not at runtime. In dynamic languages, agent has to essentially guess the full runtime context. In Rust, what you see is what you get. ## The Libraries Problem (That Isn't Really a Problem) There is one obvious concern: Rust has fewer libraries than Python or Node.js. At least for use cases I am working on, this is true. Ecosystem is smaller. But here is interesting observation. If something is missing in Rust, you don't actually need a library for it. You can just generate one. For example, I stopped using third-party libraries for API calls. I basically ask my coding agent to generate a client library specifically for the APIs I need. Custom client, exactly the types I need, no unnecessary abstractions. Works great. And honestly, libraries are popping up in Rust ecosystem every single day. With this rise of AI code generation, the pace is accelerating. From my point of view, libraries are not a problem at all anymore. ## The Real Problem: Compilation Time This is a problem. And I won't sugarcoat it. Rust compilation is slow. There are some solutions floating around. Faster linkers like [mold](https://github.com/rui314/mold) and [lld](https://blog.rust-lang.org/2025/09/01/rust-lld-on-1.90.0-stable/). Compiler caching with sccache. Experimental Cranelift backend. The new [Wild linker](https://github.com/davidlattimore/wild) written in Rust itself. But effectively there is no perfect solution. For the moment, I would suggest just accepting it. What I personally do is use layered Docker images. In [Everruns](https://everruns.com), I have multiple services, and all of these Docker images share base libraries. I have first Docker image layer that pre-builds all shared dependencies, and then each service-specific image only compiles its own code on top. It sort of works. Still feels like a hack, but it effectively does the job. ## People Already Chose Rust for AI-Generated Code This is not just my observation. Look at what's happening: - **Claude's C Compiler** - Anthropic ran 16 parallel Claude agents that generated [~100,000 lines of Rust](https://www.anthropic.com/engineering/building-c-compiler). A full C compiler. From scratch. It compiles Linux kernel, PostgreSQL, Redis, FFmpeg. All code written by AI in Rust. - **Cursor's FastRender** - Cursor attempted to generate a [web browser in Rust](https://x.com/mntruell/status/2011562190286045552) using hundreds of AI agents. 3M+ lines of Rust code claimed. The result was controversial (it never cleanly compiled), but the choice of Rust is telling. - **Vjeux's Pokemon Port** - Christopher Chedeau [ported 100,000 lines of TypeScript to Rust](https://blog.vjeux.com/2026/analysis/porting-100k-lines-from-typescript-to-rust-using-claude-code-in-a-month.html) using Claude Code in about 4 weeks. He had never written Rust before. 0.003% divergence from original across 2.4 million test seeds. - **Everruns** - We use Rust for [Bashkit](https://github.com/pipelight-dev/bashkit) (bash implementation) and [Monty](https://github.com/pipelight-dev/monty). In-memory implementations, super compact, AI-generated. Pattern is clear. When people need reliable, performant AI-generated code, they pick Rust. ## The Embeddability Story Here is the fun part. Rust is super embeddable. If you build a library in Rust and want to use it in Python or Node.js ecosystems, this is very nice to do. For Python, there is [PyO3](https://pyo3.rs/). You write your library in Rust, add PyO3 bindings, and you get a Python package that feels completely native. Your Python users don't even know it's Rust under the hood. Same story for Node.js with [napi-rs](https://napi.rs/). You build a native Node.js package that feels native. No difference from user perspective. The only caveat: you need to pre-build binaries. Your Python or Node.js users will not have Rust toolchain on their computers. If you just package your library as-is, it will require Rust compilation during installation. Your users will hate it. But there is a solution. Just compile binaries for major platforms and distribute them. This is exactly what OpenAI does with [tiktoken](https://github.com/openai/tiktoken). It's written in Rust, uses PyO3 for Python bindings, ships pre-built wheels. Users install it with `pip install tiktoken` and never think about Rust. Same approach with [SWC](https://swc.rs/) for Node.js via napi-rs. Used by Next.js, Parcel, Deno. So Rust becomes a universal backend language. Write once in Rust, distribute to every ecosystem. ## Writing vs Reading Rust Here is my personal feel. Rust is not the best language to _write_. You need to know about borrowing, lifetimes, memory management. It mentally adds noise that you don't have in Python or Node.js. But Rust is super easy to _read_. Simple syntax, clear structure, explicit types, no hidden magic. When you open Rust code, you understand what's happening. And here is the thing: in this new reality where AI agents write most of the code, readability matters more than writability. I mostly read code now, not write it. Even if you don't know Rust well, you can use it for your projects. AI agents will write it for you. They know about borrowing and lifetimes and all the stuff. You just read and review. Kind of changes the equation, doesn't it? ## "It Compiles, So It Works" There is this idea in Rust community that once your code compiles, it works. This is sort of true. Rust compiler catches a huge class of bugs that would slip through in other languages. But it's important to be honest here: compilation doesn't guarantee that your code will definitely work. You can still have logical issues, network errors, wrong business logic. Compiler doesn't know your business requirements. So when you generate code in Rust, you still have to think about testing, continuous integration, proper validation. Software engineering basics don't disappear just because Rust compiler is strict. The good news: your AI coding agent can set up CI for you too :) ## Where This Is Going I'm not going to say everything will be written in Rust eventually. That would be a joke. But kind of... not entirely a joke? With AI agents getting better at code generation, the writability problem of Rust disappears. The readability advantage remains. The type safety advantage remains. The performance advantage remains. The embeddability into other ecosystems remains. Good moment to start. ![Rust Is Winning the AI Code Generation Race](footer.png)