Learning Rust? I co-run a 6-week Python to Rust cohort where you build a performant JSON parser with PyO3 bindings.
I joined the vBrownBag podcast with Damian to talk about how to actually learn a new language or skill when an agent can write the code before you finish typing the prompt.
Keep the friction in #
The thread running through the whole conversation is friction. Agents are close to slot machines: a bit of dopamine, the path of least resistance, and suddenly you are delegating the thinking, not just the typing. The weeks where I hand off the most are the weeks I come out least happy with my own skills.
So I keep deliberate friction in the loop. I built coding platforms for Python and Rust with no AI in them, on purpose, so you still write the code in the browser without assistance.
When you are learning something, you have to go through the cycles at least once before you let an agent do it for you.
That is also why I can lean on agents more in Python (20 years of programming in, I can smell-test the output) than in a language I am still new to.
The litmus test is simple: how well do I understand the thing I am shipping?
AI to explain, not AI to do #
AI is remarkable at explaining a specific concept. It is dangerous as a crutch for deeper understanding. The distinction I keep drawing: use it to explain, not to do the work you signed up to learn.
We got into where the silent errors hide. Reviewed code can look completely plausible and still be only 70% right, because you never went deep enough to feel the wrong part (I also discussed this recently on complexity.fm).
On a recent project the app worked and returned good results, but it was silently never searching the second half of every chunk (see here).
That is the failure mode I see most with students shipping AI-built code, which is why I keep coming back to rubber-stamping AI PRs as the real risk.
Learn by building, with tests as the guide #
When people ask how to learn Rust (or anything) without losing ownership, the shape is always the same:
- Read enough to get the concepts (the first six to eight chapters of the Rust book, not all 600 pages).
- Pick a real project you have a stake in, then break it into digestible pieces.
- Write the tests first so you have a definition of done that guides each step.
- Contrast sources: read the reference in parallel, and compare answers across models.
In the Rust cohort we build a JSON parser this way: tokenizer first, then bindings with PyO3, then benchmarking. Several students beat the C parser on performance (see here and here).
This only happens because they owned every line instead of having an agent generate it.
Watch the full conversation:
The line I keep repeating: AI is an accelerator, not a compass. Start with your own thinking, then let it help, and keep a high enough bar that you never accept the first draft.
Keep reading #
The AI accelerator needs directionAI Doesn't Change What Software Engineering IsLearning Rust made me a better Python developer
Thanks Damian / vBrownBag for having me on. If you want to stay technical without outsourcing the thinking, that is exactly what we work on in the Rust and agentic AI cohorts.
Want Rust to click beyond syntax? Build a JSON parser from scratch, wire it into Python with PyO3, and benchmark it against CPython and other JSON libraries. Six weeks of practical Python to Rust engineering with weekly PR reviews and support by experienced Rust and Python engineers, not lectures. Join the next Python to Rust cohort →