1 - Start ~4 mins
You already know how to make things happen in Scratch: sequences, variables, loops, decisions, and fixing bugs. Today the question is different. How do you turn a fuzzy idea into a plan you can actually build?
You will meet four steps coders use to break a problem down, use them on a build you choose, and start that build in Scratch.
Keep this tight. Recap only that students can already make Scratch programs do things on purpose; do not re-teach variables or loops. Name the lesson goal once: plan with four steps, then build. Devices should be ready so the build time is not eaten by logins.
2 - Four Steps, One Idea ~6 mins
Coders use four steps of computational thinking to turn a big idea into something they can build. Meet each step on a worked example as you go.
Idea: a simple chase where your sprite catches another sprite and the score goes up.
- Decomposition (smaller pieces): your sprite moves; the target moves; detect a touch; score changes.
- Pattern recognition (what repeats or what you already know): arrow-key movement and a score variable are things you have used before.
- Abstraction (keep only what matters): one sprite you control, one target, one score. Ignore lives, levels and extra enemies for now.
- Algorithms (steps in order): when the green flag starts the program, forever: move your sprite on the arrow keys; if your sprite is touching the target, change score by 1 and move the target to a new place.
That plan is short enough to build. Yours will be too.
Write the four names on the board and leave them up for the whole lesson. Do not drill the list as a quiz. Walk the chase example out loud and only expand each name as you hit that bullet, so students meet the word in use. Do not list all four definitions up front; name, plain meaning, then the chase line, one step at a time.
Common misconception: students treat the four steps as answers to memorise rather than tools they use while building. Push them to say the step name when they make a decision ("I'm abstracting: keep only what matters, so no second enemy yet").
If time is tight, keep the worked example to the four bullets and move on. Do not open Scratch in this step.
3 - Hands-on: Plan, Then Build the First Part ~12 mins
Choose one build idea, or invent a close cousin of one of these:
- an animated scene (two sprites that take turns doing something)
- a short quiz round (ask a question, check the answer, change a score)
- a simple chase (catch a target, score goes up)
Open Scratch. Reopen a project you saved earlier if it helps, or start a fresh one. If your saved project is missing, ask your teacher or begin a new project from your plan.
- In your copybook, fill in a short plan for your idea using all four steps. Copy these four headings and complete each with one short line (like the chase example above):
- Decomposition: Pieces I will build: …
- Pattern recognition: I will reuse: …
- Abstraction: Only what matters for now: …
- Algorithms: In order, the program should: …
- Build only the first piece of that plan in Scratch. For a chase, that might be movement for the sprite you control. For a quiz, the question and answer check. For a scene, the first sprite's actions.
- Run what you have. Does that first piece match the algorithm you wrote?
Circulate with one look-for: every student has named all four steps on their plan before they dive deep into blocks. Stop the class briefly if plans are only drawings with no step names.
If a student needs structure, give them four headings already written: Decomposition / Pattern recognition / Abstraction / Algorithms. Stress one short line per heading; do not let planning eat the block.
Suggested timing: about 4 minutes on the written plan, then the rest on the first build piece. At the five-minute mark say: plans down, open Scratch, build piece one from whatever you have. A thin plan you use beats a perfect plan you never code.
Before the first green-flag run on a student's first piece, ask one quick predict question out loud: What do you expect to see when this runs? Then let them run and compare. That is the predict beat; do not turn it into a whole-class quiz.
Goal-level only: do not dictate blocks. Point back to skills from earlier Scratch work (events, loops, variables, ifs) when someone is stuck. Students who finish the first piece early start the next piece rather than decorating.
4 - Your Turn: Build from Your Plan ~12 mins
Keep building from your plan in Scratch. As you add each piece, say (quietly to yourself is fine) which of the four steps you are using.
Done for today looks like this:
- you have a complete written algorithm in your copybook (update it if the build taught you a better order)
- at least one clear behaviour from that algorithm runs end to end without you explaining missing bits out loud
- you can point to one place you used decomposition, one place you used pattern recognition, one place you used abstraction, and the algorithm that holds it together
- you have tested that working behaviour at least once
If time is short, a solid first piece plus a complete written algorithm counts as done today. Extra pieces of the plan are a stretch if you finish early.
If something breaks, use the debugging routine you already know: read the symptom, find the block, form a hypothesis, test it, and revert if you are wrong.
Save your project the way your teacher just said before you stop. If you are unsure: File → Save to your computer (or Scratch cloud Save now), then confirm the project name is visible.
Keep the four step names visible. When you stop beside a student, ask which step are you on right now? rather than only what are you adding?
- Students stuck in decoration (costumes, endless backdrops): steer them back with abstraction (keep only what matters for this version).
- Students whose program works but has no plan: have them write the algorithm afterwards from what the code actually does.
- Students finished early: add one deliberate improvement and name which step justified it.
Protect the minimum bar: one clear behaviour working plus a labelled algorithm. Do not require a full polished game from everyone in this period.
Last two minutes: tell them the exact save method for today (for example: Scratch cloud Save now, or File → Save to your computer into the class folder), then watch that every machine has done it. Recovery is harder next lesson if this is skipped.
5 - Make Sense ~3 mins
Today the four steps did real work, not just labels on a slide.
- Decomposition split your idea so you were not trying to build everything at once.
- Pattern recognition let you reuse skills and blocks you already knew.
- Abstraction kept you focused on what mattered so the build did not get too big.
- Algorithms gave you an order to build and a way to check the program against the plan.
When the build drifted from the plan, updating the algorithm was part of the job, not a failure.
Take two or three quick student examples only. Prefer "I abstracted X" or "the pattern was Y" over a full demo of someone's game. Name all four steps once more so the vocabulary sticks before the next planning lesson.
Unlock the full learning experience
You're previewing this lesson. Get full access to this lesson and hundreds more — each one ready to teach, with interactive activities, printable resources and pupil progress tracking built in.
This lesson is copyright of Coding Ireland 2017 - 2025. Unauthorised use, copying or distribution is not allowed.