One person and a team of AI agents built a live arcade of learning games in five months.
Mastery Arcade is two games on one learning engine: Times Machine, with 17 levels and 4 boss fights for your times tables, and the Lab, with 22 hands-on 3D science experiments. I built it alone from May 30, 1,069 commits, for web, iPhone, iPad and Android from one codebase. Here's how I did it, and the decisions that made it work.
Two games, three platforms and 1,069 commits, from one builder.
Five months, May 30 to October 31. I decided what to build and made the taste calls. AI agents wrote most of the code. The second game, the Lab, reached production with 11 experiments built in one day.
These count what exists in the repo today. I'm leaving out reach and revenue until there's something to report. The web version is live, and the App Store launch is planned for November 3.
Games you want to keep playing, with real practice inside.
Kids and adults practice facts with flashcard apps that bore them, or with games that teach very little. Mastery Arcade is my answer: a growing set of learning games, built on one learning engine, with the feel of a real arcade.
The first game is Times Machine. A giant machine has come to optimize Earth, and the only way to beat it is multiplication. You practice each table, earn a medal, then fight bosses named BYTE, MEGA and GIGA before facing the Times Machine itself.
The second is the Lab, where you pick up a question like "how do planes fly?" and test it with your hands in a 3D room. One family pass covers everything, with up to six Players.
It started on May 30 as one multiplication app. By June 27 I had rebuilt it as a monorepo around a shared engine, so a second game wouldn't mean starting over.

Two worlds. The arcade on desktop: Times Machine at night, the Lab in daylight.



Real captures of the app on a phone and a laptop, from a local test account. The Players are an invented demo family with helmet avatars.
- Spaced repetition
- FSRS, through the open-source ts-fsrs library, picks what comes next. Missed facts come back often. Mastered ones return for a check about a week later.
- A four-second line
- A clock on every question rewards quick recall over working it out. Under four seconds counts as known. That line is my own design choice, and the site says so.
- Cover-Copy-Compare
- When you miss a fact, you see it and retype it from memory.
- A page that admits what's unknown
- The evidence page sorts every choice into what research supports and what's my own bet. It says plainly that I haven't run my own study. I wrote it to be read by a skeptical parent.
One engine, so the game can't drift away from the learning.
Practice, level drills, every boss, the challenges, the first-run drone mission and the free speed check on the website all ask questions through the same state machine. Each surface sets its own knobs, like the retry on a miss or the clock. Nobody gets to write a second one, because a boss fight that grades differently from practice would quietly break the promise of the product.
- Boss fights as a layer on top
- The boss owns health and drama. The engine owns the question, the timer and the grade.
- Three.js where it earns its place
- Characters, the trophy case and hero moments run in WebGL. Everything else stays light, so a phone keeps up.
- Haptics scored from the picture
- Each boss film has its own haptic score. I rebuilt it around an onset detector gated against the measured speech, replacing a flat threshold.
- Tokens, medals, trophies, certificates
- A free daily token economy with a real spend moment, a coin that drops as you start a level. Medals you earn on speed. Certificates you can print, and share cards for every win.


