Lesson 9 — How the source-reading courses work

Question

Finishing Bridge to Advanced = ready for the three Intermediate courses (Inside Revm / Inside Reth / Inside Alloy). How do those courses work? Editorial style / quiz gates / buildup → walkthrough → quiz → drill chain structure + pacing.

Principle (minimum model)

• Three Intermediate courses. Inside Revm (EVM execution engine) / Inside Reth (Staged Sync + ExEx + SDK) / Inside Alloy (Provider + Network + Signer). Take in any order; the recommended order is Alloy → Revm → Reth.
• Chain structure. Each topic = buildup (naive version → real version, in steps) → walkthrough (real source line-by-line) → quiz (progress gate) → drill (hands-on proof you did the work).
• Predict prompts + quiz gates. "Stop here and predict" appears throughout. Quizzes gate progress — get 2+ wrong → re-read the previous lesson. The structure forces you out of "I read it and nodded" mode.
• Pacing. 30–40 minutes per lesson. Realistic: 1–2 lessons + a drill per day; weekend Capstones take half a day.
• Setup is mandatory. git clone bluealloy/revm / git clone paradigmxyz/reth / cargo install cargo-expand / second monitor or split terminal. Without these, drills cannot be done.
• Reading mental model. Read trait headers first → main struct → function bodies. grep / rg for related sites. cargo doc --open for API docs.
• When you get stuck. Mark the unclear part, keep reading, return later. Ask on Discord / GitHub. Spend 30 minutes on your own before looking at the answer.
• After completion. Advanced / Expert for production engineering. Foundry for the Solidity side. openhl DIY Perp for building one full thing. Many directions open up.

Worked example + steps

How the source-reading courses work

You're at the doorstep of the Intermediate tier — three independent courses (Inside Revm, Inside Reth, Inside Alloy) that all teach the same skill: reading production Rust source line by line. This short lesson explains how those courses are structured, so you can engage with the right mindset from lesson 1 — whichever course you start with.

(Each course also has its own short welcome handling course-specific prereqs and setup. This lesson is the generic orientation, applied once.)

The tier shift

The Beginner tier (Beginner + Fundamentals + Bridge to Intermediate) taught you the shape of the stack — what Alloy types look like, how to use Foundry, what the EVM does at a high level.

The Intermediate tier asks something different. You will read the actual production source of Reth, Revm, Alloy, and Foundry, line by line. The lessons assume you can already use the stack — they teach you to read it.

The previous lesson confirmed the technical prereqs landed (you can read the add opcode signature). What's left is how the lessons themselves are written, and the rhythm they expect from you.

The editorial style — and why

Source-reading lessons use active-learning prompts that you don't see in earlier tiers:

• 🛑 Predict — Stop. Before reading the explanation, answer this in your head. The point is to engage with the question, even if you're wrong. Wrong predictions are where the learning happens.
• 🔍 Find in repo — Open the actual source file and verify the lesson's claim. The lesson is guidance; the source is truth.
• Anti-fluency checks — In your own words, why does this work? If you can't answer, the lesson explicitly tells you to scroll back. Don't skip these.
• End-of-lesson recall tests — Most lessons close with "the lesson isn't done with you until you can answer X." Take that literally.
• Quiz gates — Every major topic ends with a 4-question quiz that gates progression. You can't nod past a quiz — that's the design. Miss two and the build-up didn't internalize; scroll back.

The editorial style is harder than tutorials you've read. It's deliberately so. Smooth tutorial prose creates a "illusion of understanding" trap — readers nod through complex material and walk away with shallow comprehension. The Predict / Recall / Quiz pattern forces actual engagement.

This is friction by design. Lean into it.

How to read these lessons

Each major source-reading topic — add, custom opcodes, the Database trait, Staged Sync, ExEx, the Reth SDK, the Provider trait — is split into a chain of 3-4 atomic lessons:

