How This Playbook Works

Most Rust material teaches the language and hopes you can build with it afterward. This playbook inverts that: you build first, and the language shows up exactly where the project demands it. By the end of Phase 1 you’ll have shipped four real programs and learned the Rust that powering them required — not a list of features, but the ones you actually reached for.

Who this is for

You can read Rust and write small things, but architecting a real project from scratch stalls you — which is the most common place to get stuck after the Book. We assume you know basic syntax (variables, functions, if/match, basic structs). We do not re-teach minigrep. We do slow down on the things that actually trip people up in real code: ownership across function boundaries, error handling that scales, lifetimes when the borrow checker pushes back, and concurrency.

The shape: 4 projects, 15 days, one runnable crate each

Project	Days	You build	The Rust it forces
logwise	1–3	a CLI log/CSV analyzer	ownership/borrowing, enums, Result/?, modules, tests
kvlite	4–7	a key-value store (mini-Redis)	traits, generics, lifetimes, iterators, custom errors, concurrency
apilite	8–11	an async REST API	async/tokio, axum, sqlx, middleware, tracing, Docker
askr	12–15	an AI CLI (Claude API)	HTTP/streaming, a tiny RAG, then production hardening

Each day is one chapter: it teaches the concept it needs, then has you build that day’s slice of the project, and ends with Check your understanding (with answers). Each project is a real crate in the companion code/ directory that compiles and runs.

How to actually use this

Don’t read passively. For each day: read the concept, then type the code yourself into the matching crate, run it, and deliberately break it to see the compiler’s error. The companion crate is the reference answer — reach for it when stuck, not before. Rust is learned in the feedback loop with the compiler, and that loop only runs if you’re typing.

The companion crates

Everything you build lives under code/ as a standalone crate:

   rust-playbook/
   ├─ src/content/docs/        ← these chapters
   └─ code/
      ├─ logwise/              ← Project 1   (cargo run -- ...)
      ├─ kvlite/               ← Project 2
      ├─ apilite/              ← Project 3
      └─ askr/                 ← Project 4

Each is independent: cd rust/logwise && cargo run. They share no build state, so you can work on any one in isolation.

What comes after Phase 1

Phase 2 (Days 16–30) builds three mini-blockchains from scratch — a Bitcoin-style UTXO+PoW chain, an Ethereum-style account model with a tiny VM, and a Solana-style parallel runtime with a Proof-of-History clock — each answering what problem did this chain actually solve?, and ending at a bridge into real Solana/Anchor development. Phase 1 gives you the Rust to build them.

The thread

What does building this force you to understand — and what is Rust’s compiler protecting you from? Hold that question on every page. Rust’s learning curve is mostly the compiler refusing things other languages allow — and almost every refusal is preventing a real bug (a dangling pointer, a data race, a forgotten error). Project-first learning makes those refusals concrete: you hit them while building something you care about, which is the only way they stick.

Start with The Rust Mindset →