5 Coding Projects You Can Do With Your Child This Weekend

You Don’t Need to Be a Coder

Here’s a secret most coding education sites won’t tell you: the parent sitting next to the child matters more than the tool on the screen.

You don’t need to understand programming. You don’t need to have studied computer science. You don’t even need to be “good with computers.” What you need is an hour, a laptop or tablet, and the willingness to try something new alongside your kid.

The five projects below are designed for exactly that. Each one uses a free tool that runs in a web browser — no downloads, no accounts required (though Scratch accounts are handy for saving work). Each one takes 30 to 60 minutes. And each one is built around the idea that you and your child are figuring it out together.

I’ve taught hundreds of kids how to code, and the sessions where a parent sits down and says “Show me how this works” are always the best ones. Kids light up when they get to be the expert. So even if you feel lost at first, that’s actually a feature, not a bug.

Let’s get into it.

1. ScratchJr Dance Party (Ages 4-6)

What you’ll make: A stage full of characters dancing, jumping, spinning, and bouncing to their own choreography. Your child picks the characters, picks the moves, and hits play to watch the show.

Tool: ScratchJr — free app for iPad, Android tablet, or Chromebook. Also available as a browser version through several educational sites.

Time needed: 20-30 minutes

How to get started

Open ScratchJr and let your child pick a background — maybe a stage, a park, or outer space. Then add a character. ScratchJr comes with a bunch of fun ones: cats, dogs, dragons, even a penguin.

Now here’s where the magic happens. At the bottom of the screen, there are colorful blocks. Show your child the blue motion blocks: “move right,” “move left,” “jump,” “turn.” Let them drag a few blocks together in a row. When they tap the green flag, their character performs the sequence.

Once they get the idea, add a second character. And a third. Each character gets its own set of moves. The result is a chaotic, wonderful dance party where everything is happening at once.

If your child wants sound, tap the character and look for the purple sound blocks. They can add a “pop” or a recorded sound to go with the moves.

What your child learns: This project introduces the idea of a sequence — things happen in the order you arrange them. That’s one of the most fundamental ideas in programming, and your child is learning it by making a cat do a backflip.

Parent tip: Resist the urge to organize the dance. Let it be messy. If your child puts the blocks in a “wrong” order and the character walks off screen, that’s a learning moment. Ask “What happened? What could we try?” instead of fixing it for them.

2. Scratch Maze Game (Ages 7-9)

What you’ll make: A maze that a character navigates using the arrow keys. If the character touches the walls, it goes back to the start. If it reaches the goal, it wins.

Tool: Scratch — free, browser-based, works on any computer. Create a free account to save projects (optional but recommended).

Time needed: 40-50 minutes

How to get started

Open Scratch and click on the “Backdrops” tab at the bottom-left. Choose a blank white backdrop, then use the paint tools to draw a maze. Keep it simple — thick black walls, a clear path, a green square at the finish. Your child will want to make it impossibly hard. Let them, then suggest they test it first.

Now click on the cat sprite (or pick a different character). You need four sets of blocks:

• “When up arrow key pressed” → change y by 5 (moves the character up)
• “When down arrow key pressed” → change y by -5 (moves down)
• “When right arrow key pressed” → change x by 5 (moves right)
• “When left arrow key pressed” → change x by -5 (moves left)

These blocks are in the “Events” category (gold) and “Motion” category (blue). Snap them together and test. Your character should now move around the screen with the arrow keys.

Next, add wall detection. From the “Sensing” category (light blue), grab “touching color?” and click on the color to pick the black of your maze walls. Wrap this in an “if-then” block from “Control” (orange): if the character touches the wall color, it goes back to the starting position. You set that with “go to x: [start] y: [start].”

Finally, add a win condition: if the character touches the green goal area, display “You win!” using a “say” block.

What your child learns: This project introduces conditions — “if this happens, then do that.” It also introduces coordinate systems (x and y positions) in a way that makes intuitive sense because they can see the character moving on screen. They’re learning geometry without calling it geometry.

Parent tip: Draw the maze together on paper first. It’s easier to plan walls and paths with a pencil before painting them on screen. This also gives your child a chance to think through the design before jumping into the code, which is a real programming skill.

3. Scratch Animation Story (Ages 8-11)

What you’ll make: A short animated story — two or three scenes, characters that talk to each other, backdrop changes, maybe a surprise ending. Think of it as a mini-movie that your child writes, directs, and codes.

Tool: Scratch — same as above.

Time needed: 45-60 minutes

How to get started

Start by asking your child: “What’s the story?” It can be anything. A cat goes to space. Two friends find a treasure chest. A dragon orders pizza. Don’t overthink it. The weirder, the better.

Pick two or three characters (sprites) and a starting backdrop. Now, the key mechanic for animation stories in Scratch is timing. Use the “wait” block (from Control, orange category) to create pauses between lines of dialogue. Here’s a basic pattern:

• Character 1: “say [Hello!] for 2 seconds”
• Wait 1 second
• Character 2: “say [Want to go on an adventure?] for 3 seconds”
• Wait 1 second
• Character 1: “say [Yes! Let’s go!] for 2 seconds”

To change scenes, use the “switch backdrop to” block. You can have multiple backdrops loaded and switch between them at the right moment. Pair the backdrop switch with character movements — have them glide from one side of the screen to the other, or suddenly appear and disappear using “show” and “hide” blocks.

For added flair, your child can record their own voice for the characters using the “Sound” tab. They can also add sound effects from Scratch’s built-in library.

What your child learns: Storytelling meets logic. Your child learns about timing, sequencing, and coordinating multiple events that happen at the same time (each character has its own script running in parallel). They also practice creative writing, narrative structure, and dialogue — all while coding.