The product is the output. The way I run the agents is what I'd bring to your company.
I don't write most of the code by hand. I decide what to build, I make the taste calls, and I check the result by using it on a real phone. Agents do the rest. That only works with a system around them, and most of that system came from something breaking.
On September 2, I filed nine epics and about 108 issues and let the agents go. They started around 6:15 pm and were still merging past 3 am. Over that four-day arc, 47 PRs landed, along with one production incident and one forced hosting upgrade.
- Issues are the coordinator
- Small work lives in GitHub Issues, never in a chat. One issue, one worktree, one branch, one PR. Assignment is the lock. Any session on any device can pick up where another stopped.
- Labels decide who has to look
- Ready for an agent. Can merge on green tests. Needs me. Money, auth and anything a kid sees default to needing me, however green the tests are.
- "Green CI is not evidence of correctness"
- That's in the rulebook. Every serious finding so far passed CI. So auto-merge is a decision someone made in advance, never just a passing build.
- Ratchets in CI
- Tests fail the build on a typed-in price, a stray icon, or a second learning engine. Rules I care about become tests, so I don't have to catch them in review.
- A model for each job
- The main session plans and reviews. Every dispatched agent names a cheaper model. That rule exists because eight agents once inherited the most expensive one in a single day.
- A 74 KB rulebook
- CLAUDE.md, with most rules next to the incident that caused them. Every agent reads it, so a lesson learned once applies to all of them.
- Scheduled agents that review the business
- Routines for profitability, growth and security. They're read-only, and each ends in one issue, one PR or one comment. A Control Center I built shows their findings next to a stamp for whether I read them. Most of them were written long before they were ever scheduled, and the doc says that too.
- I review by using
- I test on a real phone, so agents give me a link to tap, never a diff. Sound gets my ear. Art gets my eye.
A character pipeline, down to about 25 minutes.
I make and approve the character art myself in Midjourney. Agents run everything after that: Meshy turns the image into a 3D model, it gets rigged and animated, and it lands in the game as a GLB file in Three.js. I proved the whole path on one pilot, VEX, on August 23: 62 credits and about 25 minutes.
The steps are simple to list. The rules around them are what cost me. They're written into the pipeline doc, each with the measurement that earned it.
VEX: the approved art, the free mesh check, and the portrait in the game.
- Check the free thumbnail before buying the clips
- One pilot reached the game deformed because nobody looked at its mesh. I ruled out the rig with measurements first. The skeleton was fine and the mesh wasn't. The check moved the cost of a failure from about 72 credits to about 30.
- What makes a good source image
- Armor as real shapes rather than painted lines. Strong contrast. Flat light. Arms clearly away from the body, because that's the one that broke a pilot.
- Restore what rigging throws away
- The rigging step silently dropped two texture maps and made the model fully self-lit, so no light in the scene touched it. A script puts them back.
- Ship the textures you paid for
- My first builds looked blobby next to the same character in the vendor's viewer. Geometry was never the issue. It was texture resolution. Delivery went to 4096 maps at about 4.2 MB a pilot, which works because the picker only loads one at a time.
- Repaint without a rebuild
- A torn visor is a texture fault. Repainting takes 15 credits against about 60 for a rebuild, and I repaired a batch this way. But one repaint came back identical, because that source helmet had no visor to repaint. Check the source before spending.
- Three idles, on purpose
- A character spends most of its time idle. One looping idle reads as a mannequin. So every pilot cycles through three, plus a shared set of moves, and any pilot can do any of them.
- Gold needs something to reflect
- Gilded boss statues are a referral prize. Tuning the lamps didn't work, because metal only shows what it reflects. It needed an environment.




I directed the films like films, then measured what the models really do.
Each boss has its own encounter: it arrives, taunts you, fights, and falls apart when you win. I made stills in Higgsfield with GPT Image 2, then video with Seedance. A captain named Reyes talks to the player between fights. "Identity is won or lost in the still" became a rule, because the video reproduces every flaw in its first frame.
Every prompt and start frame for the four encounters took about 2,700 credits of directed work. Then I found out it all lived in a temporary folder the operating system could wipe. So now a ledger records each render's exact inputs. A vertical version of a film is a loop over that ledger, not a dig through old chats.

