Keep this light. Stand where everyone can see you. Do the three-move phrase twice, slowly: clap, clap, spin; clap, clap, spin. Ask hands-up: which bit came back? Accept any clear answer that names the repeat.

When you say bug, cross your arms for "wrong step" straight away so children do not picture an insect. Say the gloss out loud every first use: "a bug means a wrong step".

Do not lay out the step-cards or name every vocabulary word yet. The cards come out in the next steps. The star idea today is finding and fixing the wrong step; the pattern is the short acted support that helps them spot it.

Nature of STEM cue (keep tiny): people who make games look for repeats and fix wrong steps, just like we will.

Board stays almost empty: just the words bug and fix. You carry the meaning with gestures. Do not project long definitions, and do not stack the full three-word list yet. Pattern already landed lightly in the hook; children will meet it again with the cards in the next step.

Say bug with crossed arms ("wrong step" — not an insect). Say fix with thumbs up. Keep this beat short so the class locks the star idea before any acted buggy line or card work.

Keep the board short; the table below is for you.

Misconceptions to head off:

• A bug is not an insect here. It means a wrong step we can change.
• A bug is not "being bold" or "getting it wrong forever". Celebrate the find.

Lean the talk toward find-and-fix. Treat pattern as the short support that makes the wrong step easy to see. Children already know how to put simple steps in order; today we look inside the order for a wrong step.

Before this step

Print the provided action step-cards with duplicates (one demo set for you, and later one set per group). You need several of each action so a repeating line can sit on the floor. Lay a clear strip of floor space at the front.

Card texts (print exactly; print several of each)

• Card: Jump — do one jump on the spot.
• Card: Clap — clap your hands once.
• Card: Spin — twirl all the way round once (full circle; finger-twirl cue).
• Card: Stomp — stamp one foot once.
• Card: Wave — wave one hand once.
• Card: Half-turn — turn halfway to face the other way (e.g. face the window, then face back).

Each demo/group set should include about 4 Jump, 4 Clap, 3 Spin, 3 Stomp, 2 Wave and 2 Half-turn so sequences such as Jump, Jump, Spin, Jump, Jump, Spin can actually be laid out, with a spare wrong card for the bug swap.

Modelled cycle (say it in your own voice; do not read as a script)

I wonder: can we find a pattern in this dance?

I show: lay Jump, Jump, Spin, Jump, Jump, Spin in a line (you need two Jump cards and two Spin cards for each half). Act it with the class once.

I notice: jump-jump-spin comes twice. That is our pattern. Circle those two groups with your finger or two hoops of wool on the floor. (Now the three words sit together for the first time with cards in view: pattern, bug, fix.)

I put a bug in: swap the last Spin for Wave. Act the new line: jump, jump, spin, jump, jump, wave.

I ask: which card is the bug (the wrong step)? How do we fix it?

I think: the last card should be Spin to keep the pattern. Swap Wave back to Spin and act it once more so the fix is felt.

What to expect: most children will point at Wave. If they say the whole second half is wrong, praise the notice and help them name the one card to change.

Keep moves gentle and on the spot so nobody bumps. Spin = full circle with a finger twirl; Half-turn = face the other way only, so the two cards stay distinct.

Setup

Split into small groups on clear patches of floor. Give each group one duplicate-rich set of action step-cards (about 4 Jump, 4 Clap, 3 Spin, 3 Stomp, 2 Wave, 2 Half-turn — same pack as the demo). Groups work standing, then sit to talk.

Board starter (only job on the IWB): show the provided pictured starter sequence (or arrange the same card icons once on the IWB) as the shared first move: picture icons for Clap, Clap, Stomp — Clap, Clap, Stomp. Children copy that line with cards; they do not invent a dance from scratch on the first burst.

How to run (teacher-called bursts, about 10 minutes)

• Burst 1 (lay and act): "Copy the board dance with your cards. Act it together once." Stay with the one starter sequence so every group has the same clear repeat. Everyone lays and acts.
• Burst 2 (one bug): Call "bug time". Everyone except one named helper covers their eyes or turns away. Only that helper swaps one card for a wrong one from the spare cards. Group opens eyes, acts the buggy dance, points to the single wrong card, says the fix; the helper swaps it back; all act the fixed dance once.
• Burst 3 (optional if calm and time remains): offer a second ready-made line from the list below and repeat one short bug-and-fix cycle. Do not stack inventing, multiple bugs, and free turn-taking in the same breath.

Ready-made sequences (use these; do not ask groups to invent under time pressure)

• Clap, Clap, Stomp — Clap, Clap, Stomp (board starter)
• Jump, Jump, Wave — Jump, Jump, Wave
• Spin, Spin, Half-turn — Spin, Spin, Half-turn

Guiding questions while you circulate

• Which bit is the pattern?
• Which card is the bug (the wrong step)?
• What will you put instead?

Look-fors: children point to a single wrong card; they name the fix; they try the dance again after the fix. Guesses that miss are still useful: ask what they noticed, then try once more.

Differentiation: support groups keep the two-card board starter only (clap, stomp, clap, stomp). Stretch groups may try a second ready-made line in Burst 3, still with one bug at a time.

Safety: on-the-spot moves; soft landings; freeze when you say freeze. Spin = full circle; Half-turn = face the other way only.

Open the algorithm-sequencer on the IWB in explore mode. Keep this whole-class and teacher-driven: children call out; you drag and run.

Spoken bridge (say this before the grid): "We are not making a dance pattern now. We are only bug-spotting: same idea as the wrong card, new moves for the robot."

What appears on screen: a small 3 by 3 grid, a robot sprite, a star goal, and the command cards forward, turn left, and turn right.

Grid facts (match the interactive exactly): robot starts at bottom-left facing the top of the board (start x 0, y 2, dir 0). Star is at top-right (x 2, y 0). Facing the top means forward moves the robot up the board toward smaller y.

Before any buggy run (pacing lever — do not skip):

• Point at the robot and ask: "Which way is the robot looking?" Have the class point with their whole arm the same way.
• Slow finger-walk the correct path on the grid once, naming each step out loud.
• For turns, use a big body cue: hold up your left hand for left, right hand for right, so left/right is felt before it is judged on screen.

Verified working path (build this live, then put the bug in):

• Correct sequence that reaches the star: forward, forward, turn right, forward, forward.
• Buggy start for the class: forward, forward, turn left, forward, forward (the turn left is the one wrong step).
• Fix: change turn left to turn right, then press run. The robot should land on the star.

Walk the correct path once with your finger on the grid so you are sure before the children watch the buggy run. Keep "adjust if your grid looks different" only as emergency backup; this path matches the configured start and goal.

Talk track:

• Predict first: will this reach the star?
• Run it and watch where it goes wrong.
• After the fail, point clearly to the single wrong card in the sequence list (turn left) so the class is choosing between clear steps, not decoding orientation alone.
• Ask: which step is the bug (the wrong step)? What should we put instead?
• Make the fix, run again, celebrate the working path.

Fold the watchers in: "Do you agree that is the bug? What would you try?" No separate desk task.

If the interactive is unavailable, rebuild the same idea with arrow cards on the floor and a child robot, using the same five-step path and the same one-card bug, still with a slow body-facing walk first.