How I review my classes with Claude Code

Claude Code doesn’t make my classes. It holds each one to rules I wrote before it produced a single slide, and it stops after every phase until I say yes.

This term I’m teaching two subjects at UNIR: AI applied to productive sectors, and a new introduction to programming and algorithms. The classes are online, and the students come from all over: mostly business, economics and law, but also teaching and engineering. Most of them run notebook cells; they don’t write them. Since September 7, 2026, the day before the term’s first session, every class I’ve prepared has gone through the same rules: seven sessions of one subject and the first of the other. Here’s how it works, and the rule I kept breaking.

The rules come first

It starts with a CLAUDE.md, the file Claude Code reads at the start of every session. Mine has nine fixed rules:

1. A theory ceiling: 15 or 25 minutes per two-hour session, depending on the subject.
2. A tool I mention gets opened on screen that day, or it stays off the slides.
3. Every student leaves with something they made: a dashboard, a chart, a prediction, a workflow that runs.
4. The 120 minutes add up. Sum the blocks and say so if they don’t.
5. Follow me on screen: environments ready beforehand, a checkpoint every 15 to 20 minutes, a simpler variant if the group falls behind.
6. Say it out loud: a prototype isn’t production.
7. No invented data. A figure is verifiable or it’s marked.
8. Real data, or synthetic calibrated against real benchmarks, and I say so.
9. Markdown, never .pptx, unless I ask.

Above them sits this line (translated from Spanish):

These rules take precedence over any other consideration, including something I ask for in the heat of the moment. If I ask for something that breaks them, warn me before doing it.

Each subject adds its own file on top. The new subject’s file suspends rule 2, since an introduction to programming names languages it never opens.

Rule 7 comes with marks: anything inferred gets a yellow one; anything no source backs, a red one and a “pending confirmation” placeholder, never a plausible number.

Four phases, one yes at a time

First, Claude Code reads the source material: the actual .pptx and .pdf, extracted to Markdown, never from memory. Then come four phases, and it doesn’t move on until I approve the one before. The file says why: it saves me throwing away content that’s already written.

Phase	File	What I sign off
1. Diagnosis	00-diagnostico.md	What stays, what gets trimmed, what gets replaced, my open questions. No content yet
2. Skeleton	01-esqueleto.md	Goal, student deliverable, blocks that add up to 120 minutes, tools, dataset, what gets cut first
3. Production	02-guion.md, 03-handson.md	Slide by slide, what’s on screen and what I say. The practical step by step
4. Audit	04-checklist.md	The quality gate, and what I must have ready and tested before class

The first diagnosis is dated September 7. My own deck from April, which it started from, had 61 slides and about 118 minutes of material, so the clock added up. What filled it didn’t: around 45 minutes of theory, nine tools named and two opened at most, nothing for students to make, and nine figures without a source. The skeleton came back once with my corrections (no pair work, the classes are online), listed in a table at the top of version 2.

What a quality gate looks like in a class

Before it hands me a session, Claude Code answers nine questions in writing. Is theory under the ceiling? Is a tool used on screen? Does every student make something? Is any tool mentioned and not used? Does anything repeat an earlier subject? Do the blocks add up to 120? Is there a checkpoint every 15 to 20 minutes? Is there a simpler variant and a time buffer? Is every unverifiable figure marked? If a box fails, it says so before delivering. It isn’t allowed to ship a failing session with a paragraph on why it’s fine.

The rule I kept breaking

The gate flagged theory time in every session of the sector subject. In six of the seven, theory ran between 44 and 64 minutes against a ceiling of 25. It said so in writing every time, and every time I went ahead. Two of those calls had a visible cost.

In session 1, I approved 44 minutes of theory, 26 of them a news block, in a deck of more than 90 slides, when the rules call 30 to 40 healthy for two hours. The debate on the news ate the class. The sector topic moved to session 2 and the practical became self-study. After that, the news block got a rule of its own: 8 to 10 minutes, with a clock on screen.

In session 3, I approved a half-hour news block anyway. Claude Code’s notes for that version wrote down what would fall off the end: a demo of building a Make workflow through MCP. It fell off, and the RAG part moved to the next session.

The gate doesn’t decide for me. It shows me the price before I pay it.

Why did I keep breaking it? Because the ceiling is sometimes too strict, and there were especially interesting and important things to tell. Because it depends a lot on the group: the previous edition wanted to see tools, and this one valued theory and business cases much more. And because MCPs make landing in any new tool much easier: going from 0% to 30% as a user of a tool is quick now, so knowing what a tool is for matters more than learning to use it at a low level.

Decks and notebooks come out of code

Rule 9 says Markdown, never .pptx, unless I ask. The checklist for session 1 still had building the PowerPoint as my job, estimated at most of the night. By the end of that evening the folder had a script that generated it, and every session since has had one.

It’s plain python-pptx: clone slides that already look right in the university template and rewrite their text, so the theme, fonts and logo survive. My April deck had speaker notes on 15 of its 61 slides. The final one had 92 slides, all with notes.

Part of the point of doing it in Python is threefold: iterating on how earlier years’ sessions went, checking automatically for any figure that might be wrong or have changed, and, most importantly, updating the materials, above all to the latest innovations and changes in the sector.

Things broke, and each break became a check. PowerPoint’s “repair” deleted the notes of 25 slides, the whole news block, the part I didn’t know by heart. The closing slide’s printed link and its QR code pointed to two different forms, and neither was the right one. Small scripts catch notes shared between slides, text below the usable area of the rendered PDF and paragraphs that lost their text, and QR codes get decoded from the file.

For the new subject, each session has one source: a Python file with every slide’s text, the speaker notes and what I’ll say. Running it checks character limits and that the minutes add up to 60. The build writes the deck and the slide-by-slide script from it, and nobody edits the script by hand, so they can’t drift apart. The code on the slides comes from the notebook’s generator.

The notebook isn’t edited by hand either. A checker runs every cell, with plain exec and again with IPython, and compares each output character by character with what the checkpoints promise. It even checks the figures I’ll say out loud: halving finds a number from 1 to 100 in 7 questions at most, and from 1 to a million in 20. Last run, September 29: 75 checks, 0 failures.

No invented data, in practice

For the logistics session, the material I was starting from had 27 “real examples” of companies using AI. Each one was checked against a primary source. Ten held up as written, seven were partly true, two were misattributed, seven had no trace, and one of the companies doesn’t exist. The ones that failed shared a pattern: a real company, an algorithm that sounds technical, a generic benefit.

I turned the check into a slide, because asking where the company actually says so is the habit I want students to leave with. It ended up hidden, to make room for the practical. That’s a rule too.

What stuck

Three weeks in, this is what I’d keep. Rules before content. No phase without my yes. Decks and notebooks built from code and checked by script. Every exception in writing, with its reason, before the class.

Claude Code still doesn’t make the class. I decide what a good one is, and I still break my own rules. The difference is that now I do it on purpose, and in writing.