The transmission screen, where Reyes talks to you between fights.
- Tell the model what's true, don't forbid
- "No push-in" got ignored. "The camera is bolted to the floor and NEVER moves" worked. These models have no negative prompt, so a "no" is only more words about the thing you don't want.
- Extract the join, never recreate it
- Shots chain end frame to start frame. One loop started from a hand-made lookalike instead of the real last frame. It looked close enough until someone drew a center line on it. Measured, the mismatch was 14.37, where two neighboring frames sit at 1.34. A tool now extracts every join and checks it by hash.
- Always render with sound
- Muting later is one flag. Adding sound later is a whole render. And the generated sound lands on its own picture: the loudest moment fell on the frame of the biggest visual event.
- Two tests for lip sync
- Sync and stillness are separate problems. A clip passes on both measures, or it doesn't ship. I also learned to measure inside a shot, never across a fade, after a "fix" for a 79 ms offset created the drift I then complained about.
- Tag how sure you are
- Every rule in my film skill is tagged: measured by us, from documentation, general craft, or a bet. A bet can't become a rule until it's measured.
- A rule with a date on it
- A finding about audio on one Seedance version didn't hold on the next one. So rules now record what was measured, on which version.
- Draft cheap, price it, then ask
- A finished 14-second scene is about 180 credits. Composition gets settled in drafts. No video gets generated until I approve the spend.

The final boss starting to fall. A still from the defeat film.
The biggest sound fix was a default nobody had chosen.
The soundtrack is my own Suno tracks, switched by scene. Reyes' voice is one I designed in ElevenLabs, cloned into Higgsfield, with a vibe note on every line.
One lesson was bigger than audio. Her voice ran on one engine for a month until I asked why we weren't using ElevenLabs through Higgsfield. Side by side, the same intro ran 24.85 seconds against 18.24, and a laugh got performed where before it was spoken as syllables. Nobody had chosen the old engine. It was a default no one had decided, and that went into the brief.
- The voice ships inside the clip
- A separate voice track started alongside a silent video was two clocks aligned once, and it drifted. Now they're one file. The price is on iOS: the element has to be primed by a real tap beforehand, and volume can't be set in code, so levels get baked in when it's encoded.
- About 300 recorded sounds in one night
- I played ten new experiments and told the agents "the sound effects all suck." They were stand-ins nobody had replaced. Now a new sound ships recorded: several takes from ElevenLabs, measured and ranked, with a check for what a phone speaker can even play. My ear is the last gate, because the builders can't hear.
- Two audio paths, one lifecycle owner
- Effects and music use different browser systems with different unlock rules. Mixing them up was the top cause of mobile audio bugs. One module owns all the recovery logic.
Then I built a second product in about a day.
In mid-October I pointed the same system at physics. The first 11 experiments reached production on October 15, built in one day by about 15 parallel agents working from shared briefs for UX and art. By the end of October there were 22: smoke tunnels, Build an Atom, a roller coaster, orbits you can crash a moon through.
Each one has a question, things to try, clues and a short quiz, and you earn a patch. Your own pilot from Times Machine shows up in eight of them. These clips are real captures of the app.





