Tap picture‑tokens to build a plan, press go, and the character does exactly what you said.
📱 Install the Android app — full‑screen, its own icon, no browser bar (the way my kids like playing it)
Make It Go teaches a child who can't read yet the core intuitions of programming — through play. They pick a theme, then solve a ladder of short challenges that get harder one idea at a time: sequence, literal execution (debugging), iteration, decomposition. A warm AI partner talks them through it by voice and decides when they're ready for the next idea.
Success is measured by capability gained, never time on app. The win condition is that they outgrow it and graduate to ScratchJr and beyond. The name says the loop: they build a plan, tap go, and the character does exactly what they said.
I have two kids — Zoe (2½) and Autumn (5). When I went looking for games to build the foundation under coding — sequence, cause and effect, "it does exactly what you say" — I found a surprisingly big gap: lots of flash, very little that genuinely builds capability at this age, before reading. So I started building the thing I actually wanted for Zoe and Autumn.
Underneath the play there's a real question I want to answer:
Can an AI partner make a pre‑literate child more capable — by building on what they already know, instead of marching them down a fixed path?
That's the experiment. The app is the instrument; the finding is the point.
- 🚫 No reading, no typing, no microphone. Input is large picture‑tokens they tap. Voice is output only.
- 🎯 Literal execution is the lesson. Their ordered plan runs exactly as written — a wrong action fails visibly (a stumble, a splash). The gap between what they meant and what they said is the debugging lesson. No autocorrect, ever.
- 🌱 Growth over engagement. No streaks, no timers, no leaderboards. Progress is mastery‑gated — each level unlocks only after the last idea is demonstrated.
- 🗣️ A partner inside the play. It reacts, narrates, and offers the right tool at the right moment — never an interrogation, never shame for a mistake. It knows which ideas they've already mastered and builds on them instead of re‑teaching.
- 🧸 The scene is a toybox. Poke an obstacle and it reacts while the voice names it ("A gap!" — sneaky vocabulary for reading the path). The goal wiggles, the sun pokes, and a third quick pet earns the hero a spin and its happy cry. Every toy goes quiet while a plan runs — play never interrupts the lesson.
- 📱 Touch‑first, runs on tablet and laptop, fully playable with audio off. Progress survives — a reload or a theme switch resumes at the furthest rung they've earned.
The character walks itself — walking is free, never something they program. A level is a path of event points, each needing one action (a gap → jump, a branch → duck, a step → climb; later a key → grab, a gate → open).
They lay out an ordered row of action tokens, then tap go. The character advances and, at each event point in turn, performs the next action in their plan:
match → pass · mismatch → fail right there, visibly · reach the goal → win
It's plan‑first, then run — no twitch input, no runner mechanic. Just "say what to do, then watch it happen."
Each level plants or reinforces exactly one idea, in order, and is reskinnable by any theme.
| Level | Idea | Knowledge anchor |
|---|---|---|
| L1 | Sequence — the right move at the right spot (a gap → jump) | "It does exactly what you say." |
| L2 | A second move — a branch to duck under | (same anchor, new mapping) |
| L3 | Order — a gap then a step, right moves in order | "Steps happen in order." |
| L4 | Iteration — a run of gaps, folded into one repeat chip | "You can bundle steps and do them again." |
| L5 | Decomposition — grab the key, then open the gate (forget it → locked) | "When it's wrong, find the wrong step and fix it." |
| L6–L9 | Combine them — the whole dance, a fold inside a run, carry a key past a hazard, a capstone | (all four, reinforced) |
Then they enter endless, never‑memorized practice: levels are generated, not authored (and validated against the interpreter so they're always solvable), with the order shuffled so the action sequence can't be memorized — and the partner aims each one at their least‑developed skill. That's the transfer test made real: can they solve a level no one walked them through?
Anchors are spoken in the same childlike words every time — that's what makes them stick — and map straight onto ScratchJr (script order, the repeat block) for the handoff.
| The only front door | Iteration: fold many into one | Cause & effect |
|---|---|---|
 |
 |
 |
As the partner speaks, each word grows in time with the voice — an early‑reading cue that ties the sound to the written word:
Make It Go installs as a full‑screen app on Android (a Trusted Web Activity over the live site):
- On your phone or tablet, open makeitgo.org/make-it-go.apk in Chrome — it downloads.
- Tap the downloaded file → allow installing from this source → Install.
- Launch Make It Go from the home screen — its own icon, no browser bar.
It's a direct install (not a Play Store listing yet), so Android asks you to allow it once — normal for an app from outside the store. On iPad/iPhone, open Safari → Share → Add to Home Screen for the same full‑screen app.
React 18 · TypeScript · Vite · Vitest. The interpreter is pure and theme‑agnostic — fully tested (184 tests, from the interpreter down to jsdom tests that drive the real play loop), with no engine logic ever forked per theme.
src/
engine/ pure interpreter, mastery rules, levels, level generator, anchors (tested)
themes/ data-only packs over one engine (6: meadow, fox, dino, royal, trucks, space)
partner/ the "partner brain" behind one seam — local stub + server-side Claude (Sonnet)
narration/ ElevenLabs voice + karaoke word-timing, cached on-device (Web Speech fallback)
telemetry/ capability signals — never time-on-app
ui/ picker, track, plan strip, token tray, runner, grown-ups dashboard
A theme is just data — a hero, its poses, the obstacle/action art, a palette. Adding one is adding a pack, never touching the engine.
git clone https://github.com/paulmm/make-it-go.git
cd make-it-go
npm install
npm run dev # open the printed localhost URL
npm test # the engine + partner test suiteKeys (optional). Out of the box the partner is a deterministic local stub with the browser's built‑in voice. For the full experience — the Claude partner and the warm ElevenLabs voice with word‑level highlighting — add keys to .env.local. They're read server‑side and never shipped to the browser:
# .env.local (gitignored)
ANTHROPIC_API_KEY=your_key_here # the Claude partner (defaults to Sonnet 5)
ELEVENLABS_API_KEY=your_key_here # the warm voice + karaoke highlighting
# optional: ANTHROPIC_MODEL, ELEVENLABS_VOICE_ID, ELEVENLABS_MODEL_IDNo mic · no reading · no typing · no accounts · no ads · no streaks or timers · no walk token · no real‑time input · no turn/rotate tokens · the interpreter is never autocorrected · progression is never gated on time or attempt count. Failure is never a dead end — every wrong plan is a revise, with one good nudge from the partner, never the answer.
Deployed and playable at makeitgo.org (Vercel: makeitgo-zoe.vercel.app) — also installable as a full‑screen Android app. Shipped since the first cut:
- ✅ Six original theme packs (meadow, fox, dino, royal, trucks, space)
- ✅ Server‑side Claude partner (Sonnet 5) — warm, honest, readiness‑aware, and told which ideas they've already mastered
- ✅ Grown‑ups dashboard + a "ready for ScratchJr" handoff
- ✅ ElevenLabs voice with karaoke highlighting, cached on‑device (instant replay, no repeat cost)
- ✅ A nine‑rung ladder → endless adaptive practice that aims each generated level at their weakest skill
- ✅ Progress that sticks — reload or switch characters and they resume at the furthest rung they've earned
- ✅ A scene full of toys — pokeable obstacles that speak their names, a wiggling goal, a pet streak that earns a spin and the theme's cry, tap‑to‑cheer‑again after a win (placing a token now asks — "Jump?" — because pressing go is the test)
- ✅ Hardened API endpoints (same‑origin gate, size caps, per‑IP rate limits) so strangers can't spend the voice credits
On the horizon: Claude as the difficulty director (vs. the local one); per‑theme partner flavor; a parent‑facing readiness write‑up; a Play Store listing.
MIT © 2026 Paul Mangiamele — a fitting license for a tool meant to be outgrown and shared.