I've bounced off Rust every year since it came out. Fight the borrow checker, retreat to Go or TS. This year something clicked—not because Rust changed, but because I stopped needing to actively think about keeping the compiler happy.
If It Compiles, It Runs
Rust is pathologically explicit. Every lifetime, every ownership transfer, every error case spelled out. Used to feel like a burden.
Now it's the point. LLMs + strict compilers = code that actually works. If Rust compiles, you're almost certain it runs. No segfaults, no data races, no "works on my machine."
The only thing left to go wrong is logic errors. Memory bugs, null pointers, use-after-free, race conditions—gone. The compiler catches them all. What remains is whether your code does what you intended. That's the only class of bug that matters anymore.
Python/JS: looks right, passes tests, explodes in prod with some edge case you didn't think of. Rust: compile error or it works. LLMs are great at satisfying compilers—they've seen millions of errors and fixes. They handle the back-and-forth with rustc so you can focus on whether the code is actually correct.
The Library "Problem"
"Rust has no libraries" was valid. Now it's irrelevant.
Code is cheap. Web API doesn't have a Rust crate? Point Claude at its OpenAPI spec. Twenty minutes later you have a client library tailored to your exact needs. No bloat, no abandoned dependency with three stars.
The friction of writing bindings collapsed. The worst thing that can happen now is your code doesn't work (at a logic level), you're not going to have use after frees, out of bounds access or segfaults.
The Learning Curve Is a Mirage
Main reason people avoid Rust: lifetimes, borrowing, Pin<Box<dyn Future>>, all the incantations.
But I can read Rust and understand what it does. The logic is clear. What I struggle with vs TS/Go is the constant mental overhead of satisfying the compiler while I'm trying to think about the actual problem.
That overhead is exactly what LLMs eliminate.
Hard part of programming: thinking clearly, good abstractions, correct logic. The Rust-specific friction: satisfying the borrow checker. That's mechanical pattern-matching on errors. I understand borrowing and ownership—I understand it the same way I understand my code's logic. I just don't want to constantly context-switch between "what should this code do" and "how do I express this to rustc."
Understanding vs. Engaging
Let me be clear: I'm not saying LLMs replace genuine understanding. That's a recipe for disaster.
I wrote assembly in my teens to teach myself how CPUs work. I fundamentally understand what's happening at that level. But as a C programmer, I don't need to engage with assembly constantly. I know it's there. I roughly know the assembly that my C code will correspond to,* (side note, Ben Eater has an incredible video on YouTube where he line-by-line compares C code to assembly, it's worth a watch). *That knowledge informs how I write C. But I'm not hand-writing x86 for every function.
Same thing with Rust. I understand the borrow checker. I understand why 'a: 'b matters, why Arc<Mutex<T>> exists, why certain patterns are unsafe. That understanding informs how I think about my code. But I don't need to actively wrestle with the compiler's error messages while I'm trying to solve the actual problem. The LLM handles the ceremony. I stay focused on the logic.
This isn't ignorance. It's leverage.
Stupidly Fucking Performant
No GC pauses. No runtime. Tiny binaries. C-level performance with a type system that helps instead of hindering.
FFI is excellent—call C trivially, embed in Python with PyO3, first-class WASM. Perfect for the glue code that AI-assisted dev is increasingly about: CLI tools, API wrappers, system connectors.
The Ecosystem Grew Up
Yes, there was drama. Actix-web rage-quit, async runtime wars, rand versioning chaos.
That's calmed down. Async settled (Tokio won). Web frameworks are stable. CLI libs are excellent. Error handling patterns converged.
The language evolves conservatively now. You can start a project without worrying it'll be obsolete in six months.
Rust's Moment Is Now
Not when it topped "most loved" surveys. Not when AWS/Microsoft adopted it. Not when Linux accepted Rust code.
Rust's moment is when the learning curve—the main barrier—gets handled by AI that's really good at satisfying type systems.
I stopped bouncing off Rust. Not because I finally understood lifetimes. Because I stopped needing to.