A real app on Apple and Google, from one codebase.
I was an iOS developer before I was a designer, so I knew the danger: an app that's only a website gets rejected. The apps are Capacitor shells around the live product, with native features a reviewer can find and use. Most of the store work was paperwork. I turned that into tested files, so the listing can't drift from the code.
- iPhone and iPad
- Native Apple and Google sign-in on system sheets, haptics during play, seven app icons, a native launch animation, an offline screen, a rate-us prompt after a win, in-app account deletion, and separate iPad layouts.
- TestFlight since August 29
- A one-command pipeline builds and uploads. On one user-testing day I ran eleven device findings through eight merged PRs before the day ended.
- App Store machinery
- Screenshots from a repeatable pipeline in three complete directions, on real captures. Safe uploaders for screenshots and preview videos. Review notes pinned by tests. A demo family with every boss ready, so a reviewer can see it all.
- A new Apple rule, written into my process
- On October 16, Guideline 2.5.19 banned hidden or undocumented features. Since the app loads the live site, a flag could put a new game in front of families without Apple seeing it. So my rule is now written down: a new game reaches iOS only through a reviewed app version, even if the binary is identical.
- Android
- Same shell, native Google sign-in through Credential Manager, and a paste-ready submission pack for Play Console. It sells nothing in the app, which keeps Google's cut at zero. Families buy on the web.
- Kids and privacy
- No ads and no chat. The apps run no analytics on the Player's screens. A grown-up gate protects money and account moves. The privacy labels are pinned to the code by a test.
The iPhone app: practice home, a boss entrance, a Player's field report and the family picker. Demo family.
Money gets the strictest rules in the repo.
I priced one family pass and one solo pass, sold on the web through Stripe. I planned Apple in-app purchase, then cancelled it. The iOS app is US-only for version one, and it opens Stripe in a browser sheet. The prices will change as new games arrive, so I built the system to make a stale price impossible to type.
- One file holds every price
- A CI test fails on any dollar amount typed into the UI. Stripe prices are created from that file by a script, and a drift test checks that the two agree.
- A locked price for early families
- Stepped prices, where a subscriber keeps the price they joined at. Even the strikethrough can only show the next step I've committed to.
- I asked for spoof testing
- "Make sure you can't spoof through paying." An audit listed 13 ways to try it. Each one now has an executable test or a written verdict, and three got fixed.
- A purchase ends in the game
- A new buyer lands on a celebration and the game, never on an identity check.
Growth is built into the product, ready for launch.
All of this is in code. None of it has real volume behind it yet, so I can tell you what I built and nothing about how well it works. I also read my own weekly memo the same way: the first one found a real checkout that started and never finished, and showed a referral factor of zero.



