A quiz game for humans, but homework for agents

The future will be architected by engineers who can onboard other engineers' agents.

I built a multiplayer quiz game in Warp. Not because the world needed another trivia app, but because I used to be a teacher and I saw an opportunity to engage my AI learning group at LinearB. I know how to keep people engaged: a timer, a leaderboard, and just enough chaos to make you care about the next question.

But when Zach Lloyd (Warp’s CEO, recent Dev Interrupted guest, and the guy who once built Google Sheets) invited me on his livestream, I didn’t show up with a polished demo. I handed him a scrappy quiz game I vibe coded one afternoon and said: here’s the repo, now let your agent figure it out.

The experiment wasn’t just about building a feature. It was about a new kind of handoff: my agent documenting for his agent, markdown plans alongside code comments, and humans collaborating through AI instead of around it.

What happened next looked less like software engineering and more like teaching a classroom that happened to contain a human, an agent, and a few hundred livestream viewers.

Teaching the agents

When Zach agreed to pick up my repo live on his stream, I realized this wasn’t just a human handoff. He’d be onboarding with his agent.

So I did what I always did as a teacher: I prepped lesson plans.

• SPEC.md ➡️ the original project plan

• WARP.md ➡️ quick navigation notes, like an AGENTS.md

• ZACH.md ➡️ a doc written specifically for Zach’s agent

That last one changed everything. It wasn’t just documentation that an agent could parse. It was documentation written in the language agents think in: structured, contextual, explicit. I instructed my agent to hand that off to Zach’s agent.

When Zach’s agent read it, the handoff was instant. It didn’t just see the code, it understood the intent behind it. And then Zach was ready to pick up where I left off.

Voice as the interface

Another real mind-bender as we went along was Zach’s voice leading the charge.

He didn’t type prompts. He dictated them. Out loud. Messy, mid-thought, “let me just describe what I see on the screen” style. I had been doing this for a while. I recently did this on the Goose livestream, but it was really damn cool to see someone else doing it too.

And the agent understood those prompts, by the way.

• Syntax error? He just described it, and the agent patched it.

• Visual bug in the avatars? He said, “maybe the thresholds need tweaking,” and the agent spit out options and fixes.

• Deploy to Cloudflare? One sentence, and it walked him through the flow. (Thanks to my agent for writing handy deploy commands and scripts)

It was teaching while thinking out loud, the same way I used to do in front of a classroom. The same way we debug together at a whiteboard. That really hit home for me: the bottleneck isn’t the model or even the UI. It’s the keyboard. Strip that away, and iteration flows as fast as you can talk and the model can think.

Avatars, test harnesses, and a glorious experiment gone so, so right

The feature the four of us (me, Zach, and our two agents) built together was simple on paper: replace the boring lobby initials with unique Identicon-style avatars.

But the process was messy. And that’s what made it so fun to do together.

• The agent generated a full avatar system and a test harness page to preview them. (Zach and I agreed we never would’ve taken the time to build that by hand.)

• The colors clashed. The letters disappeared. We argued with the agent about light/dark thresholds like it was an unruly student. Zach copy/pasted screenshots to illustrate his point. The LLM ceded the argument and fixed it.

• A socket connection broke mid-demo. The agent caught it faster than we did.

• Deployment hiccuped when it defaulted to the wrong branch. It fixed itself live.

It was a fast, safe iterative loop that made the mess survivable, and even a lil fun.

The bigger experiment

What we stumbled into wasn’t just a livestream hack. It was a glimpse of a new collaboration stack:

• Git as the whiteboard

• Markdown as the spec

• Voice as the interface

• Agents as the medium

I handed a working app to someone who’d never seen it. His agent read my agent’s notes. Literally, I’ll have my people talk to your people. Together, we extended it, debugged it, and shipped something live in under an hour.

That’s not just better tooling. That’s a new way of working.

What I learned the hard way

Messy as it was, some patterns emerged:

• Artifacts are infrastructure. Markdown files (SPEC.md, WARP.md, ZACH.md) mattered more than the source code. They were the scaffolding that let two agents work together.

• Test small before you integrate. The avatar test harness was a lifesaver and let us ship within the hour. Isolate, then expand.

• Commit like a metronome. Frequent commits weren’t just checkpoints, they were conversation boundaries for the agent.

• Voice for flow, keyboard for precision. Talking got us 90% of the way. Editing by hand cleaned up the edges.

• Context is currency. We managed the context window like it was oxygen on our submarine.

Open questions

Of course, it raised as many questions for me as it answered:

• How do we version-control agent instructions? I continue to grapple with this, especially as rule file locations, structures, and expectations continue to evolve for every tool, it feels like.

• What’s the right abstraction for an agent-to-agent handoff? Markdown is the best substrate, but what else could my agent have encoded in that format for maximum usefulness and future-compatibility?

• What does this look like with teams of five, or fifty, instead of two? We’re all still figuring this part out.

Why I’ll keep doing this

I used to prep lesson plans for students. Now I prep lesson plans for agents. And the classroom isn’t gone, it’s just bigger. It stretches from my repo to Zach’s terminal to every viewer watching along.

That’s the real magic of agentic coding tools like Warp: it makes the messy process of learning feel not just doable, but share-worthy too.

Want to see the full session? Check out the replay on Warp’s YouTube channel and my code on GitHub. And if you’re experimenting with agent-to-agent collaboration patterns, I’d love to hear about it. The community learns fastest when we share our experiments openly.