STEM · GRADES 3-5, GRADES 6-8 · 30-40 MIN
Program the Path: Computer Science Unplugged lesson plan
Pairs write step-by-step movement instructions, a partner follows them exactly, and the writers debug the first failing step.
At a glance
Time: 30-40 min
Grades: Grades 3-5, Grades 6-8
Subject: STEM: Computer Science Unplugged
Grouping: Pairs.
Space: A route with at least three turns, marked in 1-ft units.
Teacher prep: 10 min printing + 20 min taping
Included: Teacher guide, student sheet, checks for understanding, exit ticket with answers
Open the printable lesson: teacher guide and student sheet →
Essential question
Can you write instructions so precise that someone who follows them literally arrives exactly where you intended?
What students learn and show
Learn: An algorithm is an ordered list of precise steps; debugging means finding and fixing the first step that fails.
Show: Write an algorithm that gets a partner to the goal and locate and fix a bug in another team's algorithm.
Objectives
Write a sequence of precise movement instructions (an algorithm) between two rooms
Execute a partner's instructions exactly as written, at a calm pace
Identify where an algorithm fails and debug it
Explain why computers need unambiguous instructions
Before this lesson students should: Left/right turns; counting.
Materials and prep
The 1:1 print or taped rooms
1-ft marks or floor tiles to define a step
Instruction sheets (in the packet)
Pencils
Clipboards
Prep (about 10 min to print, 20 min to tape)
Lay out the print or tape a simple maze of rooms with START and two goals.
Define one 'step' as one floor tile or one 1-ft taped mark, so all robots move the same distance.
Copy the instruction sheet.
Space: A route with at least three turns, marked in 1-ft units.
Grouping: Pairs.
Ways to run it: Painter's tape on the floor; 1:1 printed floor plan
Lesson procedure
Teacher model: Teacher plays robot for a vague instruction ('go over there') and freezes. Then runs 'FORWARD 3, TURN RIGHT, FORWARD 2' exactly.
Guided practice: The class writes the first three commands together and tests them.
Demo the problem: the teacher follows a student's spoken directions literally ('go left': whose left?). Name the need: precise, ordered steps.
Pairs write an algorithm from START to a secret goal room using only 'FORWARD n' (n = 1-ft units or floor tiles), 'TURN LEFT' and 'TURN RIGHT' (90 degrees).
Swap sheets. The robot partner executes the instructions exactly as written, at a calm walk.
Debug: mark the first instruction where the robot went wrong, fix it, and re-run. Repeat until the robot arrives.
Debrief: computers do exactly what you wrote, not what you meant.
Checks for understanding
Ask: What is an algorithm? Look for: An ordered list of precise steps that accomplishes a task.
Ask: Your robot turned the wrong way at step 3. What do you fix? Look for: Step 3 first, then re-run from the start.
Ask: Why must the robot not 'fix' your instructions while walking? Look for: Computers do exactly what is written; testing literally finds the bugs.
Exit ticket
Find the bug: goal is 2 squares right of START. Program: TURN LEFT, FORWARD 2. Answer: The turn: it should be TURN RIGHT (assuming the robot faces forward from START).
Why did we use 1-ft steps instead of normal steps? Answer: Normal steps vary by person, which adds bugs not caused by the program.
Scoring: 1 point each, plus 2 points for a working algorithm on the floor. 3-4 secure.
Common misconception
Students may think: If the robot ends up wrong, the robot made the mistake.
Address it: Trace the program line by line: the first line where the robot's position differs from the plan is the bug.
Supports and extensions
Learning support: Provide instruction cards to sequence (forward 5 / turn left) instead of free writing; run a shorter two-turn route.
Multilingual learners: Restrict vocabulary to the three commands, posted with arrows; the syntax IS the accommodation — precision beats fluency here.
Mobility and access: Robots can roll or move a token on a tabletop grid; writing and debugging stay the target.
Extension: Add a ‘loop’ command (repeat ×N) and rewrite the algorithm in fewer lines. Challenge: two robots start from different rooms and must arrive at the same room at the same step count.
Transfer task: Write an algorithm for making a sandwich and have a partner follow it literally.
Spaced review: Next week: debug a printed 6-line program on a grid.
Standards connections
CCSS MP6 (domain-level practice)
NGSS MS-ETS1 (domain-level practice)
Connections show which skills the activity practices. They are not a claim of full coverage; see the library for scope notes.
Why this approach
A National Academies consensus report arguing that spatial thinking is a teachable, underrecognized skill that belongs across the K-12 curriculum. Limit: A policy and synthesis report, not an experiment. It does not test this lesson.
Ready to teach it?
The printable version has the full teacher guide, a student recording sheet, prep steps and an exit ticket. Open the printable lesson →
Need the floor plan itself? Get a 1:1 print quote.
Related lessons
Compass Course · Bearings, Angles & Navigation, Grades 6-8
Wayfinding Challenge · Navigation & Wayfinding, Grades 6-8
What Is Spatial Validation? · Design & Engineering, Grades 6-8, Grades 9-12
Build-a-Map · From Walked Space to Drawn Map, Grades 1-2, Grades 3-5
← Previous lesson: Habitat Blueprint · Next lesson: Data Walk →