One instruction, all the way down.
Follow a single line of a program as it falls through the metal — from something a compiler emitted to the electrons that actually carry it out. Each rung is a layer of the same machine, drawn as a cross-section you can read top to bottom.
The instruction
Software hands the CPU a stream of opcodes — the ISA. ADD, LOAD, JMP: the contract between everything above and the silicon below.
The core: fetch, decode, execute
The control unit pulls the next instruction, decodes what it means, and steers the right units to act. A pipeline keeps several instructions in flight at once so the silicon is never idle.
The ALU & registers
Arithmetic and logic happen here, on operands held in a handful of ultra-fast registers. Add, compare, shift, mask — the verbs every program eventually reduces to.
Memory, near to far
Registers are tiny and instant; RAM is vast and slow. Between them sit caches — L1, L2, L3 — each a bet that what you used last, you'll use again. Locality is the whole game.
The bus
Nothing moves without wires. Address, data and control lines shuttle bits between the core, memory and the outside world — the plumbing that turns separate parts into one machine.
Logic gates
Every operation above is built from a few primitives: AND, OR, NOT, XOR. Wire enough of them together and you get adders, memory cells, whole processors. Boolean algebra, made physical.
Transistors
A gate is just transistors — switches with no moving parts. A voltage on one terminal decides whether current flows across the others. Billions of them, each flipping billions of times a second.
Electrons
The floor. A "1" is a few thousand electrons pooled where a "0" has none. Everything you have ever run — every model, every kernel, every prompt — is this: charge, moving through silicon, on purpose.
Hardware isn't trivia. It's the reason everything above behaves the way it does.
Drawn, not listed
No wall of datasheet acronyms. Each part of the machine is a diagram first — you see where it sits and what flows through it before a word of explanation.
Continuous with the stack
This is the same cross-section that starts at a prompt. A cache miss up here explains a slow request up there — the layers are one machine, not five subjects.
Intuition you can reuse
Once you feel locality, pipelines and gates, performance stops being magic. You start predicting how code will behave because you can see what the metal has to do.
Novice to expert is a depth, not a checklist.
You read the die
The chip stops being a black rectangle. You can point at core, cache and bus and say what each one is for.
You reason about cost
You predict what a loop will do to the cache, why a branch stalls the pipeline, where the cycles actually go.
You think in gates
You meet a new architecture and immediately know where to look, because the path from electron to instruction is in your head.
Reach the bottom of the machine.
Start at the instruction and fall all the way to the electrons. Then climb back up — everything above will make more sense.
Begin the descent