Module 6 Parent Guide – Think Like a Coder

Module Overview

Topic: Debugging -- Finding and Fixing Mistakes

Ages: 6-10 years old

Total Time: 60-80 minutes across 4 lessons

Big Idea: Mistakes are not failures -- they are clues. Learning to find and fix errors calmly and step by step is one of the most important life skills a child can develop.

Lesson Breakdown

Lesson 1: Mistakes Are Clues (15-20 min, Screen-Free)
Growth mindset, Grace Hopper and the first bug, the power of "yet," famous people who failed first.

Lesson 2: Finding Bugs Step by Step (15-20 min, Screen-Free)
The 4 debugging detective steps: expect, observe, check one thing, fix and test. The 3 most common bug types.

Lesson 3: Debugging Everyday Life (15-20 min, Screen-Free)
Troubleshooting real-world problems, debugging flowcharts, the "check simple stuff first" rule, rubber duck debugging.

Lesson 4: Debugging in Scratch (15-20 min, Scratch)
The 5 most common Scratch bugs, hands-on debug challenges with broken code, the Scratch debugging checklist.

Key Vocabulary

Word	Kid-Friendly Definition	Example
Bug	A mistake that makes something not work right	Turning left when you meant to turn right
Debugging	Finding and fixing bugs, like a detective	Figuring out why the flashlight does not turn on
Growth mindset	Believing you can get better with practice	"I cannot do it yet, but I will keep trying"
Flowchart	A diagram with questions and arrows to guide problem-solving	A step-by-step guide for fixing a flashlight
Wrong step	A step that has the wrong information	Saying "turn left" when you meant "turn right"
Missing step	A step that was left out completely	Forgetting to add sugar to lemonade
Wrong order	Steps that are correct but in the wrong sequence	Putting on shoes before socks
Rubber duck debugging	Explaining a problem out loud to find what you missed	Telling a stuffed animal about your code, block by block

What to Say (and What Not to Say)

Your words have a huge impact on how your child handles mistakes. Here is a guide:

Instead of This...	Try This...
"What did you do wrong?"	"Interesting! What happened there? Let us figure it out."
"That is not right."	"That is not what we expected. What a great clue!"
"Let me just fix it for you."	"Where should we start looking for the bug?"
"You made an error."	"You found a bug! Now let us debug it."
"This should be easy."	"This is a tricky one. Let us think it through step by step."

Teaching Tips

Model your own mistakes. Make errors on purpose while working together and say: "Oops, I made a bug! Let me debug it." This shows your child that mistakes are normal and fixable.

Celebrate the bug, not just the fix. Say "Great find!" when your child spots a bug. Finding bugs is a skill in itself and deserves recognition.

Use the word "yet" constantly. Turn "I cannot" into "I cannot yet." This tiny word changes the whole meaning of a sentence and builds resilience over time.

Resist the urge to jump in. When your child is stuck, wait before helping. Ask guiding questions: "What did you expect?" "What actually happened?" "What should we check first?" Let them be the detective.

Make debugging physical. Use paper instructions, recipe cards, or building steps. Finding bugs in real-world instructions is easier to understand than finding bugs in code.

Take real breaks. If frustration is building, take a 5-minute break. Walk around, get water, stretch. Coming back with fresh eyes often makes the bug obvious.

The 4 Debugging Detective Steps (Poster)

Consider writing these on a poster or sticky note and putting it near the computer:

EXPECT: What should happen?
OBSERVE: What actually happened?
CHECK: Look at one thing at a time.
TEST: Fix one thing, then try again.

Common Questions Kids Ask

"Why does my code not work?"

This is the debugging question! Instead of answering directly, guide them through the 4 detective steps. Help them get specific about what "does not work" actually means.

"Is it okay to make mistakes?"

Absolutely yes! Every professional coder makes mistakes every day. Mistakes are how we learn. The goal is never to be perfect -- it is to get better at finding and fixing problems.

"Why is debugging so hard?"

Debugging feels hard when you do not know where to start. That is why we use the detective steps. Once you have a system, debugging becomes a puzzle to solve, not a mountain to climb.

"Can I just start over instead of debugging?"

Sometimes starting over makes sense for very short programs. But for longer projects, debugging is better because: (1) you learn what went wrong, (2) you keep all the parts that work, and (3) starting over does not guarantee you will not make the same mistake again.

Extension Activities

Debugging journal: Keep a running log of bugs found and fixed. Over time, your child will see patterns in their mistakes and catch them faster.
Break it on purpose: Build a working Scratch project together, then take turns hiding one bug. The other person must find and fix it.
Real-world debugging day: Spend a day noticing whenever anyone in the family "debugs" something -- fixing a stuck drawer, adjusting a recipe, troubleshooting Wi-Fi.
Rubber duck friend: Let your child pick a small toy to be their "debugging buddy" that sits near the computer. Encourage them to explain problems to it.

What Comes Next

In Module 7: Your First Big Project, your child will combine everything they have learned -- sequences, patterns, loops, and debugging -- to plan, build, and share their own Scratch project from start to finish. The debugging skills from this module will be essential as they work through a larger, more creative project.

Module 6: Parent Guide