Two tracks.
One room. One hour.

Say each step, wait, say the next. Do not do it for them.

1. Open the kit on the table, do not dump it.
2. Work tray by tray. Match each part to its molded slot.
3. As each part goes in, say its name out loud as a team.
4. Pull out the hub, the two motors, and the color sensor. Pass each one around.
5. Close every tray. This is exactly how the kit gets left every single week.

Say each step, wait, say the next. Do not do it for them.

1. Lay out every structural beam you have before you start.
2. Build a base wider than you think you need.
3. Go up in sections and test stability every four inches.
4. Add diagonal bracing on two sides minimum.
5. Set the hub on top and time ten seconds.

Say each step, wait, say the next. Do not do it for them.

1. Sort the kit into trays as a whole group first. Ten minutes, everyone participates.
2. Split into teams of two or three.
3. Guide calls a part name. First team to hold it up scores a point.
4. After ten rounds, swap: learners call the parts and the guide plays.
5. Everything goes back in its tray before the score is announced.

Say each step, wait, say the next. Do not do it for them.

1. Build the basic driving base from the kit instructions. Do not customize it yet.
2. Connect to Coding Canvas and get one motor to turn. Just one.
3. Add the second motor so both turn together.
4. Add a wait block, then a stop block.
5. Run it. Adjust the wait time until it stops on the line.

Say each step, wait, say the next. Do not do it for them.

1. Get the robot driving straight first. Do not attempt a turn until that works.
2. Add one turn. Find the value that gives you a right angle by testing, not by guessing.
3. Once one turn works, copy that block three more times.
4. Run the whole square.
5. Mark the start with tape so you can see how far off you finish.

Say each step, wait, say the next. Do not do it for them.

1. Build the driving base and mount the color sensor facing forward.
2. Get the sensor reading on screen. Wave your hand at it and watch the number change.
3. Note the number when something is close versus far.
4. Write: drive forward until the sensor reads under your number, then stop.
5. Test with a hand, then with a wall.

Say each step, wait, say the next. Do not do it for them.

1. Tape a box on the floor slightly larger than the robot.
2. Drive once and see where it lands. Do not adjust yet.
3. Write down the value you used and where it landed.
4. Change one number. Run again. Write it down.
5. Once it lands inside, do not touch the code. Run it twice more.

Say each step, wait, say the next. Do not do it for them.

1. Set four obstacles in a line, well spaced.
2. Program to the first obstacle only. Get that right.
3. Add the turn around it. Test just that.
4. Add the next segment. Test. Repeat.
5. Only run the whole course once each segment works alone.

Say each step, wait, say the next. Do not do it for them.

1. Look at the course. Measure it with a ruler or by walking heel to toe.
2. Do the math on paper before opening Coding Canvas.
3. Write the entire program. No running it.
4. Everyone watches. One run.
5. After the run, work out what your math missed.

Say each step, wait, say the next. Do not do it for them.

1. Open your square program from Session 2. Do not delete it yet.
2. Circle the part that repeats. Say out loud how many times it repeats.
3. Build a loop with a repeat count and put one copy of the pattern inside.
4. Run it. Compare against the old program.
5. Now change the repeat count to 3 and see what happens.

Say each step, wait, say the next. Do not do it for them.

1. Get one trip working: forward, turn around, back.
2. Wrap that whole trip in a repeat loop.
3. Set the repeat to 4 and run it.
4. Change the repeat to forever. Find how to stop it.
5. Add a sound at each turnaround so you can hear the pattern.

Say each step, wait, say the next. Do not do it for them.

1. Tape a marker to the robot so the tip touches the paper.
2. Tape a large sheet of butcher paper to the floor.
3. Program a single side and watch the line it draws.
4. Wrap it in a loop with the right repeat count.
5. Run it and look at where the shape fails to close.

Say each step, wait, say the next. Do not do it for them.

1. Tape out a course with a repeating pattern. Straight-turn-straight-turn is fine.
2. Write down the pattern in words before touching Coding Canvas.
3. Program one repetition of the pattern.
4. Wrap it in a loop and set the count.
5. Run it. Fix the drift.

