Courses (Young Genius)

Scratch 1 – My First Coding Adventures with Scratch

Age Group: 7–10 years

Course Synopsis: This 10-week introductory course uses Scratch to teach fundamental coding concepts through visual, block-based programming. Students will learn to create interactive stories, animations, and simple games while developing computational thinking, problem-solving, and creative expression skills. The course emphasizes hands-on activities, collaborative projects, and building a strong foundation for future coding endeavors.

Tools: Scratch (web-based or offline editor)

Session Duration: 1 hour 20 minutes

Week 1: Welcome to Scratch! – Exploring the Interface & Making Sprites Move

  • Learning Objective: Introduce the Scratch interface, understand sprites and the stage, learn basic movement blocks (move, turn), and trigger actions with the ‘when green flag clicked’ event.
  • (15 min) Warm-up Game/Quick Review: “Simon Says Directions!”
    • Play a game of “Simon Says” using coding directions (e.g., “Simon says turn right,” “Simon says move forward”). Reinforces directional vocabulary.
  • (25 min) Concept Demo + Guided Practice: Scratch Interface Tour & Sprite Movement
    • Introduce the Scratch website/offline editor. Tour the interface: Stage, Sprite List, Block Palettes (Motion, Events, etc.), Scripts Area.
    • Introduce the default Scratch Cat sprite. Explain sprites as characters.
    • Demonstrate dragging and connecting ‘move’ and ‘turn’ blocks. Show ‘when green flag clicked’ event.
    • Guided practice: Students make the Scratch Cat move and turn using these blocks.
  • (30 min) Collaborative Project: “Sprite Dance Party!”
    • Students work in pairs. Each pair chooses a sprite from the Sprite Library (or draws their own).
    • Collaboratively program their sprite to move and turn in different ways.
    • Challenge: Make sprites move in different directions and speeds.
  • (10 min) Share & Reflect: “Show Your Moves!”
    • Pairs showcase their sprite movements.
    • Discuss: “What blocks did you use to make your sprite move? What was easy/challenging?”


Week 2: Making Sprites Talk & Change Appearance – Looks & Say Blocks

  • Learning Objective: Learn to use ‘say’ and ‘think’ blocks to make sprites communicate, explore ‘Looks’ blocks to change sprite appearance (size, color effects).
  • (15 min) Warm-up Game/Quick Review: “Charades with Actions!”
    • Act out actions (moving, turning, growing, shrinking) and have students guess the Scratch block category (Motion, Looks).
  • (25 min) Concept Demo + Guided Practice: Sprite Communication & Looks
    • Introduce ‘Looks’ palette. Demonstrate ‘say’ and ‘think’ blocks for speech bubbles.
    • Show ‘change size by’ and ‘change color effect by’ blocks.
    • Guided practice: Students make their sprites say something and change size/color.
  • (30 min) Collaborative Project: “Greeting Card Animation!”
    • Pairs create a simple animated greeting card.
    • Sprites ‘say’ greetings, change colors, and sizes.
    • Challenge: Add background using ‘Backdrops’ and make backdrop change too.
  • (10 min) Share & Reflect: “Show Your Greetings!”
    • Pairs showcase their greeting card animations.
    • Discuss: “How did you make your sprite talk and change looks? What other ‘Looks’ blocks are there?”


Week 3: Adding Sounds – Making Projects Interactive with Sound Blocks

  • Learning Objective: Introduce ‘Sound’ blocks to add sound effects and music to projects, explore different sound options in Scratch.
  • (15 min) Warm-up Game/Quick Review: “Sound Association!”
    • Play sound effects (animal sounds, vehicle sounds). Students name things that make those sounds and if they could use them in Scratch projects.
  • (25 min) Concept Demo + Guided Practice: Adding Sounds to Sprites
    • Introduce ‘Sound’ palette. Demonstrate ‘play sound’ block and ‘start sound’ block.
    • Show how to choose sounds from the Sound Library and record their own sounds.
    • Guided practice: Students add sounds to their sprites (e.g., a cat sprite meowing, a drum sprite playing a drum sound).
  • (30 min) Collaborative Project: “Sound Effects Story!”
    • Pairs create a short interactive story with 2-3 scenes.
    • Each scene uses sprites and backdrops, and incorporates relevant sound effects.
    • Challenge: Make sounds play when sprites move or interact.
  • (10 min) Share & Reflect: “Listen to Our Story!”
    • Pairs showcase their sound effect stories.
    • Discuss: “How did you add sounds? What kind of sounds are available in Scratch?”


Week 4: Events & User Interaction – Making Projects Respond to Clicks

  • Learning Objective: Introduce more ‘Events’ blocks, especially ‘when sprite clicked’, to make projects interactive and respond to user actions.
  • (15 min) Warm-up Game/Quick Review: “Action Reaction!”
    • Give a command (e.g., “Clap your hands!”). Students perform the action immediately. Relate to events triggering actions.
  • (25 min) Concept Demo + Guided Practice: ‘When Sprite Clicked’ Event
    • Review ‘when green flag clicked’. Introduce ‘when sprite clicked’ event.
    • Demonstrate making a sprite react when clicked (e.g., change color, say something, move).
    • Guided practice: Students make their sprites respond to being clicked.
  • (30 min) Collaborative Project: “Interactive Button Project!”
    • Pairs create interactive buttons using sprites.
    • Each button, when clicked, performs a different action (e.g., changes backdrop, makes a sprite appear/disappear, plays a sound).
    • Challenge: Create multiple buttons that control different aspects of the project.
  • (10 min) Share & Reflect: “Click and See!”
    • Pairs showcase their interactive button projects.
    • Discuss: “How did you make your buttons work? What other ‘Events’ blocks are there?”


Week 5: Variables – Remembering Information & Creating Scores (Simple)

  • Learning Objective: Introduce variables to store and change values, use variables to create a simple score in a project.
  • (15 min) Warm-up Game/Quick Review: “Memory Match!”
    • Play a simple memory matching game. Relate to computers needing to remember information (variables).
  • (25 min) Concept Demo + Guided Practice: Creating and Using Variables
    • Introduce ‘Variables’ palette. Show how to create a variable.
    • Demonstrate ‘set variable to’ and ‘change variable by’ blocks.
    • Guided practice: Students create a variable and make it change value when a sprite is clicked.
  • (30 min) Collaborative Project: “Clicker Counter Game!”
    • Pairs create a simple “clicker” game.
    • Clicking a sprite increases a score variable displayed on the stage.
    • Challenge: Add a “reset” button to set the score back to zero.
  • (10 min) Share & Reflect: “Count Your Clicks!”
    • Pairs showcase their clicker counter games.
    • Discuss: “What is a variable? How did you use it to keep score? Why are variables useful?”


Week 6: Simple Animation – Creating Movement with Loops & ‘Next Costume’

  • Learning Objective: Learn to create simple animations using loops and the ‘next costume’ block to simulate movement.
  • (15 min) Warm-up Game/Quick Review: “Human Animation!”
    • Students act out simple animations (e.g., walking, waving) by changing poses in quick succession. Relate to costumes and animation.
  • (25 min) Concept Demo + Guided Practice: Costumes and ‘Next Costume’
    • Introduce the ‘Costumes’ tab for sprites. Show sprites with multiple costumes.
    • Demonstrate the ‘next costume’ block and using it within a ‘forever’ loop (or ‘repeat’ loop) to create animation.
    • Guided practice: Students animate a sprite using ‘next costume’ and a loop.
  • (30 min) Collaborative Project: “Walking/Flying Sprite Animation!”
    • Pairs choose a sprite with multiple costumes that suggest walking or flying.
    • Program the sprite to animate its walking/flying motion continuously.
    • Challenge: Control the animation speed using ‘wait’ blocks inside the loop.
  • (10 min) Share & Reflect: “Show Your Animations!”
    • Pairs showcase their sprite animations.
    • Discuss: “How did you create animation? What are costumes? How does ‘next costume’ work?”


