CompuCon-VibeCoding

Session 2 — Ask Better, Check Harder

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.


Contents

Timing — 180 min

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

Warm-Up: Same Prompt, Four Ways (10 min)

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:

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.)


How Much To Ask For At Once (20 min)

The two modes

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.

Why one at a time (the real reason)

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.”

The size test

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”

The exception worth naming

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.


Prompt Lab (25 min)

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:

  1. What kind of game? Missing everything. Needs: genre, input, win condition, platform.
  2. Website doing what? Missing: pages, content, static or interactive, hosted where.
  3. Ugly how, and what do you want instead? “Fix” isn’t an instruction. Needs a target: “use a dark background with light text.”
  4. “Stuff” is doing a lot of work. Player names? Scores per game? Season totals? Needs a concrete list of what gets tracked and what you do with it.
  5. Four changes. Split it. Ask for the leaderboard, run it, then dark mode.
  6. Ambiguous and huge. “Work on my phone” could mean a website, an app, or responsive layout. Also this may be a rewrite, not a change — worth asking the AI “what would it take to…” before asking it to do it.

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.”


Break (10 min)

Ten minutes. Take it here — the next block is the densest in the session.


How To Check The AI’s Work (25 min)

The heart of the whole track. Session 1 planted the idea; today it becomes a method.

It ran ≠ it’s right

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.”

The four checks (put these on the wall — they stay up through Session 4)

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.

Making the AI check itself

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.

The 60-second demo

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.


Build: Spec First (35 min)

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.

Spec sheet (10 min, on paper)

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.

Build (20 min)

Work from the spec. First prompt is the whole app (Mode 1). Every change after is one thing (Mode 2).

Board checklist:

Land it (5 min)

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.


Swap And Break (15 min)

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.


Capstone Pitch + Scope Check (20 min)

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.”

Pitch to a partner (8 min)

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:

  1. “What happens if I do the wrong thing?”
  2. “Could you cut one of the three and still have something cool?”

Question 2 is the important one. Almost everyone should cut one.

Instructor scope check (12 min)

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.”


Capstone: Plan And First Build (20 min)

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:

  1. Ask for a plan, not code:
    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.
    
  2. Argue with the plan. Change at least two things. Combine files, drop a feature, reorder the build. Changing a plan is free; changing code is not.
  3. Save the plan as PLAN.md in the project folder.
  4. Build component 1 only. Run it. Check it.

Full multi-file technique comes in Session 3 — this block is about getting a plan on disk and one working piece before campers leave.

End of session

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.


Wrap (built into the last block)

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:

  1. Does it do the thing?
  2. Does it survive the wrong thing?
  3. Did it change something I didn’t ask for?
  4. 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.”


Instructor Prep Checklist


Creative Commons License This Vibe Coding Curriculum by Brian Bird, created in with AI assistance, is licensed under a Creative Commons Attribution-ShareAlike 4.0 International License.