High school only. Middle school is a single 85-minute session — Session 1 — and ends there.
Session 1 taught the loop. Session 2 makes them good at it: how much to specify, how to say it, and how to actually verify what came back.
Campers also pitch and start the capstone in this session. The capstone build lives in Sessions 2–3, because Session 4 is only 60 minutes and is demo-and-wrap-up only.
If new campers joined today: run the 6-minute dice roller demo from Session 1 and give them the four-question prompt template. They’ll keep up.
| Time | Block | Mode |
|---|---|---|
| 0:00–0:10 | Warm-up: same prompt, four ways | Whole group |
| 0:10–0:30 | How much to ask for at once | Talk + demo |
| 0:30–0:55 | Prompt lab: rewrite bad prompts | Pairs |
| 0:55–1:05 | Break | |
| 1:05–1:30 | How to check the AI’s work | Talk + demo |
| 1:30–2:05 | Build: spec-first practice project | Independent |
| 2:05–2:20 | Swap and break | Pairs |
| 2:20–2:40 | Capstone pitch + scope check | Pairs → instructor |
| 2:40–3:00 | Capstone: plan and first build | Independent |
On the projector, four prompts for the same app. Ask which one they’d write, then ask which one they’d want to have written.
A: make a study timer
B: make a pomodoro timer in python
C: Build a Pomodoro timer in Python with tkinter. 25-minute countdown,
big digits, Start/Pause/Reset buttons. Beep when it hits zero.
Save as pomodoro.py
D: Build a Pomodoro timer in Python with tkinter using a class-based
architecture. Use threading.Timer for the countdown, not time.sleep.
Store state in an enum. The label should use a monospace font at
size 48 with grid geometry, and buttons should be in a frame below
using pack. Handle the beep with winsound.Beep at 1000Hz. Include
type hints and docstrings on every method. Save as pomodoro.py
Most will pick C, which is right. Then push:
threading.Timer is the wrong call, that’s on you. And you
spent five minutes writing a prompt to save two minutes of work.Specify what you care about. Let the AI decide the rest.
That’s the whole lesson. The trick is knowing what you care about.
Then ask when D would actually be right. (Answer: when you have a real constraint — matching existing code, a library requirement, a teacher’s rubric.)
Mode 1: Starting from nothing → describe the whole thing.
You want the AI to build a complete, coherent first version. It should know the shape of the finished app so the pieces fit together. Ask for the whole thing.
Mode 2: Changing something that exists → one thing at a time.
Now the code exists and works. Every change risks breaking it. Ask for one, run it, and only then ask for the next.
Draw this on the board:
Ask for 5 changes → run it → it's broken
↓
which of the 5 broke it?
could be any. could be two interacting.
you're now debugging blind.
Ask for 1 change → run it → it's broken
↓
it's that one. obviously.
undo it or fix it. 30 seconds.
“Testing one change at a time isn’t about being careful. It’s about being fast. Every batch of changes you don’t test is a debugging session you’re saving up for later, with interest.”
Can you describe what should be different after this change in one sentence?
Yes → good size. No → break it up.
| Too big | Right size |
|---|---|
| “Add multiplayer” | “Add a second score counter labeled Player 2” |
| “Make it look better” | “Make the background dark gray and the text white” |
| “Add saving” | “When I click Save, write the current list to tasks.txt” |
Sometimes changes genuinely come as a set — if you’re adding a second player you need a score and a turn indicator and a way to switch. Fine. Ask for the set, but say so explicitly, and expect to spend more time checking:
Add two-player mode. That means: a second score counter, a label showing whose turn it is, and turns alternating after each roll. Those three things only.
Naming the pieces yourself gives you a checklist to verify against.
Live demo. Open a working app, ask for six things at once, run it. Even if it works, ask “which part would you check first? How long would checking all six take?” Then do one of the six properly in 90 seconds.
Pairs. Bad prompts on a handout. For each: say what’s missing, then rewrite it.
1. "make a game"
2. "build a website for my club"
3. "the colors are ugly, fix them"
4. "make a program that tracks stuff for my basketball team"
5. "add a leaderboard, dark mode, sound, and a tutorial screen"
6. "make it work on my phone"
Answer sketches for the instructor:
Then: each pair writes a real first prompt for the app they’ll build next and trades with another pair. The other pair’s job is to find the ambiguity — anywhere the AI could reasonably guess wrong.
“If your partner can find two ways to read your prompt, so can the AI.”
Ten minutes. Take it here — the next block is the densest in the session.
The heart of the whole track. Session 1 planted the idea; today it becomes a method.
Four levels of “checked,” weakest to strongest:
| Level | What you did | What it proves |
|---|---|---|
| 0 | It generated without an error | Nothing |
| 1 | It ran without crashing | The syntax is valid |
| 2 | You used it and it looked right | It works for the happy path |
| 3 | You tried to break it and couldn’t | It probably holds up |
| 4 | You read the code and it does what you asked | You actually know |
“Most people stop at level 1 and think they’re at level 4. That gap is where every disaster lives.”
1. Does it do the thing? Use it the way it’s meant to be used. Does it produce the right answer? Not “an answer” — the right one. If it’s a calculator, do the math yourself and compare.
2. Does it survive the wrong thing? Empty input. Text where a number goes. A negative number. Clicking twice fast. Zero items. A thousand items. This is where AI-written code fails most often, because the AI optimizes for the case you described.
3. Did it change anything you didn’t ask for? Ask the AI directly: “What did you change? List it.” Then check the list against what you asked for. This is a real failure mode — you ask for a color change and it also “helpfully” rewrites your scoring logic.
4. Can you explain it? Point at a chunk of the code and ask: what does this do? If you can’t say, ask the AI — “Explain what the function on line 40 does, like I’m 12.” It’s very good at this, and this is the single fastest way to actually learn to code while vibe coding.
Useful prompts to hand them:
What could go wrong with this? What inputs would break it?
What did you just change? List every change.
Explain what this does in plain English.
I expected X but got Y. Why?
The catch, and say it plainly: the AI checking its own work is a hint, not a guarantee. It’s the same guesser that wrote the bug. Use it to find candidate problems, not to prove there aren’t any.
Ask for something with a hidden bug:
Write a Python function that takes a list of test scores and returns the average.
You’ll get something like:
def average(scores):
return sum(scores) / len(scores)
Ask the room to run the four checks. Level 2 passes fine. Level 3: what if the list is
empty? ZeroDivisionError. The AI wrote correct code for the case you described and
had nothing to say about the case you didn’t.
“It didn’t make a mistake. It answered exactly what you asked. You left out the question.”
Emphasize check 3 — unrequested changes are the failure mode that bites hardest on real projects.
This build has a rule: write the spec before the prompt.
This is a practice project, not the capstone — the capstone gets pitched later in this session. Keep it small on purpose.
Every camper fills this out before touching a keyboard:
APP NAME:
WHAT IT DOES (one sentence):
MUST HAVE (3 things, no more):
1.
2.
3.
WHAT IT LOOKS LIKE:
HOW I'LL KNOW IT WORKS (3 specific tests):
1. If I ______, it should ______
2. If I ______, it should ______
3. If I ______ (something wrong), it should ______
The last section is the new thing. They write their tests before the code exists. Test 3 must be a wrong-input test.
Instructor signs off on the spec before they start. Reject anything with more than 3 must-haves or a vague test.
Work from the spec. First prompt is the whole app (Mode 1). Every change after is one thing (Mode 2).
Board checklist:
Run all three of your own tests one last time and mark pass/fail on the spec sheet honestly. A failed test you can name is a better outcome than a passed test you didn’t really check. Say this out loud — it sets the culture for the rest of the track.
Pairs swap machines. Your job: break your partner’s app.
You may not look at the code. You may only use the app.
Rules of engagement:
Write down every problem you find using the good bug-report format from Session 1: what you did, what you expected, what happened.
Swap back. Fix the top bug your partner found.
“Your partner found in five minutes what you missed in twenty. That’s not because they’re better — it’s because you were trying to make it work and they were trying to make it fail. Both are necessary. Professionals hire people whose whole job is the second one.”
Seven minutes breaking, eight minutes fixing. Require the bug report in writing, formatted properly. Then have them paste that report straight to the AI — a well-written bug report is a well-written prompt, and that’s not a coincidence.
The capstone build has to fit in the rest of this session plus Session 3, because Session 4 is 60 minutes of demo and wrap-up with no build time. Campers need to know that now.
“Your Session 4 is one hour, and it’s all demos. That means your project has to be finished by the end of next session. Plan accordingly — and that mostly means picking something smaller than you want to.”
Each camper gets 3 minutes to pitch, using this:
I'm building ______.
You use it to ______.
The three things it has to do:
1.
2.
3.
I'll know it works when:
- If I ______, it ______
- If I ______ (wrong input), it ______
Partner’s job — ask these two questions:
Question 2 is the important one. Almost everyone should cut one.
Every camper gets a ~30-second sign-off. You are looking for one thing:
Can this be built in the time left in this session plus one more session?
Common over-scopes and the cut:
| They pitched | Cut it to |
|---|---|
| Multiplayer online game | Two players, same keyboard |
| App with user accounts and logins | One user, saves to a text file |
| Website with a database | One page, data in a JSON file |
| “A whole RPG” | One battle, three enemies |
| Machine learning something | Rules-based version of the same idea |
| Discord/Instagram bot | Same logic, local app, no API |
Say the reasoning out loud, because it’s the real lesson:
“Cutting scope isn’t giving up. It’s the actual skill. A small thing that works beats a big thing that doesn’t, every single time, forever, in every job you will ever have.”
Set up the project properly. This 20 minutes is what makes Session 3 productive.
cd $HOME\Documents\Projects
cd <Name>
mkdir capstone
cd capstone
claude
<Name> is the camper’s name folder from Session 1. Campers who missed Session 1
don’t have one yet — make it for them with mkdir <Name> during setup.
Four things, in order:
I want to build [their app]. Don't write any code yet. Tell me what
files you'd create, what goes in each one, and what order you'd
build them in.
PLAN.md in the project folder.Full multi-file technique comes in Session 3 — this block is about getting a plan on disk and one working piece before campers leave.
Everyone makes a save-point copy of their project folder before they leave:
cd $HOME\Documents\Projects
cd <Name>
Copy-Item -Recurse capstone capstone-working
That’s the whole backup system, taught properly in Session 3. For now: it works, so copy it.
Two things on the board:
How much to ask for:
New app → describe the whole thing. Existing app → one change at a time. If you can’t say what should be different in one sentence, it’s too big.
How to check:
- Does it do the thing?
- Does it survive the wrong thing?
- Did it change something I didn’t ask for?
- Can I explain it?
Teaser for Session 3:
“Next time: your project gets too big for one file, and you finish your capstone. Session 4 is demos only.”
Documents\Projects folder exists on every lab machine
This Vibe Coding Curriculum by Brian Bird, created in with AI assistance, is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.