Say each step, wait, say the next. Do not do it for them.

1. Get a square working from a loop first.
2. Add a variable that holds the drive distance.
3. Inside the loop, increase that variable a little each time.
4. Run it and watch the shape grow.
5. Adjust the increase amount so four laps fit in the space you have.

Say each step, wait, say the next. Do not do it for them.

1. Split the course in half and mark the handoff point with tape.
2. Each pair programs their own half using a loop.
3. Test each half separately, from its own start.
4. Run them back to back. Watch the handoff.
5. Adjust until the second robot starts where the first actually stops, not where you hoped it would.

Say each step, wait, say the next. Do not do it for them.

1. Mount the color sensor facing down, close to the floor but not touching.
2. Open the live sensor reading. Slide the robot over the floor and over the tape. Watch the numbers.
3. Write down the two numbers: floor, and tape.
4. Pick a threshold between them.
5. Program: drive forward until the reading crosses the threshold, then stop.

Say each step, wait, say the next. Do not do it for them.

1. Get the stop-on-line behavior working first. Do not skip this.
2. Program: if you see dark, turn one way. If you see light, turn the other.
3. Run it. It will wobble. That is correct and expected.
4. Adjust the turn amount until the wobble is small enough to stay on the line.
5. Add a gentle curve to the tape and test again.

Say each step, wait, say the next. Do not do it for them.

1. Get the live color reading on screen.
2. Put three colored cards under the sensor and note what each one reads.
3. Program: if red, do this. If blue, do that. If green, do the third thing.
4. Make the behaviors obviously different: sound, turn, light.
5. Shuffle the cards and test in random order.

Say each step, wait, say the next. Do not do it for them.

1. Tape a T-shape on the floor with a colored card at the junction.
2. Get the robot driving reliably to the junction and stopping.
3. Read the color at the junction. Note the values for both cards.
4. Program: if it reads color A, turn left. Otherwise turn right.
5. Swap the card without telling the robot and run it again.

Say each step, wait, say the next. Do not do it for them.

1. Get the patrol from Session 4 running again.
2. Add: if you see the line, turn around.
3. Test just that. It should bounce between two lines.
4. Add: if something blocks the front, stop and make a sound.
5. Test both together in one run.

Say each step, wait, say the next. Do not do it for them.

1. As a team, pick which build from the arc you are proudest of.
2. Rebuild or restore it. Do not add new features.
3. Run it three times. Fix whatever fails.
4. The Presenter writes three sentences: what it does, how it works, what broke along the way.
5. Demo it to another team and take their questions.

Say each step, wait, say the next. Do not do it for them.

1. Set the room up as one group, both tracks facing a demo area.
2. Each team gets four minutes: one to explain, three to run it.
3. Presenter talks. Everyone else on the team stays hands-off unless something breaks.
4. After each demo, two questions from the room. Not from the guide.
5. No applause coaching, no adult praise. Just the next team.

Say each step, wait, say the next. Do not do it for them.

1. Set up six stations, one per Arc I skill: drive, park, square, loop, line stop, color choice.
2. Teams rotate every five minutes with their own robot.
3. Each station is pass or not-yet, judged by the team at that station.
4. Track results on a board where everyone can see.
5. Debrief at the end: which station broke the most robots, and why?

Say each step, wait, say the next. Do not do it for them.

1. Each track picks ONE thing worth teaching. Just one.
2. Ten minutes to prepare: what do you show, what do they try, how do you know they got it?
3. Team teaches first. Five minutes, hands-on for the Jr learners.
4. Jr teaches second. Same rules.
5. Close by asking each side what surprised them about the other side's work.

Say each step, wait, say the next. Do not do it for them.

1. Pair every new member with a veteran. The veteran talks, the new member has the mouse and the robot.
2. Veteran walks them through: connect, drive forward, stop. Ten minutes, hands entirely off.
3. Now the whole team adds: if the sensor sees the line, stop. Otherwise keep going.
4. Run it. The new member presses the button.
5. Veteran explains what just happened, in their own words, not the guide's.

