$ cat choices/rust.md
the call
Safety and speed without a GC, and a compiler that catches what tests miss. It's what I reach for more and more lately when the work has to be both fast and correct, and I don't pull it out for a CRUD app.
Rust gives you C-level speed with no garbage collector and no segfaults. The borrow checker turns whole classes of memory and concurrency bugs into compile errors instead of 3am pages. The type system is strong enough that if it compiles, it’s usually right. That moves correctness left, out of the test suite and into the build, which is exactly where you want it for anything performance-or-safety-critical.
The compiler that catches your bugs also fights you the whole way. For a CRUD app or a script, that fight is pure cost. You’re paying borrow-checker tax to solve a problem you don’t have. Rust earns its place where speed and correctness both actually matter. If the work is IO-bound glue or a quick internal tool, reaching for Rust is résumé-driven development. Use Go for the heavy-IO case; reach for Rust when the correctness is as load-bearing as the speed.
My recent default for performance-and-correctness-critical work is Rust. han, a Claude Code plugin marketplace, is built on it. The pitch is simple: no GC to fight, and the borrow checker plus the type system catch whole classes of bugs at compile time that tests would otherwise have to chase. For a tool other people install and run, “it won’t compile if it’s wrong” beats a faster first draft.— see: open-source / han
Move the failure as early as you can afford to. A bug the compiler catches never reaches a test, a review, or a user, and the earlier you catch it, the cheaper it is. Most language choices are really a bet about where you want your problems to surface: at write-time, at test-time, or in production. Rust pulls that line as far left as any tool I’ve used. The judgment is knowing when that’s worth the friction and when it’s just friction.
the gaps — what it costs even when it’s right
The borrow checker is a real tax. You spend time satisfying the compiler that you’d spend writing features in another language. It pays off on the hot, correctness-critical paths and burns you everywhere else.
The learning curve is steep and the hiring pool is thinner. Ownership, lifetimes, and traits aren’t intuitions you pick up in a week. Every Rust service is now something the team has to staff and stay fluent in.
Compile times and ceremony slow the inner loop. The same strictness that kills runtime bugs makes prototyping sluggish. You feel it most when you’re trying to move fast and aren’t sure of the shape yet.
used at
open-source / han