After class, the most feared is not being tired but losing everything. The typed transcript no one wants to read again, the presentation remains the same as before, and good questions asked in class are hard to find when preparing for next time. This article breaks down my own "Post-Class Organizing Loop": how do I generate three different products from a batch of post-class materials using just six steps, and how do I review them at two levels? After reading this, you can create your own conveyor belt based on the process described here.
- They attend classes, give lectures, and lead workshops, leaving piles of notes and presentations at the end of each session, only to have them deteriorate over time.
- They want to use AI to help organize course content but are unsure how to set standards or verify that what the AI produces is usable.
- They possess a large amount of one-time materials (meetings, interviews, live streams), aiming to transform them into reusable knowledge assets.
- A six-step template: from storing original drafts to going live, each step's actions and deliverables.
- A routing strategy that turns one source into three deliverables, ready to apply to your own organizing workflow.
- The two-layer review method: which step uses the light one, which step upgrades to the heavy one, and how I keep myself from overselling it.
First, let's introduce a concept: One piece of material yields three different products
Many people believe that organizing after-class materials is just rearranging the script. In fact, for the same class session, I need to produce three different finished products:
- Teaching Manual: One for my own review and preparation for a future lesson.
- Post-Class Recording Briefing Version: Another for students' review purposes, filling in the on-the-spot content that was added during the class.
- Course Page on the Official Website: And an external one, converting live good questions into public content.
The key lies here: The same batch of materials can have three different exits from a single workflow, not by doing it three times separately. Once you understand this, each subsequent step makes more sense.
Trigger-based routing: different instructions lead to different scopes of work.
This is one of the most confusing and valuable points to teach about this Loop. When you feed in the same script, what I say determines how far it goes.
| What I say | How much it runs |
|---|---|
| "Enter the post-class organizing loop" | Runs all six steps, all the way to the course page on the website. |
| "Clean up the transcript / make the teaching manual" | Does only step 2 (cleanup) and stops at the teaching manual. |
In other words, when I say "organize the script," I'll only get a manual; when I say "post-class organization loop," I'll actually go all the way to the website. This is intentional scope definition that ensures I don't have to explain where we are at any point.
The first action before starting: First, inventory, don’t rush into action.
This step comes from blood and tears. Before diving into rewriting, I'll go through the course board and pull out all the existing content for this class: pre-class PowerPoint presentations, outline maps, pre-class survey results.
Six Steps, Break Down Gradually
The six steps below represent each segment of the conveyor belt. The first two steps transform written scripts into reusable materials, while the last three steps push these materials to an external website. The step labeled "2b" involves completing pre-class presentations into post-class versions.
Keep the original script as recorded and transcribed verbatim in its own folder for that class, with a date-time stamp in the filename. The only rule is: keep it unchanged, no additions allowed. It serves as the original evidence; all subsequent processed versions grow from it, so it must remain pristine, untouched by any alteration.
Organize the script into a structured lesson manual that retains my speaking tone. This is the most time-consuming and requires standardization step in the entire Loop. Three fixed sections are essential: 💬 Teacher's Speech, 📌 Key Points, 🙋 Student Questions. Include a complete list of student questions at the end.
If there was an on-the-spot presentation during this class (which is almost always the case), this step fills in content that wasn't included in the presentation. The method involves comparing the script with the presentation, adding "content spoken but not covered in the presentation" into a few projection cards for local updates. This preserves the original student connections.
Identify what from this class is worth sharing on the course page: good questions and answers asked during the live session, details that need to be supplemented, adjustments needed for the website's color scheme and font sizes for mobile compatibility. This step involves thinking through which parts to change before actually doing so; it’s about planning ahead rather than jumping in without a clear plan.
Once you're on the course page on the website, make sure to clean up all the necessary changes: the top brand navigation bar, the post-class Q&A section, and the color scheme and mobile layout. Make sure each of these areas is addressed; if any are missed, the page will look odd.
The last line of defense after customizing everything. After completing steps 1 through 4, by default this card should be placed in the website board for queueing (from Candidate to Layout in Review → Pending Deployment). Don't push it live yet; only when I explicitly say "deploy directly" or "deploy immediately" will it go live. Once deployed, you can’t take it back; adding an extra step of queuing gives you more opportunities for review.
How do I review it? Let's break it down into two layers.
This is where I want to explain the most clearly. People often ask me, "How do you ensure that what AI generates can be used?" This isn't something that can be explained in one sentence because I use two different levels of reviews applied at different stages. Let's separate them and avoid mixing them up.
Layer one: the review during cleanup (what the post-class loop actually runs)
For the step of cleaning up the transcript, my review works like this:
First, I don't clean it in the main conversation. Course transcripts always go to a separate sub-agent (by default a model like Opus, with no downgrade) to be cleaned; the main conversation only assigns the task, takes back the result, and moves on to the next step. Why move it to a separate, independent workspace? Because a transcript is long, and running it directly in the main conversation would crowd out the context I need for everything after it.
Second, once it comes back, I always re-check it independently. The sub-agent finishing doesn't mean it's done; I take its output and compare it against the original transcript, spot-checking two things:
- Have any signature lines been rewritten? The vivid metaphors and the lines with personality that I use in class must be kept exactly as they were, not "smoothed" by AI into formal written language.
- Has any paragraph been compressed too hard? Have details that should have stayed been cut?
The key to this layer is that "the original is still in hand and can be compared against at any time." That's exactly why step 1 has to save an untouched original first: it's the baseline for the re-check.
Layer two: the review for external deliverables (which cleanup doesn't actually run)
Separately, I have a heavier review mechanism that includes cross-family review (a draft written by one AI is reviewed by a different AI; self-review is not allowed), SSR reader self-review (simulating a target reader going through the article once, checking whether the title is compelling, whether the content flows, and whether it gives the reader something they can use right away), and a five-gate review pass.
The Three Design Approaches Behind This Loop
If you want to apply this set of steps in your own organizing process, what truly makes it valuable are these three approaches; they're more important than the six steps.
Keep one original draft version permanently unchanged, with a separate clean copy. This way, edited versions won't contaminate the original evidence, making it easier to verify later.
Think of materials as "a batch of content that is divided into different products based on different audiences," not just "producing one thing." The depth and tone required for self-use, training students, or public consumption are all different.
In the cleanup stage you can let the sub-agent run freely (if it botches something, the original is still there, so just redo it); in the go-live stage the default is to queue and wait for confirmation (because once it's out, you can't take it back). The force should be proportional to the risk.
Common Pitfalls (Used as Negative Examples)
- ❌ Forgetting to take inventory first: you run a whole round and only then notice the slides are still the pre-class version.
- ❌ Pasting the entire manual into the slides: slides need condensed cards, not the whole document dropped in.
- ❌ "Smoothing" my metaphors into formal written language during cleanup: tone and personality are the soul of the class; smooth them away and they're gone.
- ❌ Cleaning up only half of it and dropping the student questions: the good questions students ask are often the most valuable part.
- ❌ Auto-publishing not-yet-finalized content into the external version: anything not yet live must be confirmed first.
In one sentence
At its core, the Post-Class Organizing Loop is about taking "the live moment of a class" and turning it, in order and to a standard, into "a knowledge asset you can keep pulling out and reusing later."
It rests on three plain things: keep the original clean, split one batch of material into multiple outputs, and add more safeguards the further out it goes. Get those three right, and AI is just there to help you do it at scale.