Build a Simple Chatbot in Scratch With AI Help (Without Getting Stuck)

Why a Scratch chatbot is the perfect “first AI” project

A chatbot sounds fancy, but in Scratch it’s really just a friendly character that can:

• ask a question (using ask [] and wait)
• read the user’s reply (with answer)
• respond based on simple rules (like if/else)

That’s why a chatbot is one of the best Scratch coding project ideas for kids: it feels like “real AI,” but it’s built from understandable building blocks.

For parents, it’s also a great project because you can see progress fast. In 20–30 minutes, your child can have a sprite that says hello, asks their name, and responds. Then you can expand the bot over days: add jokes, a quiz, or a mini “choose your own adventure.”

One more bonus: chatbots naturally teach good programming habits—clear inputs/outputs, handling unexpected answers, and organizing code.

What you’ll build (and what you need before starting)

This scratch chatbot tutorial builds a simple “Buddy Bot” that can:

• greet the player
• remember their name
• answer a few topics (games, homework, jokes)
• gracefully handle unknown responses

Before your child starts, make sure they can do these Scratch basics:

• drag blocks and snap them together
• use when green flag clicked
• use say [] for [] seconds and ask [] and wait

If they’re brand-new, that’s okay—this project still works. Just plan to sit nearby for the first 10 minutes.

Quick setup checklist

• Create a new Scratch project
• Pick a sprite that will be the “bot” (Scratch Cat works fine)
• Optional: add a simple background (like a room or space)

The core “chat loop” idea

A chatbot works best when it repeats a pattern:

1. Ask the user what they want
2. Check the answer
3. Respond
4. Ask again

This is usually done with a forever loop.

Step-by-step: Build the chatbot in Scratch (without confusion)

Below is a practical build plan. Encourage your child to test after every small change—this is the biggest “don’t get stuck” trick.

Step 1: Greet and store the user’s name

Create a variable called name.

Blocks to build:

• when green flag clicked
• set [name v] to []
• say [Hi! I’m Buddy Bot.] for (2) seconds
• ask [What’s your name?] and wait
• set [name v] to (answer)
• say (join [Nice to meet you, ] (name)) for (2) seconds

Tips for parents:

• If the bot keeps using an old name, make sure the variable is reset at the start (set name to []).
• If your child forgets to use answer, show them how ask puts the reply into that answer bubble.

Step 2: Add a “menu” so the user knows what to type

Kids often get stuck because they don’t know what responses the program expects. Fix that by showing choices.

Add a new variable called topic.

Then add:

• say (join [You can type: joke, games, homework, or bye.] []) for (3) seconds

Step 3: The main chat loop with simple rules

Now build the repeating conversation.

Use:

• forever
  • ask [What do you want to chat about?] and wait
  • set [topic v] to (answer)
  • if <(topic) = [joke]> then ... else ...

Inside the if/else chain, add three or four topics. Example responses:

• If topic = joke

  • say [Why did the computer sneeze? It had a virus!] for (2) seconds

• Else if topic = games

  • say (join [I like games! What’s your favorite game, ] (name)) for (2) seconds
  • ask [Tell me your favorite game.] and wait
  • say (join [Nice! ] (answer)) for (2) seconds

• Else if topic = homework

  • say [Homework can be tough. Want a tip: break it into 10-minute chunks.] for (3) seconds

• Else if topic = bye

  • say (join [Bye, ] (name)) for (2) seconds
  • stop [all v]

• Else (unknown input)

  • say [Hmm, I didn’t understand. Try: joke, games, homework, or bye.] for (3) seconds

Practical “unstuck” check:

• If the bot never matches the topic, your child may have typed Joke instead of joke. Scratch checks exact text.
• A quick upgrade is to accept multiple spellings (more on that below).

Step 4: Make it feel smarter with “synonyms” (easy win)

To reduce frustration, accept more than one word for the same topic.

For example, in the joke section:

• if <<(topic) = [joke]> or <(topic) = [funny]>> then ...

Do the same for goodbye:

• if <<(topic) = [bye]> or <(topic) = [goodbye]>> then ...