Week 7: Conditional Logic – ‘If’ Blocks for Making Decisions (Simple)

  • Learning Objective: Introduce basic conditional logic using ‘if’ blocks to make sprites make decisions based on conditions.
  • (15 min) Warm-up Game/Quick Review: “If-Then Game!”
    • Play “If it’s sunny, then clap your hands. If it’s raining, then stomp your feet.” Introduce ‘if-then’ logic.
  • (25 min) Concept Demo + Guided Practice: ‘If’ Block Basics
    • Introduce ‘Control’ palette and the simple ‘if then’ block.
    • Demonstrate using a simple condition (e.g., “if mouse down?”) with ‘if’ block to control sprite behavior (e.g., if mouse is clicked, change color).
    • Guided practice: Students use ‘if’ blocks with simple conditions to make sprites react differently based on conditions.
  • (30 min) Collaborative Project: “Color Changer with ‘If’!”
    • Pairs create a project where a sprite changes color when clicked only if a certain condition is met (e.g., if a variable is a certain value, or if another sprite is in a certain position – simplified conditions appropriate for age).
    • Challenge: Add more conditions and different color changes.
  • (10 min) Share & Reflect: “Conditional Creations!”
    • Pairs showcase their projects using ‘if’ blocks.
    • Discuss: “What is an ‘if’ block for? How did you use conditions to make decisions in your project?”


Week 8: More Events – ‘When Backdrop Switches’ & Story Sequencing

  • Learning Objective: Explore the ‘when backdrop switches to’ event to create multi-scene stories and control actions across different backdrops.
  • (15 min) Warm-up Game/Quick Review: “Scene Change!”
    • Show different pictures representing story scenes (e.g., forest, city, beach). Discuss how stories change scenes.
  • (25 min) Concept Demo + Guided Practice: ‘When Backdrop Switches’ Event
    • Introduce the ‘when backdrop switches to’ event in the ‘Events’ palette.
    • Show how to add multiple backdrops. Demonstrate using ‘switch backdrop to’ block and ‘when backdrop switches to’ to trigger different actions in different scenes.
    • Guided practice: Students create a project with two backdrops and make sprites behave differently in each backdrop using this event.
  • (30 min) Collaborative Project: “Two-Scene Story!”
    • Pairs create a two-scene interactive story.
    • Each scene is a different backdrop. Sprites perform actions and say dialogue in each scene, triggered by backdrop changes.
    • Challenge: Add user interaction (e.g., clicking on sprites to advance to the next scene).
  • (10 min) Share & Reflect: “Our Scene Stories!”
    • Pairs showcase their two-scene stories.
    • Discuss: “How did you use backdrop changes to tell a story? Why is ‘when backdrop switches’ useful?”


Week 9: Teamwork Project – Collaborative Storytelling Game

  • Learning Objective: Combine learned concepts in a collaborative project to create a storytelling game as a team, reinforcing teamwork and communication.
  • (15 min) Warm-up Game/Quick Review: “Story Chain!”
    • Start a story with a sentence. Each student adds a sentence to continue the story. Emphasize collaborative storytelling.
  • (25 min) Concept Review & Project Brainstorming: Planning a Team Game
    • Briefly review key concepts learned in Scratch 1 (movement, looks, sounds, events, variables, loops, if, backdrops).
    • Brainstorm ideas for a collaborative storytelling game in Scratch as a class. Decide on a basic game idea together (e.g., a simple adventure game, a choose-your-own-story game).
    • Divide students into larger teams (3-4 students per team).
  • (30 min) Collaborative Project: Team Storytelling Game Development!
    • Teams work together to develop their Scratch storytelling game based on the brainstormed idea.
    • Divide tasks within the team (e.g., one student focuses on sprite animation, another on scene design, another on coding interactions).
    • Encourage teamwork, communication, and problem-solving within teams.
  • (10 min) Share & Reflect: “Work in Progress Showcase!”
    • Teams briefly show their work-in-progress games.
    • Discuss: “What is your game about? What challenges are you facing as a team?”


Week 10: Scratch 1 Showcase & Creative Project – Junior Scratch Game Developers!

  • Learning Objective: Complete the team storytelling game projects, showcase projects, celebrate learning, and encourage continued Scratch exploration.
  • (15 min) Warm-up Game/Quick Review: “Code Review Relay!”
    • Teams quickly review each other’s code snippets and give positive feedback.
  • (35 min) Project Completion & Refinement: Finishing Touches on Team Games
    • Teams continue working on their storytelling games, adding final touches, fixing bugs, and making improvements based on feedback.
  • (25 min) Showcase Time: “Junior Scratch Game Developer Showcase!”
    • Each team presents their completed storytelling game to the class.
    • Teams can have a short demo and explain their game and the coding concepts they used.
    • Encourage positive feedback and appreciation from classmates.
  • (10 min) Recap + Rewards: “Junior Scratch Game Developers!”
    • Congratulate everyone on completing Scratch 1 and becoming “Junior Scratch Game Developers!”
    • Give out certificates of completion for Scratch 1.
    • Encourage continued exploration of Scratch and mention “Scratch 2” course.
    • Provide small celebratory rewards (e.g., Scratch-themed stickers, small toys, coding-related goodies).

Scratch 2 – Interactive Storytelling & Games with Scratch

Age Group: 7–10 years (Prerequisite: Completion of Scratch 1 or equivalent basic Scratch knowledge)

Course Synopsis: Building upon the foundation of Scratch 1, this 10-week course delves deeper into Scratch’s capabilities, focusing on creating more complex interactive stories and games. Students will explore advanced event handling, more sophisticated conditional logic (if/else), loops, cloning, sensing, and more advanced game design principles. The course continues to foster computational thinking, problem-solving, creativity, collaboration, and prepares students for more advanced programming concepts.

Tools: Scratch (web-based or offline editor)

Session Duration: 1 hour 20 minutes

Week 1: Review & Level Up – Recap of Scratch 1 & Introducing ‘If-Else’ Blocks

  • Learning Objective: Review core concepts from Scratch 1, introduce ‘if-else’ blocks for more complex conditional logic and decision-making.
  • (15 min) Warm-up Game/Quick Review: “Scratch Block Brainstorm!”
    • Teams brainstorm and list as many Scratch blocks and concepts they remember from Scratch 1 as possible. Quick review of key concepts.
  • (25 min) Concept Demo + Guided Practice: Review & ‘If-Else’ Introduction
    • Quickly recap key concepts from Scratch 1 (movement, looks, sounds, events, variables, loops, simple ‘if’).
    • Introduce ‘Control’ palette and the ‘if-else’ block. Explain how it allows for two different outcomes based on a condition.
    • Demonstrate using ‘if-else’ to make a sprite do one thing if a condition is true, and something else if false (e.g., if variable > 5, say “High Score!”, else say “Keep Trying!”).
    • Guided practice: Students use ‘if-else’ blocks in simple projects.
  • (30 min) Collaborative Project: “Interactive Quiz with ‘If-Else’!”
    • Pairs create a short interactive quiz with 2-3 questions.
    • Use ‘if-else’ to check if the user’s answer is correct or incorrect and provide feedback.
    • Challenge: Keep score using variables and update score based on correct/incorrect answers.
  • (10 min) Share & Reflect: “Test Your Quizzes!”
    • Pairs let others try their quizzes.
    • Discuss: “How did you use ‘if-else’ in your quiz? How is it different from a simple ‘if’ block?”