- Technical SEO
- One metadata helper for every public route, a sitemap, robots rules, and JSON-LD structured data. Every public link unfurls with a proper image.
- Answer engines
- An llms.txt file, and a written GEO strategy that labels each claim as measured, vendor or academic before anything got built. It was written to discount vendor hype.
- Pages people search for
- A free speed check with a shareable result, and a standards page that maps multiplication practice to Common Core, Texas and Florida, fact by fact, with sources.
- Lifecycle emails
- Welcome, checkout left behind, out of tokens, and after purchase, all from one branded shell with sending caps. A claim is recorded before each send, so a retry can't double-mail anyone.
- A launch email that can't fire by accident
- It has no route and no cron. A person types the command. It looks first, tests next, sends 5, then the rest. It refuses to send without a live store listing.
- Loops
- Two-sided referral credit, trophy and certificate share cards with their own images, a challenge at every win, and family invite links. A designed classroom loop isn't built, so I don't count it.
- A social kit
- A cut for each platform from one master, each with captions clear of the platform's buttons.
I turned the expensive lessons into skills that any agent can load.
The biggest is a 153 KB skill on directing AI film, written from my own tests. A skill is a written playbook an agent reads before it starts a job. Some of these I wrote from scratch, and some I brought in and changed. Here's which is which.
- cinematic-directionMine. 153 KB on directing AI video: shot language, measured Seedance rules, house style, what reads as AI
- reel-viral-playbookMine, from my own research session. Platform signals and a 12-point scoring rubric to use before anything gets made
- Character pipelineMine. A runbook, with a helper tool for merging clips and restoring textures
- Reyes briefMine. A character bible with voice dials, a look lock and dated reasons for each rule
- reel-script, humanize, caption, audit, repurpose, researchAdapted. MIT skills I brought in and changed for this game
- reel-edit-craft, reel-remotionAdapted from MIT plugins, for the trailer and its cutdowns
- Higgsfield skillsVendor's own. My film skill lists where they disagree with what I measured
What it costs, as far as I can honestly say.
My cost sheet has one rule: a blank means unknown, never zero. So it refuses to give a total while lines are missing. In September, I could price five of twelve lines. The rest stayed blank, so I don't have a true all-in number, and I won't estimate one here.
Most of what broke was silent. Here's the list.
Many of these were silent. Nothing errored, and nothing looked wrong until someone checked.
The list
- The launch date. I planned September 22, with October 6 as the fallback. It's now November 3. I kept adding to the product, and that's on me.
- A paywall that was only in the UI. The six-Player limit lived in the app, so any signed-in account could add Players directly through the API, free. I moved the limit to the database.
- Referrals that counted nothing. From mid-July to early September, every in-app share link bounced through login and lost its code. Nothing errored.
- Code deployed before its database. An auto-merged change called a database function that didn't exist yet, and Add Player failed for every family until I applied the migration by hand. PRs with migrations never auto-merge now.
- Six hours on a stale build. The overnight run hit my hosting plan's daily deploy cap. Refused deploys aren't retried, so production sat behind while the dashboard looked calm.
- Emails that never left. A cap bug kept every lifecycle email from sending until I caught it in October.
- A sign-in that died silently. Starting Google sign-in on one host and finishing on another lost a cookie, with nothing logged on either side. A parent would just see it fail.
- Too many agents. Seven at once took my Mac's load past 36 and got three killed mid-work. It looked like API trouble. In late October, about 300 processes froze the machine again, and a game that seemed down was my own overload.
- Prompts lost to a reboot. Boss defeat clips vanished with a purged temp folder, about 400 credits of footage. I got them back byte for byte from the job records. Now the masters live outside temp folders, and every shot's job id is in the ledger.
- A brief that lagged the art. Reyes' armor changed in one pass and the brief didn't. Two weeks later a render followed the document and produced the wrong character. Now the brief changes in the same commit.
- One direction, no options. I built the splash screen from a "make me something incredible" brief, as one take. It sat unmerged until I redid it as four. A vague brief should get several shots from the start.
- CI that tested the wrong runtime. It checked Node 20 for months while production built on Node 24. It also ran every test twice until I fixed it on October 31.
- Uneven art. Some rooms in the Lab are beautiful, and some aren't there yet. I got through one room of an art pass, then stopped so I could launch.
Live on the web, with the App Store launch planned for November 3.
The web version is live at masteryarcade.com. The App Store launch is planned for Tuesday, November 3. Apple hadn't received the app for review the last I checked, on October 31, so that date depends on review. If Apple runs late, the plan is to launch on the web on the 3rd and let the store follow.
The launch is the real test, and I'll put the results here, good or bad.
- Why Google Play is later
- A new personal developer account has to run a closed test with at least 12 testers for 14 straight days before it can publish. The shell and the submission pack are prepared. I put the test on the back burner to focus on launch.
- Still in progress
- A first-run cutscene for Times Machine. Spellwright, a spelling game, is built but isn't part of launch. Worldsong, a music and geography game, is next.
- What I can't tell you yet
- Whether it teaches better than other ways of practicing. I haven't run that study, and the product's own evidence page says so.
Everything it took, from Midjourney to the App Store API.
- Claude CodeNearly all the code, plus agents and routines
- MidjourneyApproved character art
- MeshyImage to 3D, rigging, animation
- HiggsfieldThe film pipeline, stills to video
- SeedanceBoss and character video
- GPT Image 2Film stills
- Kling, Veo, RunwayOther video tests and shots
- ElevenLabsVoice design and sound effects
- SunoThe soundtrack
- OpenAI, Gemini, GrokOther models along the way
- Three.js, React Three FiberCharacters, trophies, the Lab
- Next.js, React, TypeScriptWeb app and every game
- CapacitoriOS and Android shells
- SupabasePostgres, auth, row-level security
- StripeCheckout and subscriptions
- ResendSign-in and lifecycle email
- PostHog, SentryAnalytics and errors
- VercelHosting
- FFmpeg, RemotionEncoding and social cuts
- Vitest, PlaywrightUnit and browser tests
- ts-fsrsSpaced repetition
- GitHub Issues, ActionsThe work queue and CI
- App Store Connect APIScripted store uploads
I can run this system inside your company.
Agents, rules, evals, skills and a person making the calls. I've done it alone, from the first commit to a live product, and I can teach your teams to work this way.
Start a conversation





