You've probably learned some Rust this way: you hit a borrow checker error, paste it into a chatbot, get a clear explanation and a fixed version, paste that back, and the build goes green. It feels productive. A week later you hit the same error and you're back in the chat window.
The explanation was fine. What was missing is everything around it: an order to learn things in, someone who remembers what you got wrong last time, and a rule that says you write the code until it actually passes.
That's what I built rustcoach for. It's an AI coach (built on Claude) wrapped in a structure that a chat window doesn't have. This post walks through it with screenshots from a real lesson.
Start by finding out what you actually know
Before any lesson, you can take a free Rust skills test. You don't need an account.
- General test: 30 questions across all five areas, about ten minutes.
- Module test: 20 questions on one area: async, macros, concurrency or the type system.
Questions go from easiest to hardest, and most of them show real Rust code: what does this print, does this compile, which line panics. You see the right answer and the reasoning right after each one, so the test teaches while it measures.
The bank has 609 questions, and 446 of them include a Rust snippet. Each snippet carries a claim (it compiles, it fails with a specific error, it prints this output, or it panics), and a tool compiles and runs every snippet to check that claim. A question that says "this prints X" has actually been run and printed X.
At the end you get a level (Beginner, Intermediate, Advanced or Expert), a bar per area, your strongest and weakest topics, every question you missed with the correct answer, and a recommendation for which module to take. Here's mine after clicking through at random to get to the report quickly. It doesn't flatter you:
If you sign up afterwards, you can choose to share the result with the coach. That's off by default. If you turn it on, the coach plans your first lessons knowing which topics you got right and wrong.
Structure: a syllabus, in order
A chatbot waits for you to know what to ask. rustcoach gives you five courses, each with its own chapters, topics and progress:
| Module | Chapters | Topics |
|---|---|---|
| Core Rust | 16 | 50 |
| Async & Tokio | 12 | 51 |
| Macros | 11 | 50 |
| Concurrency & Atomics | 12 | 52 |
| Advanced Types & Traits | 11 | 50 |
Core Rust goes from bindings, ownership and borrowing through traits, lifetimes, iterators, smart pointers, threads, macros, unsafe and async. Each deep-dive module opens with a short Foundations chapter, and any topics you already covered in Core Rust start ticked off.
Every topic has a mastery score and the coach's own notes on how you did. It goes up when you get things right and down when you don't:
A lesson is written for you
There's no "lesson 7" that everyone gets. The coach reads its notes on you first, re-tests what went wrong last time, then teaches one idea with code you can run.
Every two or three explanations, it stops and checks that the idea landed: one question, a few options, one click.
The rail on the right keeps the context in view: the topic's mastery and the coach's note on you, review cards due, and this lesson's quick-check score.
Then you write the code. Until it's correct.
This is the part that makes the difference. Each lesson builds to an assignment: a real cargo crate with integration tests, written to fail on the starter code and pass on a correct solution. You code in the browser and the tests run with real cargo test in a locked-down sandbox (no network, capped memory and CPU, read-only filesystem).
In this lesson the assignment was a vending machine: restock must treat a zero count as a bug (assert!), and buy must treat "not enough money" as an expected failure (Err). Here are the starter's tests going red:
My first attempt didn't compile. Each rustc error is listed and its line tinted:
Explain with the coach turns the error into plain English: what is wrong, and what to try. It doesn't write the fix for you:
Stuck on what to reach for? Hints puts a coach note next to each function: the API to use and the trap to avoid, never the answer.
When it builds, every run also runs cargo clippy. Each lint shows up as a broom in the gutter, with the message, the help and a link. My solution passed all five tests and still got one:
Trace runs a function through one of its tests and shows the value of every variable, line by line. It's a debugger for people who don't have one set up yet:
The review: green tests aren't the end
When you submit, the coach reviews the code like a pull request: correctness first, then idioms, style and understanding. Clippy notes go to the coach too, and it teaches the idiom behind one of them.
Look at the second paragraph: "This is the second lesson in a row with this lint." It remembered. It also pointed out something I got right without being asked: each u32 subtraction sits on the branch where it can't underflow.
Accepted work can earn one optional stretch challenge, like making this version more idiomatic. So I tried the obvious thing:
It said no, explained why, and split the task into steps with examples on different data that you can't paste in. This is the core rule: the coach never writes your assignment's solution, not even when you ask or say you give up. You can ask as many questions as you want and get as many hints, explanations and examples as you need, but the code you submit is always yours.
Remembering, so it sticks
Writing the code once isn't enough. When a lesson is signed off, the coach writes two review cards per topic it covered. They come back after 1, 3, 7, 14, 30 and 60 days, and a wrong answer sends the card back to the start, so it returns tomorrow.
Every lesson stays in History, with the coach's summary of what it taught, how you did and what to revisit, plus the full transcript:
Any topic you've been taught can be redone. The redo pauses the running lesson and keeps your editor code, then returns you to it afterwards.
Small things developers will like
If you're coming from Python, JavaScript or Java, these are the details that make it feel like a dev tool rather than a course:
- The real toolchain. Your code goes through cargo test, cargo clippy and rustfmt. The errors and lints you see are the compiler's own, not simulated.
- Keyboard first. ⌘↵ runs tests, ⌘⇧F formats, ⌘⇧↵ submits, and ? lists every shortcut.
- scratch.rs. A throwaway binary crate next to the assignment for "wait, what does this actually do?" moments.
- Explain a selection. Select any code (or put the cursor in a function), hit Explain, and it goes to the coach as a question.
- Your weak spots, tracked. Every topic keeps a mastery score and the coach's notes, and the coach re-tests what you got wrong before teaching something new.
- Streaks and milestones. They're small, and they work.
What it costs
There's no subscription. A new account starts with 5 free credits, which last up to 5 lessons, and you don't need a card. After that, the Course is $49 once (before tax) for 50 credits. That covers a typical learner through one full module if you already program a bit in another language. Top-ups start at $10. The skills test is free and needs no account.
Try it
Test your Rust (free, no account): rustcoach.dev/test
Start learning: rustcoach.dev
Top comments (0)