My Robotic Friends: Teach Coding With Cups, No Devices

Hand a kid a stack of plastic cups and four arrow cards, and they'll learn what a bug is before they ever touch a keyboard.

UNI-FIED Education TeamLast reviewed November 2, 2026
Students stacking plastic cups into a pyramid while a teammate reads aloud a program written with arrow symbols

You want to teach coding, but half your class doesn't have a device today, and the other half opens the laptop and immediately ends up somewhere they shouldn't be. Meanwhile the actual idea you're trying to teach — that a computer does exactly what you tell it, nothing more — gets buried under logins and loading screens. There's a way to teach that idea with plastic cups and paper arrows, and it lands harder than any app.

In this guide:

  • What My Robotic Friends actually is
  • Why this unplugged game teaches debugging so well
  • How to run it, step by step, in about 30 minutes
  • A real grade-1 example you can copy tomorrow
  • Variations, common mistakes, and quick answers to your questions

What is My Robotic Friends?

My Robotic Friends is an unplugged coding activity where students write a "program" using only arrow symbols, then watch a classmate act as a robot and follow it exactly. It comes from Code.org's CS Fundamentals curriculum, and it teaches the core idea of an algorithm: a precise sequence of instructions.

The setup is simple. A team looks at a target — say, a small pyramid of cups — and writes down the steps to build it using a tiny symbol language: move forward, rotate, pick up, put down. Then one teammate becomes "the robot" and does only what the symbols say, in order, no guessing.

That's the whole thing. No screens, no accounts, no prep beyond cups and printed arrow cards. The magic is in what happens when the robot follows the program too literally.

Why does it work?

It works because debugging becomes something kids can see and touch. According to Code.org's CS Fundamentals materials, the activity's power comes from one thing: ambiguity breaks programs, and the breakage is concrete. When the robot stacks the cups wrong, the mistake isn't abstract — it's a crooked tower sitting on the desk.

Kids learn fast that the robot isn't being difficult. It's being faithful. If their program said "pick up, forward, put down" but they meant "forward two spaces first," the robot does exactly what's written, and the tower comes out wrong. That gap between what I meant and what I wrote is the entire lesson, and they discover it themselves.

This is also why the activity sticks. There's no lecture about precision. The cups deliver the feedback, the team fixes the program, and they run it again. That loop — write, run, see it fail, fix, run again — is exactly how real programmers work, and here it takes 30 seconds per cycle.

How do you run it, step by step?

You can run the whole thing in about 30 minutes with teams of three or four. Here's the sequence.

  1. Gather materials. Each team needs a stack of plastic cups (6 to 10 is plenty) and a set of arrow cards or a worksheet with the symbols: forward, rotate (turn the cup or the robot), pick up, and put down. Print or draw these big.

  2. Show the goal. Display a target configuration where everyone can see it — a 3-cup pyramid is the classic starter. Don't explain how to build it. Just show the finished stack.

  3. Teams write the program. Each team uses only the arrow symbols to write a sequence that would build the target. No words, no shortcuts — symbols only. This is where they argue productively about order.

  4. Pick the robot. One team member becomes the robot. They will follow the program literally and cannot use common sense to "fix" anything. The rest of the team reads the program aloud, one symbol at a time.

  5. Run the program. The robot executes each instruction in order. The team watches without interfering. Resist the urge to coach — let the robot do exactly what's written.

  6. Compare and debug. When the robot's stack doesn't match the goal, the team finds the line where it went wrong, rewrites it, and runs the program again with a fresh robot or the same one. This is the best part; protect time for it.

  7. Level up. Once a team nails the pyramid, give a harder target — a taller stack, a stack with a gap, two separate piles. Same rules, more thinking.

The arrow symbols matter. Keeping the language small forces students to be exact, which is the point. Resist adding "just one more symbol" to make it easier.

A real example: Grade 1, building a cup pyramid

Picture a grade-1 class during a morning block. The teacher sets a 3-cup pyramid (two cups on the bottom, one on top) on a stool at the front and says nothing about how it was made. Each team of four gets ten cups and a worksheet of arrow cards.

