An unplugged coding game you can start in a minute. The rule: a grown-up (or the big sister) is the robot, the child is the programmer. The robot is a "dumb" machine—it obeys only three commands: step forward, turn left, turn right. It does exactly what it's told and never "fills in the blanks." Give the robot a mission: get from the sofa to the fridge, around a chair, to grab a toy. The programmer must line up the whole string of commands first (forward, forward, turn right, forward…), then let the robot run it all at once. Went wrong? Don't blurt out a correction—first find which step was mis-ordered. That's called "debugging."
She plays "one word, one move": she shouts "Go!" and you take a step, "Turn!" and you spin, and she cracks up. Don't ask her to line up a long string—what she wants is the cause-and-effect thrill of "I say it, and it moves." Let her be the robot too: you say "forward," she steps; "stop," she freezes. The game quietly teaches two things: commands come one at a time, and the machine does only what you say. That's plenty—the rest is giggles.
She's the "lead programmer": once the mission is set, she writes the whole command string on paper first (forward ×3, turn right, forward ×2…), then runs the robot with no corrections mid-way. If it goes wrong, trace back together to "which step was mis-ordered." Bonus challenge: add a "repeat" command—write "forward ×4" instead of four lines—the seed of a loop. Ask her: why doesn't the robot dodge the chair by itself? (Because it only does the commands you wrote; you didn't write "turn," so it won't. A machine has no common sense—whatever you want it to do, you must spell out step by step with nothing left out. That's the hardest, most important part of coding.)
Big sister is the programmer, little sister the robot (or swap and take turns). Big sister has to phrase commands so little sister can understand and follow them—too fast or too tangled and the "machine" jams. When little sister is the robot she just does exactly what she hears, no improvising. Run a route successfully together and cheer. Roles don't overlap: sequencing the commands is big sister's, being the robot is little sister's, then swap next round.
The heart of coding isn't the computer—it's "break a big task into ordered small steps, clear enough for a machine to follow." That's algorithmic thinking. Machines don't fill in gaps, so you have to think it through with unusual clarity. Twist: tape a grid maze on the floor and have the robot go from start to a "treasure"—a wrong command hits a wall, the right sequence wins.
Make a greeting card that lights up when you press it—the simplest circuit lighting a tiny bulb. The principle is one sentence: connect a conductive path from the battery's two poles to the LED's two legs, and it glows. Steps: ① Draw your design on cardstock (a star, a firefly), with the LED where the light should shine. ② Use copper foil tape to run a "road" from one LED leg to the battery's positive pole, the other leg to the negative (the LED's long leg goes to "+"; if it doesn't light, flip it). ③ Leave a small gap in the road as a "switch"—press it with a finger to close the loop and the light comes on. No fire or heat—an LED on this little power barely warms up. The only real danger is that coin battery.
She owns the two happiest jobs: making it pretty and making it light up. She draws stars, colors, sticks on sparkles. Once an adult has built the circuit, let her press the "switch"—light on! That flash of surprise is the whole point of the card. Let her press, release, press, release—she's playing hands-on with cause and effect: I press, it glows. The battery and LEDs stay entirely in adult hands; she touches only paper and the spot her finger presses.
She's the "circuit engineer": she tapes the LED's two legs to the battery's poles herself and works out that the long leg goes to positive. When it won't light, troubleshoot together: wired backwards? Foil not pressed down, breaking the path? Dead battery? That's circuit debugging. Challenge her to build a real "switch"—fold the card so pressing it closes the loop. Ask her: why does electricity light the bulb, and why must it go all the way around? (Because current has to leave one pole of the battery, pass through the light, and return to the other pole—a complete "loop." Break it anywhere and it goes dark. A glowing light is the sign that current made a full lap.)
Little sister first draws the design and decides "where the light goes" (a firefly's tail, say); big sister then wires the circuit to that spot per little sister's design. Big sister makes it glow, little sister makes it beautiful and presses the switch. Together they make a light-up card for Mom or Grandma. Roles don't overlap: wiring is big sister's, drawing and pressing is little sister's. An adult watches that battery the whole time.
Lighting a bulb needs an unbroken loop: current leaves one pole, passes through the light, returns to the other. This gives kids the plainest picture of a "circuit"—nothing mysterious, just a road for electricity to run a full lap. Twist: string two different-colored LEDs, or turn the switch into a fold mechanism so the light only comes on when the card opens—a real "magic card."
Scratch is a kids' coding tool from MIT—no typing, you drag blocks together and that's the program. Today's goal is modest: build a playable "cat catches things" game—arrow keys move the cat, touching an apple scores a point. Open scratch.mit.edu, pick a character, drag blocks like "when → key pressed, move 10 steps" together, then add "if touching apple, score +1." If it runs and plays, you're done. Don't chase perfect—get it moving first, then add flourishes bit by bit.
She can't drag logic blocks yet, but she can do three big things: pick the character (cat or dinosaur?), record a sound (yell "Meow!" into the mic for the game's sound effect—she'll lose it laughing), and be chief tester—each time big sister finishes a bit, let little sister mash the keys and play, "Is it fun?" Pressing arrows to watch the cat move is another hit of "I press, it moves." Ten-odd minutes is enough; don't let her stare at the screen too long.
She's the "game developer" writing real logic: use "when arrow key pressed → move / change coordinates" to make the character go, and "if touching → score +1, play sound" for the rules. Challenge her to add a loop ("forever" to keep apples spawning) and a condition (score hits 10 → show "You win"). When it breaks, she fixes it. Ask her: how does the computer know the cat "touched" the apple? (Because you wrote an "if… then…" test, and the computer checks that condition every instant to see if it's true—a program is built from countless "ifs" and "repeats" like these.)
Big sister is the developer building the program; little sister is art director and tester: she picks the character, records sound effects, paints a background (you can draw in Scratch), and big sister loads it all in. After each small step, little sister playtests and gives notes ("the apples are too fast!") and big sister goes back to tune it. It's the most authentic "product manager + programmer" teamwork. Roles don't overlap: logic is big sister's, ideas and testing are little sister's. When it's done, the whole family plays this "home-made" game.
Scratch turns coding's two great pillars into visible blocks: "repeat" (loops) makes the computer tirelessly do one thing, and "if… then…" (conditions) teaches it to react to circumstances. By dragging and playing, kids touch the underlying logic of every program. Twist: bring today's "human robot" maze into Scratch and have the cat walk it following written commands—offline and online meet.
Turn "coding" into a treasure hunt the whole family can play. Whoever hides the treasure first writes "how to reach it" as a string of pure commands—not "go to the kitchen," only the kind a machine understands: "forward 5 steps, turn left, forward 3 steps, crouch, lift the mat." The finder is the robot and follows the commands exactly, no guessing. Write them clearly and they find it; miss a step and they veer off—that's the moment everyone gets that "one wrong step in a program throws off the whole result." Found it? Swap and hide again.
Being the "finder robot" suits her perfectly: an adult reads one command ("walk forward three steps"), she does it and counts "one, two, three," then the next. The surprise of reaching the treasure is her whole reward. Without noticing, she's practicing counting, following commands, doing things in order. She can "hide" too—she stuffs a snack under the sofa and points you "that way, that way." It's not a real "program," but she's already tasting "I have to tell you how to get there."
She's the "program author": hide the treasure, then write the route as a string of precise commands and hand it to the "robot" to run. The challenge is thinking from the executor's side—"written this way, will they go wrong?" If they veer off, trace back to which command was vague or missing (debugging). Bonus: compress with "repeat N times" ("forward ×6" for six steps)—that's a loop. Ask her: why can't you just write "go to the sofa"? (Because the robot doesn't share the map in your head; it only understands basic moves like "walk this many steps, turn this way." You have to translate the route that's obvious to you into precise step-by-step commands—which is exactly what coding does.)
Big sister is the program author writing commands, little sister the robot executing; after the treasure's found, swap—little sister "narrates" the route and big sister helps her turn it into command cards. Big sister learns that to keep her "machine" on track, commands must be simple and exact. Little sister learns that just by following along she finds the treasure—a real sense of achievement. Roles don't overlap: writing is big sister's, executing and counting is little sister's, swap each round.
This game nails coding's core lesson: the human mind runs on intuition, but a machine only obeys precise, step-by-step commands. Writing a program is fundamentally translating the "obvious at a glance" route in your head into small steps a machine can follow—miss one and it veers off. Twist: add "if… then…" conditional commands ("if you hit the red mat, turn right") and the hunt instantly becomes a real program with branches.
Short on time but itching to play right now? Pick "The Human Robot"—zero materials, zero prep, playable the moment you stand up. The 3-year-old laughs herself silly, the 9-year-old is genuinely training algorithmic thinking, and no screens or batteries are involved—the easiest of the four. Save "The Glowing Paper Circuit" for an evening when you have a solid block of time and an adult can watch that battery the whole way; the moment that light comes on is worth doing with care.