Running it as a workshop

The material in this chapter is the same as in the eight steps before it. What changes is the situation: not alone at your own pace, but everyone at the same time in the same room, with somebody up front setting the tempo.

That has a consequence better admitted up front than discovered halfway through: in a guided session, not everyone types all eight steps themselves. The course is cut for two and a half hours of concentrated solo work; two hours with ten people is a different thing. Run all eight steps live and you get to step 05 and stop right before the moment the course exists for.

So the flow below re-cuts them. It gives the two steps that carry the insight their full time, runs the middle as a demo, and brings everyone back to the keyboard for the proof.

The flow (120 minutes)

Proven with six to twelve participants, one machine per person, a projector up front. The times are alarm clocks, not estimates - if you are not on the break by 0:55, cut the fast pass, not the proof.

0:00-0:10 · Arriving and the one rule. Explain zero magic: NumPy is allowed, torch, jax, tinygrad and autograd are not. Then check together, once, that the environment stands - python -c "import numpy; print(numpy.__version__)", the skill pack unpacked, Claude Code started inside the unpacked directory, /tinytorch called once. These ten minutes are well spent: a missing NumPy install that only surfaces at 0:20 costs that person the entire autograd part.

0:10-0:25 · Step 01, the tensor. Everyone types. /tt-01-tensor. This step is deliberately easy, it is the warm-up lap: an object holding a NumPy array that can do +, * and @. What matters here is not the insight but the rhythm - python -m pytest tests/test_01_tensor.py, green, move on. Once the rhythm is there, nobody has to learn it during step 02.

0:25-0:55 · Step 02, autograd. Everyone types. /tt-02-autograd. This is the core of the session, and at thirty minutes it gets a quarter of the total time. The sentence it is all about goes on the screen before anyone starts: differentiation is bookkeeping, not magic. Every tensor remembers which parents it came from and with which local derivative; backward() replays that chain in reverse and adds up. That is all there is.

The milestone is the moment the room tips over: the derivative of x² + x at 3 comes out as 7 without anyone having written down a derivative. Have the 7 said out loud. Anyone who produced it themselves stops believing black-box stories about deep learning from that point on.

0:55-1:05 · Break. A real ten minutes. The hard part is behind the group, the rest is building.

1:05-1:30 · Steps 03 to 07 as a fast pass. Goal demo up front. Nobody types along here. Up front you run the autonomous mode from the goal skill pack - /goal-03-schichten, /goal-04-loss, /goal-05-optimizer, /goal-06-trainingsschleife, /goal-07-dataloader - and narrate while the agent writes and pulls the tests green. Participants fetch the same chapters via goal onto their own machines, so everyone is on the same footing for the proof.

Five minutes per step, and one sentence per step that sticks:

• 03 layers - a network is a chain of simple parts, Sequential is a for loop over a list.
• 04 loss - learning means making one single number smaller. The whole prediction vector becomes a scalar, otherwise backward() would not know where to start.
• 05 optimizer - the learning step is one line: p.data -= lr * p.grad.
• 06 training loop - five lines, and they are the reason the whole thing works. Show this step more slowly than the others; it is the bridge to the closing picture.
• 07 data loader - training is half data plumbing. Permute, slice, hand out.

1:30-1:55 · Step 08, the proof. Everyone by themselves again. /tt-08-beweis. The dataset does not come from a library: two interlocking half moons are ten lines of NumPy, and zero magic applies to the data as well. Then train, then print the accuracy on the test split.

The moment the whole session runs towards is a number above 0.90 on data the network has never seen - computed from beginning to end with parts that came into being in this very room. Have the numbers read out around the room. They differ slightly for everyone and are above 90 percent for everyone, and it is that mixture that makes the moment.

1:55-2:00 · The closing picture. The essence below, on the screen, without code. Five minutes.

The 90-minute version

If you only have an hour and a half, you do not trim everywhere, you trim at the front:

