Blocks to Bots: A 4-Week Roadmap from ScratchJr to Simple AI Games (Ages 6–8)

Why this roadmap works for ages 6–8

If you’ve been Googling how to teach coding to a 7 year old and feeling overwhelmed, here’s the good news: kids don’t need “real code” to learn real coding thinking. Ages 6–8 are perfect for building the foundations—sequencing, loops, events, debugging, and design—using friendly block-based tools.

This 4-week roadmap starts with ScratchJr (made for young kids) and ends with simple, playful “AI-like” games. By “AI” here, we mean beginner-friendly ideas such as:

• A character that “recognizes” simple patterns (like sorting things by color or shape)
• A game that “learns” your preference by counting what you click most
• A bot that makes decisions using rules (if/then) and randomness

It’s not about complex machine learning. It’s about teaching kids how smart behaviors are built—step by step—so they feel empowered, not intimidated.

What you’ll need:

• 15–25 minutes a day, 4–5 days per week
• A tablet for ScratchJr (iPad/Android/Chromebook depending on availability)
• A curious kid and a patient grown-up
• Optional: paper, markers, and small toys for offline “coding games”

Your 4-week coding roadmap (with daily bite-size plans)

Below is a practical plan you can follow. The goal is one small win per session—something your child can show you at the end.

Week	Main skill	What your child will build	Parent job (2 minutes)	“Done” checklist
1	Sequencing + events	Mini story and a “tap to start” scene	Ask: “What happens first?”	Has a beginning, middle, end; uses a start trigger
2	Loops + timing	Dance party / parade animation	Ask: “Can we make it repeat?”	Uses repeat block; uses wait/speed to control timing
3	Variables (kid version) + scoring	Simple game: collect items, avoid obstacle	Ask: “How do we keep score?”	Has a goal; has a score or counter; has a win/try again
4	Beginner AI behaviors	AI-style game: helper bot, sorting bot, or preference bot	Ask: “How does the bot decide?”	Uses if/then rules or pattern matching; explains bot logic

A note on pacing: if your child is brand new to ScratchJr, take two weeks for Weeks 1–2. If they’re already comfortable, you can move faster.

Week-by-week: ScratchJr projects for kids (and exactly what to do)

This is the heart of the plan—specific ScratchJr projects for kids, with prompts you can use at home.

Week 1: “Make it move” stories (sequencing + events)

Goal: your child learns that programs are ordered steps.

Try these 3 mini-projects (pick one per day):

• The Lost Cat Story: A cat walks, meets a friend, and gets home.
• Rocket Launch: Countdown, blast off, land on a planet.
• Morning Routine: Wake up, brush teeth, eat breakfast.

Parent-friendly prompts (these work better than instructions):

• “What should happen first so the story makes sense?”
• “Can we make it start when you tap the character?”
• “If it goes wrong, which step would you change?”

Debugging habit to teach now:

• One change at a time. Kids love to drag lots of blocks quickly; encourage them to test after each small change.

Week 2: Loops and timing (make animations that feel alive)

Goal: your child learns repetition and rhythm—core concepts for games.

Project ideas:

• Dance Party: Two characters repeat dance moves in a loop.
• Animal Parade: Characters march across the screen forever.
• Weather Machine: Sun appears, clouds roll in, rain falls, repeat.

Mini-challenges to level up:

• Add a repeat so a move happens 5 times.
• Use wait blocks to create a beat (fast/slow).
• Trigger two characters at once (a simple “event” lesson).

How this supports a coding roadmap for ages 6-8:

• Week 1 gives your child control.
• Week 2 makes control predictable—“I can make it repeat exactly.”

That predictability is what makes games possible.

Week 3: First real game thinking (goals, rules, scoring)

Goal: turn animations into interactive games with rules.

At ages 6–8, “variables” can feel abstract. So we teach the kid-friendly version: a counter (score) and a goal (win condition).

Choose one simple game pattern:

• Collect Game: Move a character to collect stars.
• Avoid Game: Don’t touch the bouncing obstacle.
• Maze Game: Navigate to a treasure.

Add these game essentials:

• Start screen: “Tap to play.”
• Rules: “If you touch X, you lose a life / try again.”
• Score: “Each star collected = +1.”
• Win: “Get 5 stars to win.”