Week 2: Sensing – Making Projects React to Mouse & Keyboard Input

  • Learning Objective: Explore ‘Sensing’ blocks to make projects respond to mouse movements, mouse clicks, and keyboard input, enhancing user interaction.
  • (15 min) Warm-up Game/Quick Review: “Keyboard Commands!”
    • Assign keyboard keys to actions (e.g., “Press ‘Up Arrow’ to jump,” “Press ‘Spacebar’ to shoot”). Students follow commands. Relate to keyboard input in Scratch.
  • (25 min) Concept Demo + Guided Practice: Sensing Blocks
    • Introduce ‘Sensing’ palette. Demonstrate ‘mouse x position’, ‘mouse y position’, ‘mouse down?’, ‘key pressed?’ blocks.
    • Show how to use these blocks to control sprite movement, actions, or events based on mouse/keyboard input.
    • Guided practice: Students experiment with sensing blocks to control sprites.
  • (30 min) Collaborative Project: “Mouse Follower Game!”
    • Pairs create a simple game where a sprite follows the mouse cursor.
    • Use ‘go to mouse-pointer’ block or sensing blocks to control sprite movement.
    • Challenge: Add obstacles that the mouse-following sprite needs to avoid.
  • (10 min) Share & Reflect: “Follow the Mouse!”
    • Pairs showcase their mouse follower games.
    • Discuss: “Which ‘Sensing’ blocks did you use? How does sensing make projects more interactive?”