Say each step, wait, say the next. Do not do it for them.

1. Decide the two behaviors first, on paper, before touching code.
2. Get the sensor reading live on screen.
3. Write the if branch. Test only that.
4. Write the else branch. Test only that.
5. Now test both, alternating, without restarting the program.

Say each step, wait, say the next. Do not do it for them.

1. Tape three lanes ending in three marked zones.
2. Put a colored card at the decision point.
3. Get the robot reliably reaching and stopping at the decision point.
4. Program: read the card, then drive into the matching lane.
5. Shuffle cards and run it blind five times.

Say each step, wait, say the next. Do not do it for them.

1. Tape a course with three junctions. Mark each with a different colored card.
2. Program to the first junction only. Test it.
3. Add the decision at that junction. Test it.
4. Repeat for junctions two and three, one at a time.
5. Only run the full course once each junction works alone.

Say each step, wait, say the next. Do not do it for them.

1. Build a small maze from books or boxes with two turns.
2. Program the rule: if there is space ahead, go. Otherwise turn.
3. Test it in the maze you built.
4. Change the maze without changing the code.
5. Run it again and see if the rule still works.

Say each step, wait, say the next. Do not do it for them.

1. Decide what it judges: did the object cross the line, is the color correct, did it arrive in time.
2. Get the sensor reading that detects it.
3. Program: if the condition is met, green light and a sound. Otherwise red and a different sound.
4. Test with a case that should pass.
5. Test with a case that should fail. This is the important one.

Say each step, wait, say the next. Do not do it for them.

1. Make a variable and set it to zero at the start.
2. Get the sensor detecting the thing you want to count.
3. Inside the loop: when detected, add one to the variable.
4. Display the variable on the hub screen so you can watch it change.
5. Run it and count out loud yourself. Do the numbers match?

Say each step, wait, say the next. Do not do it for them.

1. Decide what you are measuring: time, distance, or count.
2. Make a variable called best and set it to zero.
3. After each run, compare the new result to best.
4. If the new one is better, replace best.
5. Display best on the screen and run five attempts.

Say each step, wait, say the next. Do not do it for them.

1. Make a variable called fuel and set it to 10.
2. Every time the robot completes an action, subtract one.
3. Display fuel on the screen.
4. Wrap everything in: while fuel is greater than zero, keep going.
5. Run it and watch it stop by itself.

Say each step, wait, say the next. Do not do it for them.

1. Read the four roles aloud. Builder, Coder, Tester, Presenter. Say what each owns.
2. Teams get five minutes to assign them. The guide does not participate.
3. Each person says out loud what their role owns, in their own words.
4. Team writes three sentences: what we do when we disagree about the robot.
5. Run any short challenge from Arc I, in role, for the rest of the session.

Say each step, wait, say the next. Do not do it for them.

1. Assign the four roles deliberately backwards: strongest coder becomes Presenter, and so on.
2. Pick any challenge from Sessions 4 to 9 the team has already solved.
3. Run it in the swapped roles. No swapping back mid-session.
4. Debrief: what was hard, and what do you now know about your usual teammate's job?
5. Assign the real roles at the end.

Say each step, wait, say the next. Do not do it for them.

1. Each team member takes one role and writes its card.
2. Card says: what I own, what I decide, and one thing this role should never do.
3. Swap cards within the team and edit each other's.
4. Hand your set to another team and have them run in role from your cards alone.
5. Fix whatever they got wrong.

Say each step, wait, say the next. Do not do it for them.

1. Look at your longest program. Find something that appears more than once.
2. Make a new named block. Call it what it does: TurnRight, DriveToLine, Spin.
3. Move the repeated blocks inside it.
4. Replace every copy in the main program with the named block.
5. Run it. Same behavior, much shorter program.

Say each step, wait, say the next. Do not do it for them.

1. Each team writes three named blocks with clear names.
2. Write a one-line description of each on an index card.
3. Swap cards with another team.
4. Rebuild the other team's blocks from their descriptions alone.
5. Use them in a program and report back what the description left out.