Parent prompts (these prevent frustration):

• “What’s the goal of your game in one sentence?”
• “What makes it hard—but not too hard?”
• “How will the player know they won?”

A great family rule here: Your child is the designer; you are the playtester.

• You play silently once.
• Then say one thing you liked.
• Then ask one question: “What should I do next?”

That’s how real game studios work, and kids love being taken seriously.

Week 4: Beginner AI games for kids (simple, explainable “smart” behaviors)

Now that your child can make a game, you can introduce AI as “a character that makes decisions.” The key at this age is explainable AI—your child should be able to say what the bot is doing.

Here are three beginner AI games for kids you can build using rules, counting, and patterns.

Option A: The Sorting Bot (pattern recognition)

Concept: AI “recognizes” categories.

Build:

• Create 3 baskets (e.g., red, blue, green).
• Make objects appear (colored balls, shapes, animals).
• The bot moves the object into the matching basket.

How it’s “AI-like”:

• It’s doing classification (sorting by a feature).

Parent prompt:

• “What feature is the bot using—color, shape, or size?”

Upgrade:

• Make “tricky” objects (striped, mixed colors) and decide the rule together.

Option B: The Helper Bot (if/then decisions)

Concept: AI chooses an action based on what’s happening.

Build:

• A player character tries to reach a goal.
• A helper bot watches (simple trigger) and reacts.

Examples:

• If the player is near an obstacle, the bot warns them.
• If the player taps “Help,” the bot points toward the goal.

How it’s “AI-like”:

• It’s decision-making with if/then rules (the simplest form of intelligent behavior).

Parent prompt:

• “What does the bot need to notice to decide?”

Option C: The Preference Bot (learning with counting)

Concept: AI “learns” what you like based on repeated choices.

Build:

• Show two options (e.g., cats vs. dogs).
• Each time the player taps one, a hidden counter goes up.
• After 5 taps, the bot announces: “You like cats more!”

How it’s “AI-like”:

• It’s a toy version of learning from data (the data is your clicks).

Parent prompt:

• “What’s the evidence the bot is using?”

Important note for parents: This is a great moment to teach that AI can be wrong.

• “What if you clicked dogs first, but you really like cats?”
• “Does the bot know you, or only your taps?”

That simple conversation is early AI literacy.

Troubleshooting: how to teach coding to a 7 year old without power struggles

Even the best roadmap needs a few guardrails. Here are practical fixes that work in real homes.

Common hiccups and what to do:

• “It’s not working!”

  • Say: “Show me what you expected.” (Not: “You did it wrong.”)
  • Then: test one block at a time.

• They copy you instead of thinking.

  • Ask them to be the teacher: “Tell me what to drag next.”

• They want to start over constantly.

  • Make a rule: “We save versions.”
  • Version names: v1, v2, v3 (kids love feeling professional).

• They get stuck in decoration mode.

  • Use a timer: 5 minutes art, 10 minutes coding, 5 minutes playtest.

• You’re not a ‘tech parent.’

  • Perfect. Your job isn’t to know answers—it’s to model curiosity:
    • “Let’s test it.”
    • “What happens if we change this?”
    • “How could we make it easier/harder?”

This approach keeps coding playful while still building real skills.

Next Steps: turn this roadmap into a routine (and keep momentum)

To keep progress going after these four weeks, aim for a simple rhythm: build, share, improve.

Here’s a ready-to-use plan for the next month:

• Week A (Build): Make a new game with one new mechanic (speed, timer, extra level).
• Week B (Share): Your child presents the game to family and explains the rules.
• Week C (Improve): Add difficulty options: easy/medium/hard.
• Week D (AI Twist): Add a bot behavior: sorting, helper rules, or preference counting.

If you want an even smoother path, Intellect Council lessons can guide your child from block coding to beginner-friendly AI concepts with interactive challenges and built-in motivation—so you’re not hunting for the next project every week.

Your simple “start today” checklist:

• Pick one project from Week 1 and do a 15-minute session.
• End by asking: “What do you want to add tomorrow?”
• Save the project and celebrate the smallest working piece.

That’s how blocks become bots—one confident step at a time.