With agentic programming, (i) is a non-issue since LLMs have a very good grasp of the language, and it's no skin of your back, the agent is sweating it out with the compiler, not you, and (ii) is likely something you actually want.
I suspect it comes down to which other ecosystem you are coming from:
Python -> Rust: massive performance gains, type safety, much better concurrency
C++ -> Rust: much much better memory safety, much nicer compiler errors and warnings
Java -> Rust: better memory utilisation, non-null-able types (though I think recent Java versions facilitate this), better performance
But there are other language ecosystems where the gains become more subjective.
For eg. Golang -> Rust, I'd argue better "correctness", especially when concurrency is involved, but it's less pronounced than some of the other paths I mentioned above.
Tractable correctness is an underrated win at the scale of building enterprise solutions. But Rust also is a systems language, something that people had hoped from golang.
if code fails to compile, rustc will produce a very high quality error message 90% of the time (they can get pretty gnarly when you're doing something super tricky, but they're still very workable for agents). tests are a first class feature, so agents are able to spot check new features on the same turn you ask it to implement something new. documentation is also first class, and lots of libraries have excellent docs (read https://docs.rs/pyo3/0.30.1/pyo3/marker/struct.Python.html). the whole toolchain gives agents a lot to work with.
When that happens, please file a ticket. That's how the errors get good: we hear about when they aren't and then we fix them.
This is also true for humans! Rust/C/C++ are all about equally fast, but Rust is more productive for most people. The downside for humans is that Rust's learning curve is pretty steep, but that doesn't bother the LLMs.
Both C and C++ have a much steeper learning curve than many realize, just because the compilers let you get away with doing things that are fundamentally invalid (Undefined Behavior). Rust isn't actually much stricter, it just catches these problems at compile time.
Anyone capable of writing actually correct, standard-conforming C and C++ is mostly able to first-try the equivalent Rust code in almost all cases, because they are already thinking the same way that Rust requires you to think.
However, a significant portion of people who write both C and C++ don't realize that their code is full of UB - or worse, they don't care.
From a language perspective, the only new restriction in Rust compared to C++ is that mutable borrows (references) cannot overlap. Good C++ programmers are already avoiding this at all cost, because it's a mess to keep track of. When you actually do need it, Rust gives you the tools to build a safe abstraction.
* Very strong type system which helps catch bugs at compile time.
* The type system lets you enforce invariants, e.g. see the type state pattern and "make invalid states unrepresentable"
* The borrow checker encourages tree ownership which tends to be a less buggy structure than "anything can own anything" spaghetti you get in GC'd languages.
These give it an "if it compiles it works" character, that some other languages also have (e.g. Haskell), but most don't.
This was all well known before AI. I guess it's just more obvious to people that never tried Rust themselves.
It seems like the AI can really write safe types and fast, efficient code in rust that beats anything else.
I've moved basically all my projects over to it. And I don't really know how it compares to other fast languages. My personal langue preference was always for readable languages like Clojure or Ruby, but at this point I'm not reading any code and just want performance.