Session 5: Facilitator Notes

Duration: 60 min · Deliverable: AI evaluation report covering correctness, maintainability, coverage, idiom

Before the session

• I've personally done the refactor with at least two different AI tools so I know the failure modes.
• I have screenshots of one bad AI output and one good AI output for slide 7 (live demo).
• I've confirmed students have access to at least one AI tool (Claude, Copilot, ChatGPT, Cursor). If a student doesn't, I set up a backup before the session.
• I've reviewed the starter prompts and rubric in starter/ and confirmed they reflect the team's current voice.
• I've read starter/active-comprehension-prompt.md and tried it myself, so I can speak to how it changes the AI's responses (more questions, stated assumptions, the quiz at the end).
• I have one personal story ready about offloading: a time I shipped or nearly shipped AI code I didn't understand, and what it cost.

Time budget

Block	Mins	Slides
1. AI tools + good prompting + cognitive offloading	10	1–6g
2. Live demo (good vs bad prompts)	5	7–8
3. Refactor with AI	15	9–11
4. Generate tests with AI	10	12–13
5. Code review against rubric	10	14–17
6. Group discussion	10	18–22

Block-by-block

Block 1. Three modes (autocomplete vs chat) → good prompting principles. The "treat it like a new contractor" line on slide 6 should land. Anchor with a personal example.

Then pivot to cognitive offloading (slides 6a–6g), the new spine of the session. Define it plainly: handing the thinking to the tool and not building the mental model yourself, which with AI is fast and invisible. Sell the stakes (slide 6c): typing was never the bottleneck, understanding is, and you cannot debug or extend what you never understood. Land the tell on slide 6d as a question they ask themselves all session: could I re-derive or explain this without the AI in front of me? Tell your offloading story here. Then frame the two mitigations: the system prompt (6e) is where you bake comprehension into every answer, the habits (6f) are what you do, and the active-comprehension loop (6g) is the three questions they will run in the activity. Point them at starter/active-comprehension-prompt.md and tell them to set it before block 3. This thread is additive: all the original prompting, refactor, test, and rubric content stays exactly as it was.

Block 2 (live demo, 5 min). Share screen. Run two prompts side by side on the same task: a bad prompt ("make this better") and a good one (with context, conventions, and a request for a diff). Show the difference in output quality. This is the most important 5 minutes of the session: students need to see what prompting well looks like.

Block 3 (refactor workshop). We do this together, live, students following in their own clones. First make sure their comprehension-preserving system prompt is set (handout Part 0). Then we paste reports.ts into the AI tool with the prompt template, apply the result, and run the existing tests. Tests will probably break on first try, that's the lesson. Push them to iterate on the prompt, not the code. Before we move on, hold them to the comprehension proof: name every helper the AI extracted and what it does without re-reading, or modify a helper by hand and keep tests green. This is the anti-offloading rep, not busywork. Watch for the student who applies and moves on without engaging: that is exactly the behavior we are training out. We fill the W5 logbook section together as we go (the prompt change, the iterations, the proof).

Block 4 (test generation workshop). Same pattern on auth.service.ts, done together, system prompt still on. AI tends to invent imports and miss edge cases. Have them capture failures specifically; we record that data in the W5 logbook section together as we go. Comprehension check: have them break one assertion on purpose and predict the failure before running it. A wrong prediction means they didn't understand the test, which is the point of catching it now rather than in an incident. The near-miss goes in the logbook too.

Block 5 (review). Slow the room down. Read one student's AI output as a group and grade it against the rubric live. Students will be too generous, push them on coverage and idiom specifically.

Block 6 (discussion). Around the room: where AI helped, and where blind acceptance would have bitten them. Ask directly for a moment from the comprehension checks where they thought they understood the code and didn't. Those near-misses are gold: they make the offloading risk concrete instead of abstract. Capture these comments verbatim in the W5 logbook section as we go, they're the input to the AI usage policy you write in Session 7 (which will likely include a comprehension rule, e.g. "no AI code merged unless the author can explain it").

Anticipated questions

"Which AI tool should I use?"

Whichever you'll keep using after the session. Pick the one your future job is most likely to standardize on.

"What if I don't have access to a paid tool?"

Free tier of Claude or ChatGPT is plenty for today. Copilot has a student tier.

"The AI's refactor passes my tests but it changed the behavior in a way the tests didn't catch, what now?"

That's the most important moment of the session. The tests are wrong, not the refactor. Add the missing test.

"Is it cheating to use AI on the final proposal?"

No, but disclose it. We're writing that disclosure policy in Session 7.

"If the AI's code works and passes tests, why do I need to understand it?"

Because the next person to touch it is you at 2am during an incident, and the tests only check what someone thought to check. Working code you can't explain is a liability you haven't noticed yet. That's the whole offloading point: use AI to go faster and keep the mental model.

"The system prompt makes the AI ask me a bunch of questions and it's slower."

That's the feature, not a bug. The friction is where the understanding gets built. If it's genuinely too much, tune the prompt down, but don't turn it off, that's the habit we're building.

If I run short

• Shorten block 4: do one test-gen pass together and the comprehension check, rather than the full suite. Don't push it to take-home; the point is doing it live.
• Combine blocks 5 and 6: review while discussing.
• Never cut block 2 (live demo). The prompting contrast is the whole lesson.
• Trim the offloading slides (6a–6g) to the definition (6b), the tell (6d), and the system prompt (6e) if pressed, but keep at least one comprehension proof in the workshop blocks. Setting the system prompt costs nothing and runs in the background, so it survives any time cut.

Post-session

In chat: "Everything we did today is in your W5 logbook section: your prompts, your comprehension-preserving system prompt, the near-misses, the grades. Keep your logbook: we reuse it in Workshop 6 and Workshop 8, and the policy notes feed Session 7. And keep that system prompt on after today: it's the cheapest habit you can build for not letting AI think for you."