Week 3: More Loops – ‘Repeat Until’ Loops for Dynamic Conditions

  • Learning Objective: Introduce ‘repeat until’ loops, contrasting them with ‘repeat’ loops, and using them for actions that continue until a condition is met.
  • (15 min) Warm-up Game/Quick Review: “Looping Actions!”
    • Give instructions involving ‘repeat’ and ‘repeat until’ logic (e.g., “Repeat clapping 5 times,” “Repeat jumping until I say ‘stop'”).
  • (25 min) Concept Demo + Guided Practice: ‘Repeat Until’ Loops
    • Review ‘repeat’ loops. Introduce ‘repeat until’ loop from ‘Control’ palette.
    • Explain that ‘repeat until’ loops continue until a specified condition becomes true.
    • Demonstrate using ‘repeat until’ with a sensing condition (e.g., ‘repeat until touching color red’).
    • Guided practice: Students use ‘repeat until’ loops in simple projects.
  • (30 min) Collaborative Project: “Color Target Game with ‘Repeat Until’!”
    • Pairs create a game where a sprite moves repeatedly until it touches a specific color (target color).
    • Use ‘repeat until touching color [target color]’ loop to control sprite movement.
    • Challenge: Add scoring and make the target color change randomly.
  • (10 min) Share & Reflect: “Target Hit!”
    • Pairs showcase their color target games.
    • Discuss: “How is ‘repeat until’ different from ‘repeat’? When is ‘repeat until’ more useful?”


Week 4: Cloning – Creating Multiple Sprites Dynamically

  • Learning Objective: Introduce cloning to create multiple instances of a sprite dynamically, enabling more complex games and animations with many objects.
  • (15 min) Warm-up Game/Quick Review: “Cloning Objects!”
    • Show a single object, then quickly multiply it into many copies. Explain the idea of cloning or creating copies.
  • (25 min) Concept Demo + Guided Practice: Cloning Basics
    • Introduce ‘Control’ palette and the ‘create clone of [myself]’ block.
    • Demonstrate how to create clones of a sprite. Explain that clones are copies that can act independently.
    • Show ‘when I start as a clone’ event to control clone behavior.
    • Guided practice: Students create simple projects with sprite cloning.
  • (30 min) Collaborative Project: “Falling Objects Game with Clones!”
    • Pairs create a game with falling objects (e.g., raindrops, stars).
    • Use cloning to create many falling objects dynamically. Make clones fall from the top of the stage.
    • Challenge: Make objects fall at random speeds and positions.
  • (10 min) Share & Reflect: “Clone Army!”
    • Pairs showcase their falling objects games.
    • Discuss: “What is cloning? Why is cloning useful for creating many objects? How do clones behave?”


Week 5: More on Variables – Using Variables for Game States & Complexity

  • Learning Objective: Deepen understanding of variables by using them to manage game states (start, play, game over), control game difficulty, and add more complexity to projects.
  • (15 min) Warm-up Game/Quick Review: “Game State Machine!”
    • Act out different game states (start, playing, pause, game over). Explain that games have different states managed by variables.
  • (25 min) Concept Demo + Guided Practice: Variables for Game States
    • Review variables. Show how to use variables to represent game states (e.g., variable ‘gameState’ can be “start”, “playing”, “gameOver”).
    • Demonstrate using ‘if’ blocks and ‘gameState’ variable to control different parts of the game based on the current state.
    • Guided practice: Students use variables to manage simple game states.
  • (30 min) Collaborative Project: “Maze Game with Game States!”
    • Pairs create a simple maze game.
    • Use variables to manage game states: “start” screen, “playing” game, “gameOver” screen.
    • Challenge: Add score, timer, and different levels of difficulty controlled by variables.
  • (10 min) Share & Reflect: “Game States in Action!”
    • Pairs showcase their maze games with game states.
    • Discuss: “How did you use variables to manage game states? Why is managing game states important?”


Week 6: Lists – Storing Collections of Data (Simple)

  • Learning Objective: Introduce lists to store collections of data (like words, numbers, or sprite names), and use lists in projects to manage multiple items.
  • (15 min) Warm-up Game/Quick Review: “List It!”
    • Ask students to list their favorite colors, animals, etc. Explain that lists are ways to organize collections of items.
  • (25 min) Concept Demo + Guided Practice: Creating and Using Lists
    • Introduce ‘Lists’ palette. Show how to create a list and add items to it.
    • Demonstrate using list blocks to access items from a list (e.g., ‘item 1 of [list name]’, ‘length of [list name]’).
    • Guided practice: Students create lists and display items from lists.
  • (30 min) Collaborative Project: “Random Item Picker with Lists!”
    • Pairs create a project that randomly picks an item from a list (e.g., random name picker, random word generator).
    • Use lists to store items and ‘pick random’ block to select an item from the list.
    • Challenge: Make the project display the randomly picked item in a visually appealing way.
  • (10 min) Share & Reflect: “Pick a Random Item!”
    • Pairs showcase their random item picker projects.
    • Discuss: “What are lists? Why are lists useful for storing many items? How did you pick a random item from a list?”


Week 7: More Sensing – Touching and Colors for Interactions

  • Learning Objective: Explore ‘touching [sprite]’ and ‘touching color [color]’ sensing blocks to create interactions based on sprite collisions and color detection.
  • (15 min) Warm-up Game/Quick Review: “Touch Tag!”
    • Play a game of tag. Relate touching and collision to sprite interactions in Scratch.
  • (25 min) Concept Demo + Guided Practice: ‘Touching’ and ‘Touching Color’ Sensing
    • Review sensing. Introduce ‘touching [sprite]’ and ‘touching color [color]’ blocks.
    • Demonstrate using these blocks to detect collisions between sprites and touching specific colors.
    • Guided practice: Students use these sensing blocks to create interactions when sprites touch each other or touch certain colors.
  • (30 min) Collaborative Project: “Simple Chase Game with Touching!”
    • Pairs create a simple chase game with two sprites (chaser and chased).
    • Use ‘touching [chased sprite]’ sensing to detect when the chaser catches the chased sprite.
    • Challenge: Add scoring when the chaser catches the chased sprite and make the chased sprite run away.
  • (10 min) Share & Reflect: “Catch Me If You Can!”
    • Pairs showcase their chase games.
    • Discuss: “How did you use ‘touching’ sensing? How can sensing collisions make games more fun?”


Week 8: Operators – Math & Logic for More Complex Game Mechanics

  • Learning Objective: Introduce basic ‘Operators’ blocks (arithmetic, comparison, logic) to perform calculations, compare values, and create more sophisticated game mechanics.
  • (15 min) Warm-up Game/Quick Review: “Math Challenge!”
    • Give simple math problems. Students solve them quickly. Relate to computers doing calculations.
  • (25 min) Concept Demo + Guided Practice: Basic Operators
    • Introduce ‘Operators’ palette. Demonstrate basic arithmetic operators (+, -, *, /), comparison operators (<, >, =), and logic operators (‘and’, ‘or’, ‘not’).
    • Show how to use operators to perform calculations, compare variables, and create more complex conditions in ‘if’ blocks and loops.
    • Guided practice: Students use operator blocks in simple projects.
  • (30 min) Collaborative Project: “Math Quiz Game with Operators!”
    • Pairs create a math quiz game.
    • Use operators to generate random math questions (addition, subtraction – age-appropriate), check user answers, and calculate scores.
    • Challenge: Add different levels of difficulty with more complex math problems.
  • (10 min) Share & Reflect: “Math Masters!”
    • Pairs showcase their math quiz games.
    • Discuss: “How did you use operators in your math game? How can operators make projects more powerful?”


Week 9: Teamwork Project – Collaborative Game Design & Development

  • Learning Objective: Combine all learned concepts in a larger collaborative game design and development project, emphasizing teamwork, planning, and problem-solving.
  • (15 min) Warm-up Game/Quick Review: “Game Design Ideas!”
    • Teams brainstorm ideas for a more complex game they could create together, listing game mechanics, story ideas, and features.
  • (25 min) Project Planning & Design: Team Game Concept
    • Teams refine their game ideas, decide on a game concept (genre, story, mechanics), and plan the different parts of the game (sprites, backdrops, levels, scoring, interactions).
    • Encourage teams to divide tasks and assign roles for game development.
  • (30 min) Collaborative Project: Team Game Development – Part 1
    • Teams start developing their games in Scratch, focusing on core game mechanics, sprite design, and basic interactions.
    • Provide support and guidance as teams work.
  • (10 min) Share & Reflect: “Game Design Progress!”
    • Teams show their work-in-progress games and explain their game design and progress.
    • Discuss: “What is your game idea? What are you working on? What challenges are you facing?”


Week 10: Scratch 2 Game Showcase & Creative Project – Junior Scratch Game Designers!

  • Learning Objective: Complete team game projects, showcase projects, celebrate learning, and encourage continued advanced Scratch exploration.
  • (15 min) Warm-up Game/Quick Review: “Code Debugging Challenge!”
    • Present teams with small code snippets with deliberate errors. Teams quickly identify and fix the errors.
  • (35 min) Project Completion & Refinement: Finishing Touches on Team Games
    • Teams continue working on their game projects, adding final features, levels, polish, and fixing bugs based on feedback.
  • (25 min) Showcase Time: “Junior Scratch Game Designer Showcase!”
    • Each team presents their completed Scratch game to the class.
    • Teams can have a demo, explain their game design, coding concepts used, and any challenges they overcame.
    • Encourage positive feedback and appreciation from classmates and potentially invite others to play their games.
  • (10 min) Recap + Rewards: “Junior Scratch Game Designers!”
    • Congratulate everyone on completing Scratch 2 and becoming “Junior Scratch Game Designers!”
    • Give out certificates of completion for Scratch 2 or combined Scratch 1 & 2 certificates.
    • Encourage continued advanced Scratch exploration, suggest more complex projects, and potentially introduce other coding platforms for further learning.
    • Provide celebratory rewards (e.g., Scratch-themed goodies, coding books, or resources).

These two Scratch courses are designed to be progressive and engaging. Remember to adapt the complexity of projects and challenges based on the students’ skill levels and interests. Encourage creativity, collaboration, and a growth mindset throughout both courses!

Course Title: Junior Genius Robot Explorers: Unlocking VinciBot’s Adventures!

Age Group: 7–10 years

Course Synopsis: This 10-week course provides a foundational introduction to robotics and programming using the Matatalab VinciBot. Through hands-on activities and guided challenges, students will learn to program VinciBot using its graphical interface to perform various tasks, exploring concepts like sequences, loops, events, and conditional logic. The course emphasizes sensor exploration (sound, color, distance, light), problem-solving, collaborative projects, and building essential computational thinking, communication, and teamwork skills in an age-appropriate and engaging manner.

Tools: Matatalab VinciBot (Robot, Programming Platform – Website/App, Activity Cards as inspiration)

Session Duration: 1 hour 20 minutes

Week 1: Hello VinciBot! – Getting Started and Basic Movements

  • Learning Objective: Introduce VinciBot, its components, the graphical programming interface, and learn basic movement blocks (move forward, turn).
  • (15 min) Warm-up Game/Quick Review: “Robot Command Relay!”
    • Divide students into teams. Teams race to complete a relay where they act out robot commands (move forward, turn left, turn right) and verbally describe the commands.
  • (25 min) Concept Demo + Guided Practice: VinciBot Introduction & First Program
    • Introduce VinciBot: Show the robot, its features (sensors, lights, screen). Explain it’s a robot they can program.
    • Introduce the VinciBot programming platform (website/app). Tour the interface: Block categories (Motion, Events, etc.), programming area, robot connection.
    • Demonstrate connecting VinciBot and running a very simple program: when robot start -> move forward for 20 cm.
    • Guided practice: Students connect to VinciBot and program it to move forward and backward using different distances.
  • (30 min) Collaborative Project: “VinciBot Says Hello Dance!”
    • Pairs program VinciBot to do a simple “hello dance” using move forward, turn left/right, and show image (smiley face) blocks.
    • Challenge: Add sound effects or music to the dance using sound blocks.
  • (10 min) Share & Reflect: “Meet My VinciBot!”
    • Pairs showcase their VinciBot “hello dances.”
    • Discuss: “What did you learn about VinciBot and programming? What was easy/challenging?”


Week 2: Sequences and Paths – Programming VinciBot to Follow a Path

  • Learning Objective: Learn to program sequences of commands to make VinciBot follow a planned path (straight lines and simple turns).
  • (15 min) Warm-up Game/Quick Review: “Path Planning Puzzle!”
    • Give students simple path puzzles on paper (mazes with straight lines and right angles). They plan the sequence of “forward,” “turn left,” “turn right” to solve the maze without coding.
  • (25 min) Concept Demo + Guided Practice: Programming Sequences for Paths
    • Review sequences of commands. Explain how to combine move forward and turn blocks to create paths.
    • Demonstrate programming VinciBot to move in a square shape or an L-shape path.
    • Guided practice: Students program VinciBot to follow pre-drawn paths (straight lines, L-shapes) on paper or a mat.
  • (30 min) Collaborative Project: “VinciBot Maze Navigator!”
    • Pairs create a simple maze on paper or using tape on the floor (using straight lines and right angles).
    • Program VinciBot to navigate their maze from start to finish.
    • Challenge: Add obstacles to the maze and program VinciBot to navigate around them (using turns).
  • (10 min) Share & Reflect: “Maze Masters!”
    • Pairs showcase VinciBot navigating their mazes.
    • Discuss: “How did you plan your sequence of commands? What strategies did you use for turns?”


Week 3: Loops – Repeating Actions for Efficiency

  • Learning Objective: Introduce ‘repeat’ loops to make VinciBot repeat actions, making programs more efficient and creating repeating patterns.
  • (15 min) Warm-up Game/Quick Review: “Human Loop!”
    • Students perform repeating actions (clap 3 times, jump 4 times) on command. Relate to loops in programming.
  • (25 min) Concept Demo + Guided Practice: Using ‘Repeat’ Loops
    • Explain the concept of loops for repeating code blocks. Introduce the ‘repeat’ block in VinciBot’s programming environment.
    • Demonstrate using ‘repeat’ to make VinciBot move in a square (repeating forward and turn actions).
    • Guided practice: Students use ‘repeat’ loops to make VinciBot draw approximate shapes (squares, triangles – using movement and turn blocks within loops).
  • (30 min) Collaborative Project: “VinciBot Pattern Artist!”
    • Pairs program VinciBot to create repeating patterns on paper using markers attached to VinciBot (if possible, or visualize patterns on a mat).
    • Use ‘repeat’ loops to create patterns with movement and turns. Examples: spirals, zigzags, rows of squares.
    • Challenge: Create more complex patterns by nesting loops (loops inside loops).
  • (10 min) Share & Reflect: “Pattern Creators!”
    • Pairs showcase VinciBot’s pattern art.
    • Discuss: “What patterns did you create? How did ‘repeat’ loops make programming easier? Why are loops useful?”


Week 4: Events – VinciBot Reacts to Sound!

  • Learning Objective: Introduce event-driven programming using the ‘when loudness >’ event block to make VinciBot react to sounds.
  • (15 min) Warm-up Game/Quick Review: “Sound Trigger Actions!”
    • Assign actions to different sounds (clap = jump, snap = turn around). Teacher makes sounds, students perform actions. Relate to events triggering actions.
  • (25 min) Concept Demo + Guided Practice: ‘When Loudness >’ Event
    • Explain event-driven programming – programs react to events (like sounds). Introduce the ‘when loudness >’ event block.
    • Demonstrate programming VinciBot to react to a loud sound (e.g., clapping) by saying “Hello!” or changing LED color.
    • Guided practice: Students program VinciBot to react to different loudness levels with different actions (e.g., quiet sound = move forward slowly, loud sound = move fast).
  • (30 min) Collaborative Project: “VinciBot Sound-Activated Dance Party!”
    • Pairs create a “Sound-Activated Dance Party” program.
    • Use ‘when loudness >’ event to trigger different dance moves or light effects in VinciBot based on sound levels.
    • Challenge: Make VinciBot react to different types of sounds (if sound recognition is possible in VinciBot – otherwise, focus on loudness levels) or different sound patterns (sequences of claps).
  • (10 min) Share & Reflect: “Sound Reactors!”
    • Pairs showcase their sound-activated dance parties.
    • Discuss: “How did you make VinciBot react to sound? What other events could VinciBot react to?”


Week 5: Events – VinciBot Reacts to Color!

  • Learning Objective: Explore color sensing using the ‘when [color] color detected’ event block to make VinciBot react to different colors.
  • (15 min) Warm-up Game/Quick Review: “Color Command Game!”
    • Assign actions to different colors (red = move forward, blue = turn left, green = turn right). Show colored cards, students perform corresponding actions.
  • (25 min) Concept Demo + Guided Practice: ‘When [Color] Color Detected’ Event
    • Introduce color sensing. Show the ‘when [color] color detected’ event block.
    • Demonstrate programming VinciBot to react to a red card by stopping or saying “Red!”
    • Guided practice: Students program VinciBot to react to different colors with different actions (e.g., red = move forward, blue = turn left, green = turn right).
  • (30 min) Collaborative Project: “VinciBot Color Path Follower!”
    • Pairs create a simple path using colored tape or markers on paper (e.g., a path with red, blue, green sections).
    • Program VinciBot to follow the colored path. For example, when it detects red, move forward; when it detects blue, turn left; when it detects green, turn right.
    • Challenge: Make the color path more complex with branches and intersections.
  • (10 min) Share & Reflect: “Color Pathfinders!”
    • Pairs showcase VinciBot following their color paths.
    • Discuss: “How did VinciBot ‘see’ colors? How did you use color sensing to control VinciBot’s movement?”


Week 6: Events – VinciBot Reacts to Distance! (Proximity Sensor)

  • Learning Objective: Utilize the distance sensor (ToF LIDAR) and ‘when obstacle distance <‘ event block to make VinciBot react to objects in its proximity.
  • (15 min) Warm-up Game/Quick Review: “Distance Detectors!”
    • Students practice estimating distances (near, far). Discuss how robots can “see” distance with sensors.
  • (25 min) Concept Demo + Guided Practice: ‘When Obstacle Distance <‘ Event
    • Introduce the distance sensor on VinciBot. Show the ‘when obstacle distance <‘ event block.
    • Demonstrate programming VinciBot to stop or change direction when it gets close to an object (e.g., hand, book).
    • Guided practice: Students program VinciBot to react to different distance thresholds with different actions (e.g., close = stop, medium distance = slow down).
  • (30 min) Collaborative Project: “VinciBot Obstacle Avoider!”
    • Pairs create a simple obstacle course using cups or blocks.
    • Program VinciBot to navigate through the obstacle course autonomously, using the distance sensor to detect and avoid obstacles. Use ‘when obstacle distance <‘ event to trigger turning or moving backward to avoid collision.
    • Challenge: Make the obstacle course more complex and challenging to navigate.
  • (10 min) Share & Reflect: “Obstacle Avoidance Experts!”
    • Pairs showcase VinciBot navigating their obstacle courses.
    • Discuss: “How did the distance sensor help VinciBot avoid obstacles? How is this useful in real robots?”


Week 7: Conditionals – ‘If-Then’ Logic for Decision Making

  • Learning Objective: Introduce ‘if-then’ conditional statements to make VinciBot make decisions and perform actions based on conditions (using sensors).
  • (15 min) Warm-up Game/Quick Review: “If-Then Scenarios!”
    • Present “if-then” scenarios (e.g., “If it’s raining, then open an umbrella”). Students complete the “then” part. Relate to conditional logic in programming.
  • (25 min) Concept Demo + Guided Practice: ‘If-Then’ Blocks with Sensors
    • Explain conditional logic – making decisions based on conditions. Introduce the ‘if-then’ block.
    • Demonstrate using ‘if-then’ with a sensor condition. Example: “If obstacle distance < 20cm, then stop moving.”
    • Guided practice: Students use ‘if-then’ blocks with different sensor conditions (sound, color, distance) to control VinciBot’s actions.
  • (30 min) Collaborative Project: “VinciBot Smart Traffic Light!”
    • Pairs create a “smart traffic light” simulation using VinciBot.
    • Use color cards (red, green). Program VinciBot to act like a traffic light. For example, “If red color detected, then stop and show red light on VinciBot’s LEDs. If green color detected, then move forward and show green light.” (Use ‘if-then’ and color sensing).
    • Challenge: Add a “yellow light” state and more complex traffic light behavior with timers and sequences.
  • (10 min) Share & Reflect: “Decision Makers!”
    • Pairs showcase their VinciBot traffic light simulations.
    • Discuss: “How did ‘if-then’ blocks help VinciBot make decisions? Why is conditional logic important for robots?”


Week 8: Conditionals – ‘If-Else’ Logic for Two-Way Choices

  • Learning Objective: Expand conditional logic to ‘if-else’ statements, allowing VinciBot to perform different actions based on whether a condition is true or false, creating more complex behaviors.
  • (15 min) Warm-up Game/Quick Review: “If-Else Choices!”
    • Present “if-else” scenarios (e.g., “If it’s sunny, then wear sunglasses, else wear a hat”). Students complete the “else” part.
  • (25 min) Concept Demo + Guided Practice: ‘If-Else’ Blocks with Sensors
    • Introduce ‘if-else’ blocks. Explain how they provide two paths of action – one for ‘true’ condition, one for ‘false’.
    • Demonstrate using ‘if-else’ with a sensor condition. Example: “If loudness > 60, then say ‘Loud!’, else say ‘Quiet.'”
    • Guided practice: Students use ‘if-else’ blocks with sensor conditions to make VinciBot perform different actions in two different scenarios.
  • (30 min) Collaborative Project: “VinciBot Mood Robot!”
    • Pairs create a “Mood Robot” program for VinciBot.
    • Use the light sensor. Program VinciBot to detect light level. “If ambient light < 50 (dark), then show ‘sad’ face and say ‘It’s dark’, else (if light >= 50 – bright), show ‘happy’ face and say ‘It’s sunny.'” (Use ‘if-else’ and light sensing).
    • Challenge: Add more mood states based on different light levels or other sensor inputs (e.g., sound level for “noisy/quiet mood”).
  • (10 min) Share & Reflect: “Mood Programmers!”
    • Pairs showcase their VinciBot mood robots.
    • Discuss: “How did ‘if-else’ blocks make your robot’s behavior more complex? What other choices can robots make with ‘if-else’ logic?”


Week 9: Teamwork Challenge – VinciBot Rescue Mission!

  • Learning Objective: Combine all learned concepts (sequences, loops, events, conditionals, sensors) in a collaborative “rescue mission” challenge, promoting teamwork and problem-solving.
  • (15 min) Warm-up Game/Quick Review: “Mission Briefing!”
    • Present a “rescue mission” scenario involving VinciBot needing to navigate obstacles, follow paths, or react to events to “rescue” something (e.g., a toy, a marker). Brainstorm possible coding solutions as a class.
  • (25 min) Project Planning & Design: Rescue Mission Strategy
    • Explain the “VinciBot Rescue Mission” challenge. Define the goal (e.g., VinciBot needs to navigate a maze, avoid obstacles, and reach a “rescue zone”).
    • Divide students into teams. Teams plan their rescue mission strategy, decide which sensors and coding concepts to use, and sketch out their program.
  • (30 min) Collaborative Project: Team VinciBot Rescue Mission – Part 1
    • Teams work together to build their rescue mission arena (maze, obstacle course, etc.) and start programming VinciBot to complete the mission.
    • Encourage teamwork, communication, and problem-solving within teams.
  • (10 min) Share & Reflect: “Mission Progress Report!”
    • Teams briefly show their work-in-progress rescue missions and explain their approach and challenges.
    • Discuss: “What is your rescue mission goal? What coding strategies are you using? What challenges are you facing?”


Week 10: VinciBot Explorer Showcase – Your Creative Robotics Project!

  • Learning Objective: Complete team rescue mission projects, showcase projects, celebrate learning, and encourage continued robotics exploration.
  • (15 min) Warm-up Game/Quick Review: “Code Debugging Challenge!”
    • Present teams with short VinciBot code snippets with deliberate errors. Teams quickly identify and fix the bugs.
  • (35 min) Project Completion & Refinement: Finalizing Rescue Missions
    • Teams continue working on their VinciBot rescue mission projects, adding final features, refining code, and debugging.
  • (25 min) Showcase Time: “Junior Robot Explorer Showcase!”
    • Each team presents their completed VinciBot rescue mission to the class.
    • Teams demonstrate their robot completing the mission and explain their coding and design choices.
    • Encourage positive feedback and applause from classmates.
  • (10 min) Recap + Rewards: “Junior Robot Explorers!”
    • Congratulate everyone on completing the “Robot Explorers” course and becoming “Junior Robot Explorers!”
    • Give out certificates of completion for the VinciBot course.
    • Encourage continued robotics and coding exploration, suggest more advanced projects with VinciBot or other robotics platforms.
    • Provide celebratory rewards (e.g., robot-themed stickers, small STEM toys, coding resources, books about robotics for kids).

This “Junior Genius Robot Explorers” course using VinciBot is designed to be a fun, hands-on, and progressive introduction to robotics and coding for the 7-10 age group. Remember to adjust the complexity of challenges and projects based on the students’ skill levels and engagement. Encourage creativity, collaboration, and celebrate their achievements as they become Junior Robot Explorers!

Course Title: Junior Genius AI/ML Explorers: Making Computers Smart with Scratch!

Age Group: 7–10 years

Course Synopsis: This 10-week course introduces young learners to the exciting world of Artificial Intelligence (AI) and Machine Learning (ML) using Scratch with AI extensions. Through block-based programming and guided challenges, students will explore fundamental AI/ML concepts like data, patterns, predictions, and simple classification. The course emphasizes hands-on activities, collaborative projects, and building computational thinking, communication, and teamwork skills, while setting a strong foundation for understanding AI/ML and Data Science in an age-appropriate way.

Tools: Scratch (web-based or offline editor) with AI extensions or functionalities (e.g., if using extensions like Machine Learning for Kids integration, PictoBlox, or focusing on conceptual understanding using Scratch’s built-in capabilities for simplified AI demonstrations). If specific AI extensions are not readily available, the course can be adapted to focus on the core concepts of data, patterns, and algorithms using Scratch’s standard features to simulate AI behaviors.

Session Duration: 1 hour 20 minutes

Week 1: What is AI? – Making Computers Think!

  • Learning Objective: Introduce the basic concept of Artificial Intelligence (AI) – making computers think and solve problems like humans.
  • (15 min) Warm-up Game/Quick Review: “Human vs. Computer!”
    • Play a simple game comparing human and computer abilities (e.g., quick math problems – humans are good at creative problem solving, computers are fast at calculations). Discuss: What are computers good at? What are humans good at? Can we make computers smarter?
  • (25 min) Concept Demo + Guided Practice: “Smart” Behaviors in Scratch
    • Discuss: What does it mean for a computer to be “smart”? (Following instructions, making decisions, learning).
    • In Scratch, demonstrate simple “smart” behaviors using code. Example: A sprite moves towards the mouse pointer automatically (simulating intelligent following). Use ‘point towards mouse-pointer’ and ‘move steps’ blocks.
    • Guided practice: Students make their sprites exhibit simple “smart” behaviors in Scratch.
  • (30 min) Collaborative Project: “Smart Robot Dance!”
    • Pairs create a “smart robot” sprite in Scratch that can dance automatically.
    • Program the robot to perform a sequence of dance moves (using loops and motion blocks) when the green flag is clicked. Discuss: Is this robot “smart”? It follows instructions, but does it learn or think?
    • Challenge: Add user interaction – make the robot dance differently if a key is pressed (more “smart” behavior based on input).
  • (10 min) Share & Reflect: “Is My Robot Smart?”
    • Pairs showcase their “smart robot dances.”
    • Discuss: “What makes your robot seem ‘smart’? Is it really intelligent? What’s the difference between following instructions and true AI?”


Week 2: Data Detectives – Exploring Data and Information

  • Learning Objective: Introduce the concept of data as information computers use to learn, and explore different types of data.
  • (15 min) Warm-up Game/Quick Review: “Data Collection Challenge!”
    • Quickly collect data from students (e.g., favorite color, pet, etc.) and write it on the board. Discuss: What is this? (Information, data).
  • (25 min) Concept Demo + Guided Practice: Data in Scratch (Variables & Lists)
    • Discuss: What is data? (Facts, numbers, words, pictures – anything that gives information). Where do computers get data? (From us, sensors, internet).
    • In Scratch, show how variables and lists can store data. Create a variable to store “score,” a list to store “names.”
    • Guided practice: Students create variables and lists in Scratch to store simple data.
  • (30 min) Collaborative Project: “Data Display Animation!”
    • Pairs create a Scratch project that displays data in a visual way.
    • Example: Create a list of favorite fruits. Program sprites to represent each fruit and display them on the stage, maybe with size proportional to how popular each fruit is (if you collected frequency data).
    • Challenge: Make the data display interactive – let users add new data and see the display update.
  • (10 min) Share & Reflect: “Data is Everywhere!”
    • Pairs showcase their data display animations.
    • Discuss: “What data did you display? Why is data important for computers and AI?”


Week 3: Patterns Everywhere – Finding Patterns in Data

  • Learning Objective: Introduce the concept of patterns in data and how AI/ML can find and use patterns to make predictions.
  • (15 min) Warm-up Game/Quick Review: “Pattern Recognition Game!”
    • Show simple visual patterns (shapes, colors). Students identify and continue the pattern. Discuss: What is a pattern? Why are patterns useful?
  • (25 min) Concept Demo + Guided Practice: Pattern Recognition in Scratch (Simple Sequence)
    • Discuss: What are patterns? (Repeating sequences, trends). Why are patterns important for AI? (To learn and predict).
    • In Scratch, demonstrate a simple pattern recognition example. Example: Program a sprite to move in a repeating pattern (square, circle) using loops.
    • Guided practice: Students create sprites that move in repeating patterns using loops.
  • (30 min) Collaborative Project: “Pattern Dance Challenge!”
    • Pairs create a “Pattern Dance Challenge” game.
    • Program a sprite to perform a dance sequence with a pattern (e.g., move forward 2 steps, turn right, move forward 2 steps, turn left, repeat).
    • Challenge: Make the pattern more complex and let users try to guess the pattern by observing the dance.
  • (10 min) Share & Reflect: “Pattern Detectives!”
    • Pairs showcase their “Pattern Dance Challenges.”
    • Discuss: “What patterns did you create? Why is finding patterns important for AI/ML?”


Week 4: Making Predictions – Using Patterns to Guess What’s Next

  • Learning Objective: Introduce the idea of prediction in AI/ML – using patterns in data to guess or forecast future outcomes.
  • (15 min) Warm-up Game/Quick Review: “Prediction Game!”
    • Start a simple sequence (e.g., clap, stomp, clap, stomp…). Students predict what comes next. Discuss: How did you predict? (Based on the pattern).
  • (25 min) Concept Demo + Guided Practice: Simple Prediction in Scratch (If-Else based on Variable)
    • Discuss: What is prediction? (Guessing what will happen next based on patterns). How does AI predict? (Using data and patterns).
    • In Scratch, demonstrate a simple prediction example. Example: Create a variable for “weather” (sunny/rainy). Program a sprite to say “Wear sunglasses” if weather is “sunny”, else say “Take an umbrella” using ‘if-else’ and variable comparison.
    • Guided practice: Students create simple prediction projects in Scratch using ‘if-else’ and variables.
  • (30 min) Collaborative Project: “Fortune Teller Game!”
    • Pairs create a “Fortune Teller” game.
    • Based on user input (e.g., choosing a number, color), program the game to give a “prediction” or fortune using ‘if-else’ and random number generation. (Keep predictions lighthearted and fun).
    • Challenge: Make the fortune teller more interactive and visually appealing.
  • (10 min) Share & Reflect: “Crystal Ball Coders!”
    • Pairs showcase their “Fortune Teller” games.
    • Discuss: “How did your game make predictions? Is it real prediction or just fun? How does real AI make predictions?”


Week 5: Classification – Sorting Things into Categories

  • Learning Objective: Introduce the concept of classification in AI/ML – sorting data into different categories or groups based on features.
  • (15 min) Warm-up Game/Quick Review: “Sorting Game!”
    • Give students a set of objects (or pictures). Ask them to sort them into categories (e.g., by color, shape, animal type). Discuss: What is sorting? Why do we sort things?
  • (25 min) Concept Demo + Guided Practice: Simple Classification in Scratch (If-Else based on Sprite Property)
    • Discuss: What is classification? (Sorting things into groups). How does AI classify? (By looking at features or characteristics).
    • In Scratch, demonstrate simple classification. Example: Create sprites of different colored balls (red, blue, green). Program sprites to “go to” different zones on the stage based on their color using ‘if-else’ and ‘touching color’ or variable representing color.
    • Guided practice: Students create simple classification projects in Scratch, sorting sprites based on a property (color, size, name – using variables).
  • (30 min) Collaborative Project: “Animal Classifier Game!”
    • Pairs create an “Animal Classifier” game.
    • Use sprites representing different animals (e.g., cat, dog, bird). Program the game to ask “Is it a pet or wild animal?” and based on user choice, move the animal sprite to the “Pet” or “Wild” zone on the stage using ‘if-else’.
    • Challenge: Add more animal categories and features for classification.
  • (10 min) Share & Reflect: “Category Creators!”
    • Pairs showcase their “Animal Classifier” games.
    • Discuss: “How did your game classify animals? What features did you use? How does real AI classify things?”


Week 6: Training a Machine – Teaching the Computer to Recognize Patterns (Simplified)

  • Learning Objective: Introduce the basic idea of “training” a machine learning model – showing the computer examples to learn from and improve its predictions or classifications (simplified conceptual understanding).
  • (15 min) Warm-up Game/Quick Review: “Teaching Game!”
    • Teacher acts as a “computer.” Students “teach” the teacher to recognize something (e.g., clap when they see a red card, stomp when they see a blue card) by showing examples and giving feedback. Discuss: What is teaching? What is learning?
  • (25 min) Concept Demo + Guided Practice: Simulated “Training” in Scratch (Manual “Learning” – If/Else adjustments)
    • Discuss: How do we teach a computer? (By showing it examples, giving feedback, letting it learn from data – “training”). Simplified explanation – focus on showing examples and adjusting rules based on mistakes.
    • In Scratch, demonstrate a very simplified “training” process. Example: Start with a simple “classifier” that sorts shapes based on one rule (e.g., “If it’s round, it’s a circle”). Test it. If it makes mistakes, “adjust” the rule (e.g., “If it’s round and red, it’s a circle” – manually adjust ‘if-else’ conditions based on simulated “mistakes”).
    • Guided practice: Students manually “train” a simple classifier in Scratch by adjusting ‘if-else’ conditions based on simulated examples and feedback.
  • (30 min) Collaborative Project: “Shape Training Game!”
    • Pairs create a “Shape Training” game.
    • Start with a very simple shape classifier (e.g., tries to classify squares and triangles based on a simple visual feature – maybe number of corners, very simplified).
    • “Train” the classifier by manually adjusting ‘if-else’ rules based on example shapes you provide.
    • Challenge: Make the training process more interactive – let users provide feedback (correct/incorrect classification) and adjust the rules based on user feedback.
  • (10 min) Share & Reflect: “Machine Trainers!”
    • Pairs showcase their “Shape Training” games.
    • Discuss: “How did you ‘train’ your classifier? Is it real machine learning? What do real ML models learn from?”


Week 7: AI in Our World – Real-World Examples of AI/ML

  • Learning Objective: Explore real-world examples of AI/ML applications in everyday life, broadening understanding of AI’s impact and relevance.
  • (15 min) Warm-up Game/Quick Review: “AI Brainstorm!”
    • Ask students: “Where do you see AI in the real world?” Brainstorm examples together (Siri, Google, recommendations, self-driving cars).
  • (25 min) Concept Demo + Guided Practice: Exploring AI Examples (Videos/Images)
    • Discuss: Where is AI used in real life? Show short age-appropriate videos or images of AI applications (voice assistants, image recognition, recommendation systems, medical AI, etc.).
    • Guided discussion: Talk about each example – what problem does it solve? How does AI help?
    • In Scratch (optional): If possible and age-appropriate, demonstrate a very simplified simulation of a real-world AI application in Scratch (e.g., a basic recommendation system based on user preferences – using lists and variables – highly simplified).
  • (30 min) Collaborative Project: “AI in My Life Presentation!”
    • Pairs choose one real-world AI application they learned about or find another example (with guidance).
    • Create a short presentation (using drawings, simple slides, or just verbal presentation) explaining: What is the AI? How does it work? How is it helpful?
    • Challenge: Think about the benefits and potential downsides of their chosen AI application (simplified ethical considerations).
  • (10 min) Share & Reflect: “AI Experts!”
    • Pairs present their “AI in My Life” presentations.
    • Discuss: “Where is AI used in the real world? Is AI always helpful? What are some things to think about when using AI?”


Week 8: Data Bias – Fairness and Accuracy in AI (Simplified)

  • Learning Objective: Introduce the concept of data bias in AI/ML, understanding that AI can be unfair or inaccurate if trained on biased data (simplified ethical introduction).
  • (15 min) Warm-up Game/Quick Review: “Biased Game!”
    • Play a game where the rules are unfair to one group of students. Discuss: Is this fair? What if a computer program was unfair like this?
  • (25 min) Concept Demo + Guided Practice: Simulating Bias in Scratch (Simplified Example)
    • Discuss: What is bias? (Unfairness, favoring one group over another). Can AI be biased? (Yes, if the data it learns from is biased). Why is bias bad in AI? (Can lead to unfair decisions).
    • In Scratch, demonstrate a simplified example of bias. Example: Create a “classifier” that is supposed to guess if a sprite is “happy” or “sad” based only on its color. Show that color is not a good feature and can lead to biased classifications (e.g., always classifying blue sprites as “sad” even if they are not).
    • Guided discussion: Why is color a biased feature for happiness? What would be better features?
  • (30 min) Collaborative Project: “Unbiased Classifier Challenge!”
    • Pairs try to create a less biased classifier in Scratch.
    • Continue the shape classifier from Week 6, but now focus on using better features for classification (e.g., shape type, not just color).
    • Discuss and test: Is your classifier less biased now? How can we make AI more fair? (Use diverse data, think about features carefully).
    • Challenge: Think about real-world examples of bias in AI and how to avoid them (simplified discussion).
  • (10 min) Share & Reflect: “Fairness in AI!”
    • Pairs showcase their “Unbiased Classifier Challenges.”
    • Discuss: “What is data bias? Why is it important to make AI fair? How can we reduce bias in AI?”


Week 9: Teamwork Project – AI-Powered Story Game Design

  • Learning Objective: Combine learned AI/ML concepts in a collaborative project to design a story game with simple AI elements, reinforcing teamwork and creative application of AI understanding.
  • (15 min) Warm-up Game/Quick Review: “AI Story Ideas!”
    • Teams brainstorm ideas for a story game that uses some AI/ML concepts they’ve learned (prediction, classification, pattern recognition – simplified).
  • (25 min) Project Planning & Design: AI Story Game Concept
    • Teams refine their story game ideas, decide on a story, characters, and how to incorporate simple AI elements into the gameplay.
    • Plan the different parts of the game, divide tasks within the team.
  • (30 min) Collaborative Project: Team AI Story Game Development – Part 1
    • Teams start developing their AI-powered story games in Scratch, focusing on story elements, sprite design, and implementing simple AI mechanics.
    • Provide support and guidance as teams work.
  • (10 min) Share & Reflect: “AI Story Game Progress!”
    • Teams show their work-in-progress games and explain their game design and AI elements.
    • Discuss: “What is your story about? How are you using AI concepts in your game? What challenges are you facing?”


Week 10: AI/ML Explorer Showcase & Creative Project – Junior AI/ML Explorers!

  • Learning Objective: Complete team AI story game projects, showcase projects, celebrate learning, and encourage continued AI/ML exploration.
  • (15 min) Warm-up Game/Quick Review: “AI Ethics Review!”
    • Quickly review the concept of data bias and fairness in AI.
  • (35 min) Project Completion & Refinement: Finishing Touches on Team AI Story Games
    • Teams continue working on their AI story games, adding final features, levels, polish, and addressing any ethical considerations (fairness, representation in their game stories – age-appropriate).
  • (25 min) Showcase Time: “Junior AI/ML Explorer Showcase!”
    • Each team presents their completed AI story game to the class.
    • Teams can have a demo, explain their game design, AI/ML concepts they incorporated, and what they learned about AI ethics.
    • Encourage positive feedback and appreciation from classmates and potentially invite others to play their games.
  • (10 min) Recap + Rewards: “Junior AI/ML Explorers!”
    • Congratulate everyone on completing the “AI/ML Explorers” course and becoming “Junior AI/ML Explorers!”
    • Give out certificates of completion for the AI/ML course.
    • Encourage continued exploration of AI/ML, suggest further learning resources (age-appropriate websites, books, online courses).
    • Provide celebratory rewards (e.g., AI/robot-themed stickers, small STEM toys, coding resources, books about AI for kids).

This “Junior Genius AI/ML Explorers” course is designed to be an engaging introduction to AI/ML for young learners using Scratch. Remember to adapt the complexity based on the students’ understanding and access to specific AI extensions in Scratch. If full AI extensions are limited, focus on the core concepts and use Scratch’s built-in features creatively to simulate and demonstrate AI/ML principles. Prioritize hands-on activities, discussions, and creative projects to make learning fun and impactful!