Lesson 3 of 64 in this sequence

Not completed yet

Saved on this device only — not synced to an account yet.

Learning path

Step 3 of 64

Continue the sequence

ResumeReturn to this step ReviewRevisit the core idea RemediateGet repair practice Next stepChoose the next lesson manually

Completion

Review objectives and instruction
Complete the activity with manual learner confirmation
Answer every understanding-check item
Show completion feedback and reward only after the learner finishes the check

Progress

Step 3/64
15 content types
AI help source context available
Auto-advance blocked

Review objectives and instruction

AI help

Available only with source grounding, privacy limits, age controls, and measurement.

AI source context

Debugging: Find and Fix Your Program's Bugs · Debugging is systematically testing a program to locate an error and correct it. · 1B-AP-15

Evidence: local lesson AI-help metadata only; source-grounding, privacy, age-safety, and measurement hooks do not prove real model quality, production telemetry, child AI approval, or AI tutor production readiness

Production AI readiness not claimed

AI source context

Assessment shape

Local lesson assessment shape is complete.

Local shape only; production answer-attempt telemetry, live ownership/RLS evidence, mastery interpretation, release, and production readiness are not claimed here.

Objectives: 4
Activity: Prompt ready
Quiz items: 3 items, 3 answer keys, 3 explanations
Reward: Completion reward ready

Assessment progress stays manual: do not auto-advance through uncertain answers, failed writes, consent, media, payment, learner choice, or AI-assisted checks.

Learning-loop evidence: Content-map contract only; persistence and production learner-progress writes require route/API evidence.

Manual policy: assessment, media, consent, payment, learner choice, failed writes, and AI-uncertain help stay under learner control.

Prerequisite: Complete or review Debugging a Program by Testing One Step at a Time; Use with parent or guardian controls for child learners

AI guardrails

Privacy

Do not send raw child free text without consent
Use source excerpts and non-identifying progress state only
Asset is not registry-gated

Age safety

Apply kids audience controls before AI-help claims
Keep child learner AI paths behind guardian/product review evidence before readiness claims

Measurement

Log AI help usage by surface and asset slug
Evaluate answer quality against source-grounded rubric before production-readiness claims
Tie remediation prompts to completion, retry, or review outcomes

Local AI-help guardrails only; they do not prove guardian approval, production telemetry, model evaluation, release, deployment, or AI tutor production readiness.

Source and rights

Source path: koydo-app/scripts/curriculum-authoring
License: ai-generated-koydo
Attribution: Attribution decision needs owner review
AI provenance: claude-opus-4-8

Source review gates: attribution_missing

Local source evidence only; this does not prove publication rights, attribution approval, AI provenance clearance, release, deployment, or production readiness.

Route review

Current route: /library/kids/computer_science/en/lesson/find-and-fix-bugs
Route source: Fallback route needs owner canonical review
Candidate route: /library/kids/computer_science/en/lesson/find-and-fix-bugs

Local route evidence only; fallback candidates need owner-approved canonical route policy before route writes, production discoverability, or readiness claims.

Content gates: canonical_target_web_missing_uses_library_fallback

lessonslessonslesson objectivesmedia scenesdrillspractice setsquizzesfeedbackcharacterscitationsconcept mapsprogressresumereviewremediationnext steps

Debugging: Find and Fix Your Program's Bugs

with Byte

Byte the friendly robot kneels beside a winding floor maze, holding a glowing checklist and pointing at one wrong arrow card while a toy rover waits to move

Define debugging as testing a program to find and fix a mistake.
Run a program step by step to locate exactly where it goes wrong.
Change one step at a time and test again to check the fix.
Explain why guessing and changing many steps at once makes bugs harder to find.

Key terms

Bug: A wrong step in a program.
Debugging: Finding and fixing a program's mistake.
Step: One instruction the computer follows in order.
Test: To run a program and watch it.

What Debugging Means

A program is a list of steps the computer follows in order. Sometimes one step is wrong, so the program does the wrong thing. That mistake is called a bug. Finding the bug and fixing it is called debugging. Every coder debugs, so it is a normal and helpful skill to have.

The Four Detective Moves

Good debugging has four moves. First, run the program and watch what really happens. Second, find the exact step where things go wrong by checking one step at a time. Third, fix only that one wrong step. Fourth, test again to make sure the program works now. Slow and careful wins.

Change Only One Step

It is tempting to change many steps at once, but that makes bugs harder to find. If you change lots of steps together, you cannot tell which change helped or which one made a new problem. Change one step, test, and check. That way you always know exactly what your fix did.

Worked examples

Rover should go UP, RIGHT but goes UP, UP.

Check step one: the first UP matches the plan, so it is fine.
Check step two: the plan says RIGHT but it says UP, so that is the bug.

Answer: Change the second step to RIGHT, then test again.

Put these debugging moves in order.

First run the program and watch it.
Then find the wrong step, fix only it, and test again.

Answer: Run, find, fix, then test again.

Hi, I'm Byte! A program is just a list of steps a computer follows in order. Sometimes a step is wrong, so the program does the wrong thing. That mistake is called a bug, and fixing it is called debugging. Here is my secret: I don't guess wildly. I debug slowly and carefully, like a detective. First I RUN the program and watch what really happens. Then I FIND the exact step where things go wrong by checking one step at a time. Next I FIX only that one wrong step. Last, I TEST again to make sure it works now. Here's a real example. Say my rover should go UP, RIGHT to reach the star, but it goes UP, UP and misses the star. I check step one: the first UP is correct — the rover should go UP there. Good. Now I check step two: the second arrow says UP, but the plan says RIGHT. That second step is the bug! I change only that one arrow to RIGHT and test again. One step at a time — that's the key. If you ever feel stuck, slow down, point at each step out loud, and ask: 'Did THIS step do what I wanted?' The first step that surprises you is your bug.

Activity

Byte mixed up the debugging steps! Drag them into the correct order to fix a buggy program

Practice

List the four debugging moves in the correct order.

Explain why changing many steps at once is a bad idea.

Common mistakes to avoid

Guess and change many stepsChange one step at a time so you know what fixed the bug.
Restarting the computer fixes bugsRestarting does not change your steps, so the bug stays there.

Check your understanding

What does 'debugging' mean?

A bug is hiding somewhere in your steps. What is the smartest way to find it?

Your rover should go UP, RIGHT but it goes UP, UP and misses the star. The first UP is correct. Where is the bug?

Recap

Debugging means finding and fixing a wrong step in a program. Run the program, find the exact step that goes wrong, fix only that one step, and test again. The first step that surprises you is your bug, so go slow.

Reflect

What surprising step would you check first when debugging?