• 0:00-0:08 Arriving, the rule, the environment. Step 01 is given away - the finished tensor.py sits in the directory you hand out, and you read it aloud in two minutes.
• 0:08-0:35 Step 02, autograd. Everyone types. Nothing gets cut here.
• 0:35-0:40 Short break.
• 0:40-1:00 Steps 03 to 07 as a goal demo, now four minutes per step.
• 1:00-1:25 Step 08, the proof. Everyone by themselves.
• 1:25-1:30 Closing picture.

What you should not trim is autograd or the proof. Without the first the insight is missing, without the second the evidence that it holds.

What participants need

Not much, but all of it - and checked before the session starts, not during it:

• Python 3.10 or newer and NumPy. Nothing else. No environment, no setup, no GPU.
• Claude Code, signed in and started once. Anyone without access can type the steps by hand from the chapter text, but that costs them a few minutes of lag every time.
• The coach skill pack from the course, unpacked, with Claude Code started inside the unpacked directory. It holds /tinytorch for the rules and the roadmap, /tt-01-tensor through /tt-08-beweis for the steps, the progress log PROGRESS.md and all eight milestone tests. The folder .claude/commands/ is already in the right place, there is nothing to set up. Both packs are on the course page to download - in the workshop the participants need the coach pack, and you additionally need the goal pack.
• One machine per person. Two people on one device works badly for this course: whoever only watches while the other types autograd does not get the moment.

What the facilitator prepares

Run the goal variant once, all the way through, in advance. One directory, /goal, once through all eight chapters, all tests green. It costs you an hour once and is the only preparation that really counts - afterwards you know how long the steps take on your machine, where the agent asks back, and what the result looks like when it is done. A demo you have seen once before, you can narrate; one you are running for the first time, you can only watch.

On top of that, in this order:

• Keep the completed goal directory as a lifeline. Anyone without a data loader at 1:30 gets the folder copied over and is there for the proof. Nobody should get stuck on the plumbing step and miss the ending.
• Have the gradient stumbling block (+= instead of =) ready as a note or a second slide - see above, held up only after ten minutes.
• Set the projector to a large font, and the terminal font as well. During the fast pass twelve people are reading along with what the agent writes.
• Put a clock where you can see it. The flow above only works if the break actually starts at 0:55.

Extension ideas

For a longer session, a second date, or as homework:

• A second dataset: spirals instead of moons. Two spiral arms twisted into each other, again in about ten lines of NumPy (r growing linearly, phi with an offset of pi for the second class). The task is considerably harder than the moons - with the same network and the same 60 epochs you will not get past 90 percent. That is exactly the lesson: more neurons, more epochs or a smaller step size, and you see for the first time what those dials are for.
• Momentum as a ninth part. SGD remembers nothing; momentum remembers the last direction per parameter and mixes it in. That is three lines in the optimizer and one extra field per parameter. Afterwards the word "optimizer" is no longer a black box but a family with a visible difference: the loss curve gets smoother and falls faster.
• The comparison run against real PyTorch. Same network, same data, same epochs - once in meintorch, once in fifteen lines of torch. Put the loss curves side by side, compare the run times. This is where the zero-magic rule ends on purpose: after building it yourself, importing is allowed. The curves lie almost on top of each other, the run times do not - and that gap holds the honest answer to what a framework is actually for.

The essence

You did not build a framework anyone is going to use in this session. You built one loop and saw that everything else is accessories.

The training loop goes: compute a prediction, measure the error, get the gradients, adjust the weights, start over. The agent loop goes: ask the model, call a tool, hand the result back, start over. The same figure, twice:

The progress is not hidden in one brilliant step but in the repetition of a very simple one, with state passed along between the rounds. "AI" is the swappable box inside a loop - not the loop itself.

Anyone who has typed the five lines from step 06 themselves reads the tools and loop building block like an old acquaintance. And anyone who runs the ant lab afterwards sees the same statement from the other side: there the loop stays put and the decision box gets swapped four times - hand-written code, a learning network, an LLM, an LLM with memory. Here the group built that box once from the inside.

Two courses, one sentence. Confirm it with your own hands in one afternoon and no AI hype will fool you again.