One company hired 20–25 high school graduates with zero systems programming background and turned them into working Rust developers using LLMs as the learning crutch. That claim alone should make every engineering leader rethink who can become a Rust dev.
Clone Guilt Is Real and Unaddressed
Every experienced Rust developer interviewed for the Vision Doc gave the same piece of advice: clone freely while learning, then optimize later. Yet newcomers consistently set the bar at zero clones, zero copies, threading lifetimes through everything before they've written a first working program. A university researcher described carefully weaving lifetimes into a struct, getting stuck, then watching someone else clone the same struct—it was cheap and it worked. The advice exists only in tribal knowledge, not in official materials. Putting "clone freely while you're learning" into The Rust Programming Language or Rustlings would save months of frustration.
The Compiler Already Teaches Better Than the Docs
Several interviewees said Rust's diagnostics taught them lifetimes before any book or tutorial did. One senior software engineer put it bluntly: "Whatever's missing, the compiler usually fills in." The compiler reaches learners at the exact moment they're stuck. When writing new diagnostics, the Rust project should keep the confused newcomer in mind alongside the expert, because for many people that is where learning actually happens.
Silent Attrition: Community Vibes Turn People Away
We heard second-hand stories of a friend who walked away from embedded Rust because he couldn't just grab a raw pointer to a peripheral, and of learners told their struggles were a "skill issue." One researcher reported that senior engineers struggle more than beginners because they have more patterns to unlearn. The welcoming side of the community—students getting answers on GitHub from maintainers—came up unprompted as a reason people stayed. Every "skill issue" comment pushes someone out, and because they leave quietly, the Rust project has no way to measure how many.
LLMs: Shortcut or Crutch?
The Vision Doc found multiple uses for LLMs in learning: example generation, research, and in one case the tool that lets a consultancy train high school graduates into Rust developers in a few months. But a university professor observed that when students worked on an embedded project, the C cohort leaned on LLMs to generate entire projects, while the Rust cohort couldn't—they had to engage with the code directly. No clear explanation yet, but it suggests LLMs may smooth over the surface without building the mental model needed for Rust's ownership rules.
What's Worth Trying Now
The Rust team recommends three concrete actions: create learning materials that explicitly name patterns from C++/Java that won't transfer (like reading a trait as an interface), put the "clone freely" advice somewhere official, and triage the perception that The Rust Programming Language is out of date by cleaning up visible issues and PRs in its repository. Teams adopting Rust don't need to invent a training program—ramp-up across every organization interviewed looked the same: a shared baseline course, low-risk tickets, and an internal Slack channel for questions.
Who bounces off Rust and why remains the biggest blind spot. The Vision Doc team never reached people who gave up, only those who stuck around long enough to be interviewed through Rust channels. Making that missing cohort the target of the next user research project would tell us more than any survey of existing Rustaceans ever could.
Source: The many journeys of learning Rust
Domain: blog.rust-lang.org
Comments load interactively on the live page.