How muxd Built Pass the Potato: A Game in One Prompt with Parallel Pipelines

We wanted to see what happens when you give muxd a single prompt and let it go wild. The result: Pass the Potato, a fully playable async multiplayer game with a web app, admin panel, mobile app, SMS notifications, and push notifications. Almost entirely built by the agent.

What Is Pass the Potato?

Pass the Potato is an async social game. Someone starts a potato and sends it to you. You have to pass it to someone else before the timer runs out. If you are holding it when it expires, you get splatted. 💥

That is the whole game. Simple, chaotic, and surprisingly fun.

The game has four potato types with different timers:

Each pass builds a chain. You can see the full history of who held the potato, what they said, and how long they waited before passing it on. There is a leaderboard for top passers and a hall of shame for the most splatted players. SMS and push notifications let you know when someone sends a potato your way.

The Tech Stack

This is not a toy project with a single file and a SQLite database. The agent built a real production app:

Monorepo (Turborepo)

• @potato/db: shared Drizzle ORM package
• @potato/shared: shared types and utilities
• @potato/push: push notification package

Frontend

• Next.js 15 with App Router for the web app and admin panel
• Tailwind CSS for styling
• Deployed on Vercel

Backend

• Next.js API routes (serverless)
• Drizzle ORM with Neon (serverless Postgres)
• JWT auth with httpOnly cookies
• Twilio Verify for OTP via SMS

Notifications

• Twilio SMS for gameplay notifications
• Push notifications via Expo push service

Mobile

• Expo / React Native for native iOS and Android

The agent set up the entire Turborepo workspace, wired up the shared packages, configured Drizzle with Neon, integrated Twilio for both auth and gameplay SMS, and got the Expo app scaffolded. A full-stack monorepo from one conversation.

The Prompt

We started with something like this:

Build me a web game called "Pass the Potato". It's an async multiplayer game where players pass a virtual potato to each other before a timer expires. Include different potato types, a leaderboard, SMS notifications, user accounts with phone auth, and a mobile-friendly frontend. Use Next.js 15 with App Router, Tailwind CSS, Drizzle ORM, Neon Postgres, and set it up as a Turborepo monorepo. Also scaffold an Expo mobile app.

One prompt. The agent did the rest.

Where Parallel Pipelines Shined

Building a full-stack monorepo involves a lot of independent work. The database schema does not depend on the Tailwind config. The SMS notification system does not depend on the leaderboard UI. The Expo app scaffold does not depend on the admin panel. muxd recognized this and split the work using the parallel pipeline, running multiple agent tasks simultaneously as a DAG.

Here is what the pipeline looked like:

⚡ Pipeline
[✓ set up Turborepo + shared packages] ──▶ [✓ Drizzle schema + Neon config] ──▶ [✓ API routes]
                                            [✓ Next.js frontend + Tailwind]
[✓ Twilio SMS + OTP auth]
[✓ Expo mobile scaffold]
[✓ Leaderboard + pass chains]

The agent identified that API routes depended on the database schema, which depended on the monorepo setup. But the frontend styling, Twilio integration, Expo app, and leaderboard could all be built in parallel after the initial workspace was ready. Six tasks across multiple layers of the stack, running concurrently.

That parallelism is the difference between waiting 30 minutes and waiting 10. The agent was scaffolding the Expo app in one task, setting up the Drizzle ORM schema in another, and wiring Twilio Verify in a third, all at once.

What the Agent Built

Here is the breakdown of what came out of that session:

Monorepo Setup

• Turborepo workspace with shared packages
• @potato/db with Drizzle ORM schema definitions
• @potato/shared for types and utilities used across web and mobile
• @potato/push for Expo push notification handling

Backend (Next.js API Routes)

• Serverless API routes on Vercel
• Neon Postgres via Drizzle ORM for users, potatoes, pass chains, and game state
• JWT auth with httpOnly cookies
• Twilio Verify for phone-based OTP login
• Four potato types with configurable timers
• Pass chain tracking with message history
• Expiry checker that splats players when their timer runs out

Frontend (Next.js 15 + Tailwind)

• Mobile-first responsive design
• Potato sending with username lookup and share links
• Live pass chain visualization
• Leaderboard and hall of shame
• Admin panel for managing users and potatoes
• Clean, playful UI that fits the vibe

Notifications

• Twilio SMS for gameplay events (potato received, potato expired)
• Expo push notifications for mobile users

Mobile (Expo / React Native)

• Native iOS and Android app
• Push notifications
• Same game experience optimized for mobile

The agent even wired up the full auth flow from phone number entry, to Twilio Verify OTP, to JWT issuance and httpOnly cookie management. Production-grade auth from a prompt.

The Development Loop

What made this work well was the feedback loop. The agent could:

1. Write code: file_write and file_edit to create and modify files across the monorepo
2. Test immediately: bash to run the Next.js dev server and curl API endpoints
3. See errors: read compiler output, fix type errors, and iterate
4. Search for context: web_search for Drizzle ORM docs, Twilio Verify API references, Neon connection strings
5. Deploy: push to Vercel and have it live

All of this happened within the muxd agent loop. The agent wrote code, ran it, saw the error, fixed it, and tried again, the same loop a human developer uses, but faster and without getting tired.

What We Learned

A few things stood out from this experiment:

Parallel pipelines are not just a performance trick. They changed how the agent approached the problem. Instead of building everything sequentially and risking context drift across a massive monorepo, the agent could focus on one subsystem at a time while others ran independently.

The agent handles monorepo-scale work better than expected. Turborepo config, shared package wiring, Drizzle schema design, Next.js API routes, Tailwind styling, Twilio integration, Expo scaffolding, it juggled all of it without losing track of the overall architecture.

One prompt is powerful, but iteration matters. The initial prompt got us 80% of the way there. A few follow-up messages refined the UI, fixed edge cases, and polished the game feel.

Play It Yourself

Head over to passthepotato.to and start a potato. Send it to a friend. See how long the chain gets before someone gets splatted. 🥔

Build Something Yourself

The same agent that built Pass the Potato is available to you:

go install github.com/batalabs/muxd@latest

Give it a prompt. See what it ships. The parallel pipeline kicks in automatically when the agent sees independent tasks it can run concurrently. You just describe what you want, and the agent figures out the rest.