Say each step, wait, say the next. Do not do it for them.

1. Pick something the robot does that takes at least four blocks.
2. Make it a named block.
3. Write a program that calls it three times in different places.
4. Run it. Does it behave the same each time?
5. If not, find what it assumed about where the robot was.

Say each step, wait, say the next. Do not do it for them.

1. Pick ONE mission from the three on the board. Do not attempt two.
2. Write the plan in words before opening Coding Canvas. Every team member signs off.
3. Break it into named blocks: approach, act, return.
4. Build and test each block separately.
5. Only run the full mission once each block works alone.

Say each step, wait, say the next. Do not do it for them.

1. Build an attachment that can push, scoop, or carry. Simple beats clever.
2. Test the attachment by hand before writing any code.
3. Program: drive to the object, engage, drive to the zone, release.
4. Test each of the four phases separately.
5. Run the whole thing and measure how far off the drop is.

Say each step, wait, say the next. Do not do it for them.

1. Write the mission card first: what has to happen, and how you know it worked.
2. Build the field from tape, boxes, and whatever is in the bin.
3. Now solve your own mission.
4. Hand the card and field to another team and watch them attempt it.
5. Fix whatever your card failed to explain.

Say each step, wait, say the next. Do not do it for them.

1. One learner steps out. The room picks a secret rule for sorting objects into two piles.
2. Sort ten objects into the two piles correctly. Leave them out.
3. Bring the learner back in. They can look but not ask.
4. They guess the rule, then sort a new object to prove it.
5. Debrief: which examples were most useful, and why?

Say each step, wait, say the next. Do not do it for them.

1. Pick a real rule, then choose examples that also fit a second, wrong rule.
2. Sort them. Bring the guesser in.
3. Let them guess. They will probably get the wrong rule.
4. Reveal the real rule.
5. Debrief: what example would have prevented this?

Say each step, wait, say the next. Do not do it for them.

1. Pick something with real variety: shoes, backpacks, LEGO pieces.
2. Decide the categories. Write them down.
3. Write the rules for deciding which category something goes in.
4. Hand the rules to another team and give them a pile.
5. Watch where their sorting disagrees with yours.

Say each step, wait, say the next. Do not do it for them.

1. Open the AI classification module in Coding Canvas.
2. Pick two clearly different things to classify. Start easy.
3. Collect training samples for category one. Lots of them.
4. Collect samples for category two.
5. Train, then test on something you never showed it.

Say each step, wait, say the next. Do not do it for them.

1. Train a working classifier on two categories.
2. Now stop trying to make it work. Try to break it.
3. Log every input that fools it. Write them down.
4. Pick the most common failure and collect training data specifically for it.
5. Retrain and test the same failing input again.

Say each step, wait, say the next. Do not do it for them.

1. Train a working two-category classifier first. Do not attempt this without one.
2. Set up two bins or two zones.
3. Program: classify, then drive to the matching zone.
4. Test with an obvious example from each category.
5. Run five mixed objects in sequence.

Say each step, wait, say the next. Do not do it for them.

1. Set the room up with a demo area and seating before anyone arrives.
2. Each team gets six minutes: two to explain, three to run, one for questions.
3. Every team member speaks. Assign who says what during prep.
4. Run live. A failed live run explained well beats a video.
5. Questions come from the room, including parents. The guide does not field them.

Say each step, wait, say the next. Do not do it for them.

1. Set up stations around the room, one per team or per learner.
2. Every station must have something actually running, not just sitting.
3. Each station has a card: what it does, what broke, what we would change.
4. Visitors circulate freely for thirty minutes.
5. Last ten minutes: everyone stops and two learners summarize the whole year so far.

Say each step, wait, say the next. Do not do it for them.

1. Two learner hosts are chosen a week in advance and get a prep card.
2. Hosts open the session, introduce each demo, and run the close.
3. The guide sits with the parents and does not speak.
4. Hosts field problems: a failed demo, an overrunning team, a hard question.
5. Debrief with the hosts privately afterwards, not in front of the room.