1. Build-up lesson — start from the dumbest version of the code you could write, then earn each piece of complexity step by step. By the end, you've built every line of the real production source from a motivated starting point. Predict prompts at each step.
2. Walkthrough / pipeline / companions lesson (some chains have one) — read the surrounding production code in detail, with predict and find-in-repo prompts.
3. Quiz — 4-5 multiple-choice questions that gate progression. Pass to continue; miss too many and you scroll back.
4. Drill — hands-on exercise in a real checkout (cargo build, modify the source, observe behavior). The drill is what makes the lesson stick a day later.

Within any individual lesson, the rhythm is:

1. Hit a 🛑 Predict prompt before the explanation. Stop. Answer in your head or on paper. Then continue.
2. Read the walkthrough. Compare to your prediction. Where you were wrong is where the learning happens.
3. Hit a 🔍 Find-in-repo prompt. Open the repo. Find the actual file. Verify the lesson's claim.
4. End-of-lesson recall test. Close the tab if you can answer in your own words. If not, scroll back.

This is slower than typical tutorials. It also internalizes. The trade is intentional.

Pacing

Each atomic lesson is 8-12 minutes stated, ~15-25 minutes with the prompts actually engaged. A full topic chain (build-up → walkthrough → quiz → drill, 3-4 lessons) is roughly 45-80 minutes — one solid evening's work. Advanced tier chains (the L1 Architect courses, after Intermediate) go longer — 1.5–3 hours per session is typical, because that's the length real L1 architect work demands.

The right unit is one chain per session. Plan to start a chain (say, the four add lessons in Inside Revm) and finish it. The build-up, walkthrough, and quiz reinforce each other, and the drill is where doing-not-reading turns the chain into memory. Splitting a chain across days — half the build-up tonight, the rest plus drill next week — breaks the model.

If you're short on time: do one lesson well rather than skim two. Engagement matters more than coverage at this tier.

Now go pick a course

The three source-reading courses are independent and can be taken in any order — though Inside Revm is the recommended first stop since its types (Address, U256, Database trait) underpin Reth and Alloy:

• Inside Revm — Inside the EVM engine
• Inside Reth — Inside Reth: Staged Sync, ExEx, the Reth SDK
• Inside Alloy — Inside Alloy: Provider, Network, Signer

Each course has a brief welcome that handles course-specific prereqs and setup. Read that and start lesson 1.

Beyond Intermediate — the Advanced tier (L1 Architect)

After the Intermediate source-reading courses, the Advanced tier waits (5 courses, ADVANCED difficulty, track reth-l1-architect). Intermediate teaches you to read production source. The Advanced tier teaches you to design an L1 — the implementation skills behind architecting Hyperliquid- or Tempo-class chains.

• Consensus Engineering — PoS / BFT / Tendermint internals; the latency / liveness / finality trade-offs of consensus design
• Cross-Chain Bridges — read CCIP, the OP Standard Bridge, and light clients in real source; then build your own
• Sequencer & Rollup Architecture — centralized sequencers to shared sequencers; MEV defense and forced inclusion
• P2P Networking Internals — devp2p, libp2p, gossip subprotocols, and peer scoring at the implementation level
• Validator Operations — key management, slashing conditions, coordinated upgrades

Each chain runs 1.5–3× the length of an Intermediate source-reading chain. Don't worry about it now — finish a single source-reading chain first. Keep the Advanced tier as a distant destination on the map and nothing more.

You're ready.

Summary (3 lines)

• Three Intermediate courses (Revm / Reth / Alloy), each as buildup → walkthrough → quiz → drill. Predict prompts + quiz gates prevent passive reading.
• Setup is mandatory (revm + reth clones + cargo-expand + two screens). Pacing: 1–2 lessons + drill per day; weekend Capstones half a day.
• After completion: Advanced + Expert + Foundry + openhl DIY Perp. Bridge to Advanced complete; the source-reading toolkit is ready.