One team writes: PICK UP, FORWARD, PUT DOWN, BACK, PICK UP, FORWARD, FORWARD, PUT DOWN. Their robot — a six-year-old taking this very seriously — follows it and ends up with two cups side by side and nowhere to put the third. The tower has no top.

The team groans, then leans in. Someone notices the program never tells the robot to place a cup on top of the others. They add a "put down" that stacks rather than sets beside, run it again, and the pyramid stands. The robot takes a bow. That moment — the fix landing, the tower holding — is when "the computer only does what you tell it" becomes something they actually believe, not something a teacher said.

For grade 1, the pyramid is the right ceiling. Older students can build the same understanding with taller or trickier targets in the same 30 minutes.

Variations and when to use it

There are a few easy ways to bend this activity to your room.

  • Teacher as robot. You play the robot and students write a program to stack cups on your desk. Great for a first run, because your deadpan literal-following gets big laughs and makes the lesson obvious. Code.org lists this as the standard variation.
  • Team swap. One team writes a program, another team's robot runs it cold. This raises the stakes on clarity, since the second team didn't see your intentions.
  • Harder targets. Add height, gaps, or two separate stacks once the pyramid is easy.
  • Bridge to related lessons. This pairs naturally with other Code.org unplugged activities like Graph Paper Programming or Relay Programming when you want a unit, not a one-off.

Use it as the very first coding lesson of the year, on a no-device day, or anytime a class is struggling with the idea that small mistakes in instructions cause big failures. It's also a strong substitute-teacher activity — low prep, high engagement, hard to derail.

Common mistakes to avoid

The biggest mistake is letting the robot use common sense. The whole lesson depends on the robot doing exactly what's written, even when everyone can see it's about to go wrong. If the robot quietly fixes the program, the bug disappears and so does the learning. Coach your robots to be gloriously literal.

A second trap is rushing past the debugging. The instinct is to celebrate the teams that get it right and move on. But the teams that got it wrong are sitting on the best teachable moment in the room. Build in time to fix and re-run.

Third, don't expand the symbol language to make things easier. A small, strict set of arrows is what forces precision. More symbols just hide the gap between intention and instruction.

Last, don't pre-explain the solution. Show the goal, hand over the cups, and let the cups teach. Your job is to protect the loop, not to shortcut it.

How UNI-FIED helps

If you like this routine but don't have time to hunt down targets, print arrow cards, and plan the debrief, that's the gap UNI-FIED fills. The platform turns research-backed routines like My Robotic Friends into ready-to-teach activity cards built around your topic and grade, so you walk in with the goal images, the symbol set, and the discussion prompts already done. You spend your prep thinking about your students, not formatting worksheets.

Frequently asked questions

What grade is My Robotic Friends for? It started as a K-1 activity, but the same pattern is used across Code.org's CS Fundamentals courses for K-5. Younger students build simple pyramids; older students take on taller or trickier targets.

Do I need any technology? No. That's the point of an "unplugged" lesson. You need plastic cups and printed arrow cards, and nothing else. It's ideal for days when devices aren't available.

How long does it take? About 30 minutes for a first run, including writing programs and debugging. You can stretch it with harder targets or shorten it by doing one round as a whole class with you as the robot.

Where does this come from, and is it free? It's from Code.org's CS Fundamentals curriculum, which is published under a Creative Commons license (CC BY-NC-SA 4.0) and free to use. You can find it through the Code.org elementary curriculum.

Why not just use a coding app instead? Apps are great later, but they can hide the core idea behind buttons and animations. Here, when the program fails, students see the broken tower with their own eyes — and that makes debugging real in a way a screen rarely does.

Give your class a stack of cups and four arrows, and let the robot teach the lesson you've been trying to explain all year.

Sources & further reading

Run this in your classroom tomorrow

UNI-FIED turns your topic, grade, and lesson length into ready-to-teach activity cards built on routines like this one — no prep, no curriculum change.

See how UNI-FIED works

Related routines

Published November 2, 2026.