The Joy of Watching AI Agents Work: Sports Commentary for Code

Last night, I found myself genuinely entertained watching progress bars.

Not just any progress bars—I was watching four AI agents build a feature for me, in parallel, while narrating their progress like a soccer match. And it was fun.

If you haven’t read my previous post on 10x Coding with Parallel AI Agents, I recommend starting there. It explains how Zerg orchestrates multiple AI coding agents in parallel using barrier synchronization. This post is about making that process entertaining.

The Setup

I needed to add a new feature to a web app. Instead of building it myself or asking one AI agent to do it sequentially, I broke it into four tasks:

1. Research the API integration
2. Build the frontend UI
3. Build the backend API
4. Integrate and deploy

Using Zerg, I launched all four agents with barriers:

zerg run ~/prompts/myproject --prefix MIX --barrier 1 --barrier 3 --robot

This means:

• Agent 1 runs first (research)
• Agents 2 and 3 run in parallel after Agent 1 finishes
• Agent 4 runs after Agents 2 and 3 both complete

Then I asked Claude to narrate the execution like a World Cup match.

The Narration

What followed was fifteen minutes of genuine entertainment:

GOOOOOOL! MIX1 SCORES at 77 seconds! The Research striker has found the back of the net with a clinical finish! The crowd goes WILD! That’s 1-0 to the home team!

The referee signals the first barrier is CLEARED - Phase 2 is GO!

AND LOOK AT THIS! Manager Zerg has deployed a TWIN STRIKER formation! MIX2 “Frontend” and MIX3 “Backend” are BOTH making runs down the pitch simultaneously! This is BOLD tactics!

As agents completed their work:

MIX3 “Backend” BURIES IT at 3 minutes 14 seconds! That’s 2-0! The API endpoints are COMPLETE! But wait - Barrier 3 is still standing! It needs MIX2 to also score!

MIX2 is still battling! 5 minutes… 6 minutes… he’s deep in JavaScript territory!

And when the frontend finally completed after 6 minutes:

THE BARRIER CRUMBLES! MIX4 “Integration” is ON THE PITCH! The super-sub is SPRINTING towards goal!

The match ended 4-0 in 11 minutes 43 seconds. I was genuinely rooting for MIX2 when it fell behind.

How to Try It Yourself

Prerequisites

You’ll need the parallel agent setup from my 10x Coding post:

• Zerg for orchestration (GitHub)
• Toad for running individual agents (my fork)
• tmux for managing agent windows

Step 1: Create Your Prompts

Create a directory with your task breakdown:

mkdir -p ~/prompts/myproject

# Shared context for all agents
cat > ~/prompts/myproject/prompt_master << 'EOF'
# Project Context
You're building a web feature.
Working directory: ~/repos/myapp/
Tech stack: Python Flask, vanilla JavaScript
EOF

# Individual agent tasks
cat > ~/prompts/myproject/prompt1 << 'EOF'
# Research Phase
Investigate the API we need to integrate with.
EOF

cat > ~/prompts/myproject/prompt2 << 'EOF'
# Frontend UI
Build the user interface components.
EOF

cat > ~/prompts/myproject/prompt3 << 'EOF'
# Backend API
Create the API endpoints.
EOF

cat > ~/prompts/myproject/prompt4 << 'EOF'
# Integration
Wire everything together and deploy.
EOF

Step 2: Launch the Swarm

# Preview first
zerg run ~/prompts/myproject --prefix P --barrier 1 --barrier 3 --dry-run

# Run with robot mode (agents auto-complete)
zerg run ~/prompts/myproject --prefix P --barrier 1 --barrier 3 --robot

Step 3: Ask for Narration

In a separate Claude session (or the same one if you’re using Claude Code), say:

“Narrate this zerg run like a soccer match”

Claude will monitor the progress using zerg plan myproject and provide live commentary.

Step 4: Enjoy the Show

Watch as your AI agents compete to complete their tasks:

# Check status anytime
zerg plan myproject

# Peek at an agent's output
tmux capture-pane -t zerg-myproject:P2 -p | tail -30

Narration Styles to Try

Soccer isn’t the only option. Ask for:

• Nature documentary: “And here we observe the Backend agent in its natural habitat…”
• NASA mission control: “T-minus 30 seconds. All systems nominal. Frontend is GO.”
• Heist movie: “The Frontend is in. Backend is cracking the vault. We need 3 more minutes.”
• Boxing match: “Round 2! Frontend comes out swinging with a beautiful left hook of CSS!”
• Horse racing: “And they’re off! Research takes an early lead, but Frontend is closing fast!”

Why This Actually Works

This isn’t just a gimmick. There are real benefits:

1. It makes waiting fun. Building software involves waiting for tests, builds, deployments. Narration transforms passive waiting into active watching.

2. It provides natural status updates. Instead of checking dashboards, you get real-time commentary on what’s happening and why.

3. It creates emotional investment. When MIX2 was taking longer than expected, I was genuinely rooting for it. That emotional engagement keeps you attentive.

4. It’s legitimately informative. Between the jokes, you learn which parts of the work are slow, which complete quickly, and where the bottlenecks are.

A Glimpse at the Future

As AI systems become capable of doing more complex work autonomously, humans will shift from doing to supervising. And supervision can be boring. Really boring. Staring at logs, checking dashboards, waiting for completion notifications.

But it doesn’t have to be.

The same AI that does the work can also make the supervision engaging. It can tell you a story about what it’s doing. It can celebrate wins with you. It can build drama around blockers and relief around solutions.

This isn’t about making work “gamified” in a manipulative way. It’s about recognizing that humans are narrative creatures, and even technical work can be framed as a story worth following.

The Final Score

My match ended with a complete feature deployed in under 12 minutes:

Final score: 4-0. The crowd went home happy.

For the full technical setup, see 10x Coding with Parallel AI Agents.