This tiny change makes the chatbot feel way more forgiving—great for younger kids.

Step 5: Add a mini “memory” feature

This is where a chatbot starts feeling personal.

Add a variable called favoriteColor.

Add a topic called color:

• If topic = color
  • ask [What’s your favorite color?] and wait
  • set [favoriteColor v] to (answer)
  • say (join [Cool—I'll remember that you like ] (favoriteColor)) for (2) seconds

Then, if the user types remember:

• If topic = remember
  • if <(favoriteColor) = []> then
    • say [I don't know your favorite color yet. Type: color] for (3) seconds
  • else
    • say (join [You told me your favorite color is ] (favoriteColor)) for (2) seconds

That’s a real programming milestone: storing information and using it later.

Use ChatGPT to learn Scratch (the right way) without breaking the project

Many families try to use AI and end up more confused because the AI gives “Scratch-like” code that doesn’t match the blocks. The trick is to ask for block-level instructions and to keep changes small.

Here’s a parent-friendly workflow to use ChatGPT to learn Scratch while keeping your child in control:

• Ask for one feature at a time (not “build the whole chatbot”).
• Request the exact block names (ask and wait, answer, if/else, variables).
• Paste your current behavior and what’s going wrong.
• Test after every 3–6 new blocks.

Copy/paste prompts that actually work

Use these with ChatGPT (or any AI helper):

• “My Scratch chatbot uses ask and wait and answer. Can you tell me the exact blocks to add so it accepts both bye and goodbye?”
• “I want a forever loop chatbot menu. Please describe the blocks step-by-step using Scratch block names.”
• “My bot only responds when I type lowercase. What are three simple ways to handle capitalization in Scratch?”

Common “stuck” moments (and the fast fixes)

Stuck Problem	What’s happening	Fast fix your child can try
Bot ignores inputs	Text must match exactly	Add synonyms with or, or show a menu of valid words
Bot repeats the wrong thing	Variable not updated	Check set [topic] to (answer) is inside the loop
Bot won’t stop on “bye”	stop all not reached	Make sure the bye check happens before the “unknown” else
Conversation feels boring	Same reply every time	Add 2–3 jokes and pick one with pick random (1) to (3)
It breaks after adding features	Too many changes at once	Undo, then add one feature and test before adding the next

A simple “AI safety rule” for kids

Explain it like this: AI can suggest ideas, but your child is the programmer.

A good habit:

• Have your child predict what the next blocks will do before running them.
• If the result is surprising, ask: “Which block made that happen?”

That builds real understanding (not just copy/paste coding).

Make it awesome: upgrades kids love (and parents can manage)

Once the basic chatbot works, let your child choose one “upgrade path.” This prevents the project from turning into a messy pile of half-finished ideas.

Pick one:

• Quiz Bot: Ask 5 questions, keep score with a score variable.
• Mood Bot: User types “happy/sad/mad,” and the bot responds with tips.
• Adventure Bot: Use choices like “left/right” to branch the story.
• Helper Bot: Build a homework timer (Pomodoro) and motivational messages.

If your child wants their chatbot to feel more “AI-like,” you can also teach a beginner-friendly concept: keyword matching.

Example: if the user’s answer contains the word “game” anywhere, respond about games. Scratch doesn’t have a built-in “contains” block for text, so keep it simple:

• Ask the user to type one keyword (menu-based)
• Accept common variations with or

That keeps the build smooth and age-appropriate.

Next Steps: Start today in 30 minutes (and keep momentum)

Here’s a simple plan you can follow tonight without turning it into a big production.

• Minutes 0–5: Choose a sprite and background. Create variables: name, topic.
• Minutes 5–15: Build the greeting + name memory.
• Minutes 15–25: Add the forever loop with 3 topics: joke, games, bye.
• Minutes 25–30: Add the “unknown input” response so it never feels broken.

Then schedule a fun second session (15–20 minutes) to add one upgrade: synonyms, favorite color memory, or a mini quiz.

If you want your child to keep building confidently, make the goal not “perfect code,” but “a working version that gets a little better each time.” That’s how real developers work—and it’s exactly how kids learn best.