A chat reply is one model call. A Porphy course is a pipeline of them, and the shape of that pipeline is most of why the output is different. Here is what runs, in order.
1. Finding out where you actually are
'Teach me thermodynamics' means something very different to a class-10 student and to a second-year engineering undergrad. So before anything is researched, a clarifier asks a few short questions — but it never asks you to rate yourself. Self-rating is noise: nobody actually knows whether they are 'intermediate' at organic chemistry. It asks about concrete things you can or can't do instead, and works out where to start from your answers.
A course that ignores your starting point is a textbook with extra steps.
2. Research, genuinely in parallel
A planner splits your topic into sub-questions, and five researchers search the web for them at the same time. Each returns findings with the sources they came from. This is the stage that separates a model half-remembering something from a course written out of what is actually published — which matters when your syllabus changed last year and the model's training data didn't.
3. A critic that sends work back
The synthesizer turns findings into an ordered roadmap, and then a critic reads it the way a reviewer reads a colleague's draft — checking the ordering, the coverage and the depth. Thin sections go back for another research pass, up to twice. Most of the quality difference between a first draft and what ships happens in this loop, and none of it is visible to you except as a line in the progress feed.
Why ordering matters more than prose
Almost nobody who gives up on a chapter hit a bad explanation. They hit a perfectly good explanation of step seven while they were still stuck on step three. That is the whole experience of sitting in a class that has moved on without you. Getting the order right is the highest-leverage thing a course generator does, which is why an entire stage exists just to check it.
4. One writer per part, all at once
The writing stage is a fan-out, not one long call: each part gets its own writer, and they all run simultaneously. Output tokens are the wall clock in a system like this, and decoding a seven-part course end to end sequentially was most of a run. Every writer gets the whole roadmap and is told which part is theirs, so the parts agree with each other without any of them seeing another's text.
- A single writer failing costs its part, not the run — the course ships with a note about what is missing.
- The findings are attached from a shared cache, so five writers do not re-send the same research.
- The sources section is assembled from the roadmap's own URLs, so no writer is in a position to invent one.
Every stage above is streamed to your screen as it runs, with what it is currently doing. Nothing sits behind an unexplained spinner.