Parent tip: Be the audience. When your child finishes (or gets to a point where something works), ask them to show you the story. React to it. Laugh at the jokes. Ask what happens next. The motivation to code more comes from the joy of sharing what they made.

4. Digital Pet in Scratch (Ages 9-12)

What you’ll make: A virtual pet that lives on screen. Click to feed it, play with it, or put it to sleep. Its mood changes based on how you interact with it. Ignore it too long and it gets sad.

Tool: Scratch

Time needed: 50-60 minutes

How to get started

Choose a character for the pet — the cat works perfectly, but your child might prefer a dog, a parrot, or a fantasy creature. Draw or choose a backdrop that feels like a home (a room, a garden, a cozy cave).

This project uses something called a variable, which is simpler than it sounds. A variable is just a number that the program remembers. Create three of them in the “Variables” section (orange-red category): “Hunger,” “Happiness,” and “Energy.” Set each one to 50 at the start.

Now add three buttons. You can make these by creating new sprites — draw a simple food icon, a ball, and a bed. For each button:

• Click the food sprite → Hunger goes down by 10, and the pet says “Yum!”
• Click the ball sprite → Happiness goes up by 10, and the pet does a little spin
• Click the bed sprite → Energy goes up by 10, and the pet says “Zzz…”

Here’s the clever part: add a “forever” loop (from Control) to the pet’s script that slowly changes the numbers over time. Every few seconds, Hunger goes up by 1, Happiness goes down by 1, and Energy goes down by 1. This creates the feeling that the pet needs ongoing attention.

To make the pet react visually, add costume changes. If Happiness drops below 20, switch to a sad costume. If Hunger gets above 80, switch to a hungry costume. You can draw these costumes in the Scratch editor — just duplicate the original and make small changes (droopy eyes, open mouth, sleeping face).

What your child learns: This project introduces variables (keeping track of changing information), continuous loops (things that keep happening over time), and cause-and-effect relationships. These are core programming concepts, but your child will experience them as “I need to keep my pet happy” — which is a lot more motivating than a textbook.

Parent tip: Help your child plan the pet’s “rules” before coding. Grab a piece of paper and write: “When I click food, what happens?” This kind of planning — thinking through the logic before building — is exactly what professional programmers do. Your child is already practicing it.

5. Generative Art with p5.js (Ages 11-14)

What you’ll make: Colorful geometric patterns that the computer draws for you. Circles, lines, and shapes that repeat, rotate, and change color — all from a few lines of actual code. The results look like something you’d hang on a wall.

Tool: p5.js Web Editor — free, browser-based, no account needed. This is real JavaScript code, but the first steps are surprisingly approachable.

Time needed: 30-45 minutes

How to get started

Open the p5.js editor. You’ll see two sections: code on the left, a preview on the right. There’s already some starter code. Replace everything with this:

function setup() {
  createCanvas(400, 400);
  background(30);
}

function draw() {
  let x = random(width);
  let y = random(height);
  let size = random(10, 50);

  fill(random(255), random(255), random(255), 150);
  noStroke();
  circle(x, y, size);
}

Hit the play button. Watch as colorful circles fill the canvas, one per frame, in random positions and sizes. It’s instant visual gratification.

Now start experimenting. Change circle to square. Change the canvas size. Change background(30) to background(30, 0, 50) for a deep purple. Add stroke(255) to give each shape a white outline. Change 150 (the transparency value) to 50 for a more ghostly effect.

For a more structured pattern, try this:

function setup() {
  createCanvas(400, 400);
  background(240);
  noLoop();
}

function draw() {
  for (let x = 20; x < width; x += 40) {
    for (let y = 20; y < height; y += 40) {
      fill(random(255), 100, 150);
      circle(x, y, 30);
    }
  }
}

This creates a grid of circles, each with a different shade of color. It introduces repetition — the code says “do this for every position across the screen” — which is one of the most powerful ideas in programming.

What your child learns: This is a first taste of text-based programming. Your child writes real code, sees real results, and learns that changing one number changes the entire output. They’re learning about randomness, repetition, coordinates, and color — plus the satisfying feeling that a few lines of text can create something beautiful.

Parent tip: Don’t worry about understanding every line. Your job is to ask good questions: “What do you think happens if we change that number?” “What if we made the shapes bigger?” “What if we used only blue?” Experimentation is the whole point. There are no wrong answers in generative art.

What Happens After the Weekend

If your child finishes one of these projects and says “Can we do more?” — that’s the best possible outcome. Here are a few ways to keep the momentum:

• Save their work. Create a Scratch account so projects don’t disappear. Bookmark the p5.js editor link. These are things they can come back to on their own.
• Share it. Scratch lets kids publish projects to the community. Seeing other people play their game or watch their animation is incredibly motivating.
• Let them lead. The next project should be their idea, not yours. Ask what they want to make, then figure out together how to get there.
• Don’t turn it into homework. The moment coding feels mandatory, it loses its magic. Keep it as a weekend activity, something fun, something you do together.

The projects above are starting points, not endpoints. The real magic isn’t in the specific game or animation — it’s in the moment your child realizes they can make a computer do what they want. That shift from consumer to creator is worth more than any curriculum.

And if you hit a wall? That’s fine. Getting stuck and figuring it out is literally what programming is. You’re modeling exactly the right behavior by sitting next to your child and saying, “I don’t know either. Let’s try something.”

---

Want to go further? C.Lab Academy offers coding and digital art programs for kids aged 3 to 16 in Seoul. Small groups, hands-on projects, and a teacher who loves seeing kids create. Book a free trial class or explore our programs.