Say each step, wait, say the next. Do not do it for them.

1. Each team member names one thing they want the robot to do. Write all four down.
2. Pick one. Not a combination of all four, one.
3. Write the constraint lines: what it cannot use, how long it has, what counts as cheating.
4. Write the success test as something you could film.
5. Trade briefs with another team and have them tell you what success looks like.

Say each step, wait, say the next. Do not do it for them.

1. Prepare constraint cards: no wheels, under sixty seconds, must use the color sensor, must carry something, must return to start.
2. Each team draws three at random.
3. Design a challenge that genuinely requires all three.
4. Write it as a brief with a success test.
5. Present the brief to the room and take one challenge question.

Say each step, wait, say the next. Do not do it for them.

1. Spend ten minutes walking the building. Write down five annoyances.
2. Pick one a robot could plausibly help with.
3. Go ask a person who has that problem what they actually need.
4. Write the brief based on what they said, not what you assumed.
5. Get that person to agree the success test would actually help them.

Say each step, wait, say the next. Do not do it for them.

1. Read your own brief aloud as a team before starting. It will have changed in your heads.
2. Split the work by role. Builder starts the hardware, Coder starts the logic.
3. Set your own checkpoint at minute 20. Timekeeper owns it.
4. At the checkpoint, everyone stops and reports for thirty seconds.
5. Keep building. Do not test the whole thing until the last ten minutes.

Say each step, wait, say the next. Do not do it for them.

1. Existing members meet for ten minutes and decide what a member must be able to do.
2. Write it as three concrete tasks, not opinions.
3. Run the check on the new members. Existing members run it, not the guide.
4. Pass, or name exactly what to practice and check again next session.
5. File the written check with the club playbook.

Say each step, wait, say the next. Do not do it for them.

1. Split into two pairs. Same brief, no consultation for thirty minutes.
2. Each pair builds their own approach.
3. At minute 35, both pairs demo to each other. Three minutes each.
4. Team decides which approach to continue with. Decision is theirs.
5. The abandoned approach gets one sentence written down: what it did better.

Say each step, wait, say the next. Do not do it for them.

1. Each veteran picks ONE skill they can teach in ten minutes. Just one.
2. Ten minutes of prep: what do you show, what do they try, how do you know they got it?
3. Run two workshops in parallel, ten minutes each, then swap.
4. Every workshop ends with the learner doing it, not watching it.
5. Back to the sprint for the last twenty minutes.

Say each step, wait, say the next. Do not do it for them.

1. Each track picks one skill worth teaching to the other side.
2. Ten minutes of prep on each side, separately.
3. Team teaches Jr first. Ten minutes, hands on.
4. Jr teaches Team second. Same rules, same time.
5. Close by asking each side what was harder than it looked.

Say each step, wait, say the next. Do not do it for them.

1. Pick one skill. Write it as numbered steps, no more than eight.
2. Include one line about what goes wrong and how to spot it.
3. Hand it to someone who cannot do the skill. Then say nothing.
4. Watch where they get stuck. Do not help. Write down where.
5. Rewrite the step that failed.

Say each step, wait, say the next. Do not do it for them.

1. Freeze the feature list. Nothing new gets added today. Write that on your table.
2. Run the success test once. Log exactly what failed.
3. Fix one thing. Run again. Log it.
4. Repeat. The Tester owns the log and nobody skips entries.
5. Last ten minutes: three consecutive runs, untouched.

Say each step, wait, say the next. Do not do it for them.

1. Make a table: what I did, what broke, why I think it broke.
2. Now actively try to break it. Low battery, different start position, bumped mid-run.
3. Log everything, including failures you cannot explain.
4. Pick the two most likely to happen at competition and fix them.
5. Test the fixes against the same conditions.

Say each step, wait, say the next. Do not do it for them.

1. Set up the field exactly as it will be next session.
2. Run the full format: setup time, run time, scoring.
3. Nobody helps. The guide does not answer questions during the run.
4. Score it honestly and write the number down.
5. Debrief: what two things do we change before next week?