Teaching Kids Coding, Design & AI: An 8-Week Tutor Guide

A complete, session-by-session guide a tutor can teach from with no prior curriculum-design experience. Everything builds toward one project: each child designs, codes, and presents their own video game. It runs as an 8-week holiday program for ages 9–11, covering coding, design, and AI.

How to use this guide

• The program is 8 weeks — one teaching unit per week.
• Each unit runs ~90 minutes. To split into two 60-minute sessions, break at the ◆ SPLIT marker.
• Every week ends with a Ship It: one concrete thing the child finishes and saves. No week ends empty-handed.
• Stay on the spine. If a child races ahead, use the Extension. If a child falls behind, protect the Ship It and drop the Extension. A finished small thing beats an abandoned big one — every time.

The big picture: why one project

Most kids' programs teach seven tools as seven islands — a child does Scratch one week and never returns to it, and forgets most of it by the end. This program connects the same skills through a single build, so each week reinforces the last. The game is the thread. The showcase is the payoff.

Your job in every lesson: keep pointing back to the child's own game. "This goes into your game" is the sentence that makes everything stick.

The 8-week arc:

What the tutor needs (your skill floor)

You do not need to be a professional developer. Before the program starts, you need to be able to do each of these once, yourself:

• Build a simple Scratch game: a sprite that moves with arrow keys, a score variable, and a collision that ends the game. (~2 hours to learn if you're new.)
• Make and export a graphic in Canva with a transparent background.
• Train and test a Teachable Machine image model.
• Use one generative-AI tool, and explain — in kid words — one time it gave you a wrong answer.

Do the full Week 3–4 build yourself before teaching it. You'll hit the exact snags the kids will, and you'll know the fixes cold.

Accounts & tools — setup checklist (do this before Week 1)

This is also how the program keeps its "no child accounts for AI" promise to parents. Read carefully.

• Scratch — usable with no sign-in, or set up a free Teacher Account to manage student projects. Children do not need personal email accounts.
• Canva — set up Canva for Education or a shared class account; children work under it. Avoid individual child sign-ups.
• Teachable Machine — runs entirely in the browser, no login needed. Models export locally or to a Google Drive you own.
• Generative AI (e.g. ChatGPT) — tutor account only. You drive it, screen-shared. Children never log in or type into it unsupervised. This is non-negotiable and is a safety promise to parents.
• Devices — one computer per child ideally. Headphones for Week 5. Stable internet.
• A shared folder you own, one per child, to save assets and project files each week.

Running the room

• Open the program with safety (Week 1) before touching any tool.
• Norms: one helper voice at a time; "ask three classmates, then me"; celebrate finished work over flashy-but-unfinished.
• Pacing rule: the Ship It is sacred, the Extension is optional. Never trade a finished deliverable for more content.
• Online delivery: screen-share the demo → give a "copy me" moment → then a build block with camera check-ins.

How to tell a child "got it" (lightweight check)

No tests. Each week, the Ship It is the assessment. A child has the week if they can (1) show their finished Ship It, and (2) explain in one sentence what it does or how they made it. If they can't explain it, they copied it — revisit in next week's warm-up.

---

Week 1 — Concept: plan the game

Objective: the child leaves with a plan for a game simple enough to actually build. Ship It: a completed Game Plan sheet — genre, hero, goal, how you win, how you lose. Prep: printed Game Plan sheets (or a simple slide template), one finished example, 2–3 kid-friendly game examples to show.

Flow (~90 min)

• Welcome & safety (15 min). Online safety basics: personal info stays private, be kind online, tell an adult if something feels wrong. What AI is, in one line: "a very good guesser that's sometimes wrong." Set the goal: "by Week 8, you'll have your own game to show your family."
• ◆ SPLIT
• Teach (15 min). What makes a game: a character, a goal, an obstacle, and a way to win and lose. Show two examples and name those four parts together out loud.
• Build (45 min). Each child fills in their Game Plan. Circulate and shrink scope aggressively — push everyone toward something tiny: one character, one screen, one goal (collect X, avoid Y). Sketch three rough scenes on paper.
• Share & wrap (10 min). Each child says their game in one sentence: "You play as ___, you win by ___, you lose if ___."

Common stumbles → fix

• "I want an open world with 50 levels." → Praise the ambition, then: "What happens in the first 30 seconds?" Build that.
• Blank page → offer a pick-list: collector, dodger, chaser, maze.

Capstone link: this sheet is the contract for the whole program. Every later week refers back to it.

---

Week 2 — Art: design it in Canva

Objective: the child designs and exports the visual pieces of their game. Ship It: a hero character, at least one background, and a game logo — exported as image files (transparent background for the character). Prep: Canva class account ready; a one-screen demo of search → drag → remove background → download.

Flow (~90 min)

• Recap (5 min). Each child restates their game in one sentence.
• Teach (20 min). Design basics at a kid's level: pick 2–3 colours that go together, use big readable fonts, keep it simple. Demo: making a character, then exporting it as a PNG with transparent background (this matters — it's why the sprite won't have an ugly box around it in Scratch).
• ◆ SPLIT
• Build (55 min). Each child makes: hero, background, logo. Save everything to their shared folder. Tutor checks each export is the right file type before the child moves on.
• Wrap (10 min). Quick gallery — each child shows their hero.

Common stumbles → fix

• Exports with a white box → wrong file type; re-export as transparent PNG.
• Spends 40 minutes on one character → set a 15-minute timer per asset.

Capstone link: these exact files get imported as sprites next week. Label them clearly.

---

Week 3 — Movement: bring it to life in Scratch

Objective: the child's own character moves on screen under their control. Ship It: their hero sprite moving with the arrow keys on their background. Prep: have your own finished version open to demo. Know how to upload a sprite and a backdrop from a file.

Flow (~90 min)

• Recap (5 min). Show last week's art.
• Teach (20 min). Scratch tour: stage, sprites, the blocks palette. Three ideas only — events (when green flag clicked), loops (forever), motion (change x/y). Demo importing their hero as a sprite and their background as a backdrop.
• ◆ SPLIT
• Build (55 min). Each child: import art, then make the hero move with arrow keys (when [right arrow] key pressed → change x by 10, etc.). Tutor moves desk to desk; this is the week kids feel the magic of "I made it move."
• Wrap (10 min). Everyone drives their character around for 30 seconds.

Common stumbles → fix

• Sprite too big/small → use the size field, not stretching.
• Moves off-screen and vanishes → add if on edge, bounce or set boundaries (keep it simple).

Capstone link: this is the playable seed of their game. Save the project to their folder.

---

Week 4 — Logic: make it a real game

Objective: turn movement into an actual game with a score, lives, and a way to win or lose. Ship It: a playable game loop — collect/avoid something, score changes, game ends. Prep: build this exact game yourself first. This is the hardest week; know the collision and variable blocks cold.

Flow (~90 min)

• Recap (5 min). Drive last week's character.
• Teach (20 min). Three ideas: variables (a score box that remembers a number), conditionals (if ___ then ___), and collision (if touching ___). Demo: add a collectible, when touching → change score by 1.
• ◆ SPLIT
• Build (55 min). Each child adds: a thing to collect or avoid, a score variable, and a win or lose condition (if score = 10 → say "You win!" or if touching enemy → stop). Tutor triages — get every child to a working loop before anyone polishes.
• Wrap (10 min). Swap seats and play a neighbour's game for one minute.

Common stumbles → fix

• Score doesn't change → the collision block isn't inside a forever loop.
• Collision never triggers → sprites' colours/edges aren't actually overlapping; check sprite size.

Capstone link: it's now genuinely a game. From here it only gets better — not bigger.

---

Week 5 — Polish: sound, levels, debugging

Objective: the child improves their working game and learns that finding-and-fixing bugs is part of building. Ship It: a polished, bug-checked game with sound, plus written playtest notes from a classmate. Prep: headphones for everyone. Know how to add a sound and a simple second level/difficulty bump.

Flow (~90 min)

• Recap (5 min). Play your own game from last week.
• Teach (15 min). Two ideas: sound (play sound on collect / win / lose) and difficulty (make enemies faster, or add a timer). Then introduce debugging as a normal, expected skill: "Every game has bugs. Finding them is the job, not a mistake."
• ◆ SPLIT
• Build & playtest (55 min). First half: add sound + one difficulty improvement. Second half: pair up — each child plays a partner's game and writes three notes (what's fun, what's confusing, one bug). Then each fixes one thing from their notes.
• Wrap (10 min). Each child names one bug they fixed.

Common stumbles → fix

• "It's done, I'm bored" → hand them the Extension: a second collectible type, a high-score, or a start screen.
• Overwhelmed by partner feedback → fix one thing only.

Capstone link: the game is now show-ready. Weeks 6–7 add the AI layer; the game itself is essentially finished.

---

Week 6 — AI: train a model (Teachable Machine)

Objective: the child trains an AI to recognise something and understands, concretely, that AI learns from examples — and is only as good as them. Ship It: a trained image model that correctly tells two or three things apart (e.g. thumbs-up vs thumbs-down, or two objects). Prep: train a model yourself. Have a deliberately bad model ready to show what biased/poor examples do.

Flow (~90 min)

• Recap (5 min). Play a finished game from the room.
• Teach (20 min). Teachable Machine tour. Big idea: "AI doesn't 'know' things — it learns from the examples you give it." Demo training two classes with the webcam, then test it live.
• ◆ SPLIT
• Build (50 min). Each child trains a model with two or three classes and tests it. Then the key lesson: garbage in, garbage out. Show your bad model, or have them train one badly on purpose (only photos from one angle) and watch it fail. Name it: "if you only show the AI one kind of example, it gets unfair and wrong." (This is bias, in kid language.)
• Wrap (15 min). Each child demos their model and says one thing that made it better or worse.

Common stumbles → fix

• Model guesses randomly → too few examples; add more, more variety.
• Frustration when it's wrong → reframe: "Now you know how to teach it better."

Extension: connect the Teachable Machine model to Scratch (via the TM extension) so a hand gesture controls their game. This is the magic-moment version if time and setup allow.

Capstone link: the child now understands the AI behind the tools they use — not just how to click them.

---

Week 7 — AI: create with it, safely

Objective: the child uses generative AI as a creative helper while learning to question it, not trust it. Ship It: AI-assisted additions to their game's world (character names, a backstory, level ideas) plus a short "What the AI got wrong" note. Prep: tutor account only — you drive the AI, screen-shared. Plan two or three safe, useful prompts in advance. This week is led from the front; children do not log in.

Flow (~90 min)

• Recap (5 min). Show a trained model from last week.
• Teach (20 min). How AI helps and fails. Demo a prompt on the shared screen ("give me five names for a brave robot character"). Then show it confidently getting something wrong or making something up — and name it: "This is called making it up. AI does this. So we always check." Rules: AI gives ideas, you make the game; always check what it says; credit when something was AI's idea.
• ◆ SPLIT
• Build (50 min). Children write down what they want help with; the tutor runs the prompts (individually or as a group), and children choose which ideas to keep and adapt into their game. Each child writes one thing the AI got wrong today.
• Wrap (15 min). Share one idea you kept and one thing you rejected.

Common stumbles → fix

• Child wants to copy AI's idea wholesale → "Great start — now change two things to make it yours."
• Treats AI as always right → return to the wrong answer from the demo.

Capstone link: the child can now use AI like a smart, fallible assistant — the actual skill, not just prompting.

---

Week 8 — Showcase: finish, portfolio, present

Objective: finish the game, package it, and present it live. Ship It: a finished game, a one-page portfolio, and a rehearsed 2-minute demo delivered to family/classmates. Prep: decide the portfolio format (a Scratch studio, or a one-page Canva sheet with screenshots + "what I made / what I learned"). Set up the showcase space. Record or screenshot every game in advance as a fallback if live tech fails.

Flow (~90 min)

• Finish & package (35 min). Final fixes only — no new features. Build the one-page portfolio: game title, a screenshot, one line on what it does, one line on what they learned.
• ◆ SPLIT (if splitting, run the showcase as session two, ideally with parents invited)
• Rehearse (20 min). Teach a simple demo script: "My game is called ___. You play as ___. The fun part is ___. The trickiest thing I solved was ___." Each child practises once with a partner.
• Showcase (30 min). Each child presents for ~2 minutes: shows the game, runs the script, takes one question. Applause every time.
• Close (5 min). Name what each child built. Hand out a simple certificate if you have one.

Common stumbles → fix

• Stage fright → let nervous kids go mid-order, not first; partner can stand beside them.
• Game broke last-minute → use the pre-recorded screenshot/clip; the presentation still counts.

Capstone link: this is the outcome the whole program promised — a finished thing they made, and the confidence to talk about it.

---

Appendix A — Troubleshooting quick reference

Scratch

• Sprite has a white box → re-export the art as a transparent PNG.
• Won't move → check the block is inside a loop and tied to the right key event.
• Collision won't fire → sprites aren't actually overlapping; check size and position.

Canva

• Can't remove background → confirm the class plan has background removal; otherwise pick art that's already on transparent.
• Blurry export → export at a larger size / higher quality.

Teachable Machine

• Random guesses → more examples, more variety per class.
• Won't load the camera → check browser permissions.

Generative AI

• Off-topic or wrong answer → great teaching moment; use it. Re-prompt more specifically.
• Anything inappropriate appears → you're driving, so you can stop instantly; never leave a child alone with it.

---

Appendix B — Parent touchpoints

• Week 1 — Welcome note. Confirm the goal (a finished game by Week 8), the AI safety policy (no child accounts; supervised use only), and the showcase date.
• Week 4–5 — Mid-point update. A line and a screenshot: "Here's [child]'s game so far." Builds confidence and word-of-mouth.
• Week 7 — Showcase invite. Time, place, and what to expect (each child presents for ~2 minutes).

---

Appendix C — Showcase day runbook

1. Before: screenshot/record every game as a fallback. Test the room's screen and sound.
2. Setup: chairs for families, one shared screen, a running order (nervous kids in the middle).
3. Run: brief welcome → each child ~2 min → applause every time → one question max.
4. If tech fails: switch to the pre-recorded clip; the child still presents.
5. Close: name each child's build; hand out certificates.

---

Appendix D — Tutor's weekly checklist (one glance)

Appendix E — Optional taster sessions (if running a hybrid)

If you want a touch of breadth without breaking the spine, add a standalone taster between weeks — never inside the core build. Keep it to one session, clearly framed as "try something new," with no expectation it connects to the game:

• Physical computing taster — MakeCode with a micro:bit (lights, buttons, a step counter). Genuinely different from Scratch because it touches hardware, so it adds real breadth rather than repeating block coding.
• Music-coding taster — making a short tune with code.

Slot at most one or two across the program. Each costs a week of capstone time, so add them only if your program's goal is exposure as well as outcome.

---

This guide is a teaching artifact from the Softroid studio. If you run a coding or AI program for kids and want curriculum, tooling, or a custom build to support it, get in touch.