“Rewritten in Rust” has become a three-word victory lap. Another CLI, another daemon, another piece of a browser. People call the migration oxidizing, which is cute until you remember how much of the stack underneath your apps is still C and C++ from an era when “ship it” beat “sanitize it.”
Rust is not new. So why does it feel like the default answer in 2026, and why am I meeting more developers who never loved the language on paper but shipped in it anyway, often with an AI chat open in the other window?
The old tradeoff, stated plainly
For a long time you picked a side.
C and C++ give you speed and control. They also give you memory bugs. Buffer overflows, programs trying to use memory they already threw away, races that only show up on a Tuesday under load. Big vendors have published numbers along the lines of “most of our worst security holes were memory safety in native code.” I treat those as directional, not as a quiz answer, but the direction matches what security teams have been tired of patching for decades.
Java, Python, Go with a runtime: safer day to day. A garbage collector cleans up after you. Fewer sharp edges. You pay with latency, memory, and sometimes that moment where cleanup wakes up at exactly the wrong time.
Rust’s pitch is annoyingly simple on a slide: fast like native, safe like something that refuses to compile stupidity. No garbage collector. Instead, the compiler checks who owns which piece of memory, and who is allowed to borrow it, before the program ever runs. If two threads would fight over the same data, or if you would free something twice, the build fails. You argue with the compiler before users argue with your crash logs.
That is the whole class of failures we normalized as the cost of doing business in systems software. Rust attacks the class, not one bug at a time.
Why the rewrites, not just greenfield
Nobody rewrites a working payroll system for sport. The wave is concentrated where pain is measured in emergency security advisories and midnight alerts: network services, parsers, browser engines, pieces of mobile and desktop OSes, CLI tools that run everywhere. Replace a critical C module with Rust, keep most of the performance, spend less of next year on emergency patches.
That is less “Rust won the beauty contest” and more “our threat model finally caught up with our codebase age.” Rust is a maintenance and liability bet. The meme is fun; the spreadsheet is boring and convincing.
Where AI walks in
Rust’s reputation for friendliness is fair. The borrow checker is a strict teacher. Historically, a Python person porting a scraper could lose a week to ownership errors before the first successful fetch.
I lived the other path. Scrapers in Python for years: fine on a laptop, painful when I wanted scale on weaker hardware. The logic was already settled: HTTP, HTML parsing, backoff, where to store rows, what to do when the site throttles you. I used AI as a translator into Rust, not as an architect. Same behavior, new runtime.
I measured it. On one small site I crawl often, about thirty-four pages: Python took roughly thirty-six seconds and peaked near two hundred fifty megabytes of RAM; Rust finished in about six seconds and peaked around thirty-four megabytes. Roughly six times faster wall-clock, about seven times less memory. Across sibling HTTP runs the speed band sat around six to eleven times. The win is real. The process was easy because the hard thinking had already happened in a language I could iterate in quickly.
If you handed a model the prompt “make a fast scraper in Rust” with no mental model of scraping, you would still be stuck when the website changes its layout, starts throttling your requests, or quietly blocks your IP. AI did not invent those problems. It just typed the part I already knew how to judge.
Syntax got cheaper. Judgment did not.
This is the argument I keep having with friends who feel obsolete watching vibecoded apps appear overnight.
A lot of syntax work is commoditized now. Boilerplate, API glue, idiomatic loops, even cross-language ports when the spec is clear. Models are trained on mountains of Rust that compiles. They are oddly good at satisfying the borrow checker when you give them a clear blueprint.
What did not get cheaper: knowing what to build and what to defer. Choosing data structures and failure modes before lines 1 through 500 exist. Debugging when the output is syntactically perfect and structurally wrong. Living through the 1-to-100 phase: migrations, traffic spikes, auth mistakes, observability gaps.
AI can dump five thousand lines in a minute. When it is wrong, it is rarely wrong with a typo. It is wrong with a plausible wire-up: a connection pool that leaks under concurrency, a retry policy that amplifies an outage, a security check that covers the happy path only. Finding that without scar tissue is hard.
So I do not think experience became worthless. I think the job description slid again, the same slide as when we stopped writing assembly for a living. Less author, more editor and director. Less “I memorized the standard library,” more “I can read this diff and tell you what will break in production.”
Junior developers feel the squeeze because the industry used to pay well for being a reliable syntax translator from ticket to pull request. That layer is thinning. Senior engineers who have seen three outages from the same mistake are not panicking. They are tired, because review surface area grew.
What I would still learn on purpose
Not every keyword in Rust. Enough to read what comes back: where ownership moves, where the model quietly copied a pile of memory just to silence an error, why a safety check was bypassed to force the build through, and who actually vouched for that bypass.
Then the skills that compound. System shape: where state lives, how a service protects itself when overwhelmed, what happens when an operation runs twice by accident. Domain depth: for me, scraping; for you, billing, logistics, whatever your users touch. Debugging as a craft: reproduce, isolate, instrument, fix the class not only the instance. Stack literacy: when Rust is worth the rewrite, when Go or plain old Python is the rational call.
Vibecoding is a great 0-to-1 machine. Production is mostly 1-to-100. AI fills the middle with text. Humans still own the context that text does not carry.
Rust is having a moment because it finally offers a credible off-ramp from a decades-long compromise: speed without treating memory bugs as weather. The rewrites are the boring security and ops story underneath the meme.
AI did not make Rust easy. It made Rust reachable when you already know what you are building. That is a different revolution, and it rhymes with Cup 12: we were always stacking abstractions so we could think at a higher level. The abstraction moved again. The need to know what you are doing did not.
I am curious where you land. If you have ported something with AI as the typist, what broke first: the language, or the assumptions you forgot to mention in the prompt?