I hoped for
six games.
They built
an arcade.
A room full of network engineers.
Two hours to make something nobody had made before.
Before there was an arcade,
there was Andy.
I had one hour to explain spec-driven development to Andy Lapteff. Live. With Andy driving.
I wanted him to experience it. To go from an idea, to a written specification, to something he could actually run. That meant finding an idea we could understand immediately, care about enough to finish, and enjoy building in public.
Video games. Who doesn’t love video games?
But it couldn’t be just any game. It had to relate to networking. And it had to teach something. That gave us a useful constraint: take knowledge we already have as network engineers and turn it into an experience that helps somebody else learn.
That became my episode with Andy, “Stop Vibe Coding: Start Spec-Driven Development.” The episode became the seed of a workshop. The workshop became this arcade.
The exercise had a second lesson built into it from the beginning. We would learn a way of building software by building software that teaches. The method and the result would both be useful.

One idea. One live session.
A very different kind of lesson.
Andy at the controls. A networking game as the shared problem. Specifications as the way to make the intent concrete.
Watch on YouTubeThe player connects to YouTube when you press play.
I was
very nervous.
Third sold-out workshop in a row. First time teaching this workshop. First time teaching SDD at this scale.
I had a plan, a lecture, a starter game, and examples. I also had a room full of people who had paid extra to be there. They had chosen to spend that time with me when there were other excellent workshops they could have attended.
That means something to me. It carries a responsibility.
I was introducing spec-driven development, and then adding Ralph Wiggum loops to spice it up. We were going to ask an AI coding agent to work through a specification, test its work, inspect what happened, and keep going. And the thing we were asking network engineers to make was a video game.
Was this too far? Too much? Too distant from the core of network automation?
I didn’t know how it would land. It was the first time. I couldn’t point to a previous run of this workshop and tell myself it would be fine.
We ended up letting roughly 15 more people into the space, bringing the room to about 75 participants. Some worked together; some worked alone. Experience varied. For some, it was their first time opening an AI coding agent.
“We are network engineers?
We are going to make a video game in two hours?”
Yes.
Yes.
That was the first and only question between the two blocks. Really, two bewildered comments. Seif had put into words the leap I was asking everybody to make.
I had hoped for six games. Six would have told me the idea worked.
My original write-up recorded the first game live on the internet 41 minutes after the build began. Seif later told me his own game took 68 minutes to build, then three minutes to push live. Those are two different milestones, and both still make me smile.
By the end, there was an arcade taking shape. And then the building kept going. People refined balance, added levels, changed interfaces, and sent me new links through the week. The finished collection includes those later improvements. This is what the workshop started, not a claim that every line and asset appeared in a single two-hour sprint.
Three examples.
Permission to imagine.
My starter was Per-Hop Works. Joksan Flores and Elliot Conner each built a game too: RIBRush and Backbone. Together, the three demos made the exercise tangible before anyone had to invent their own.
The games are wonderful.
The people are the point.

John Armstrong
John Armstrong was the first real external submission, beyond our starter and the two demo games. And he couldn’t even make the workshop.
He wanted to build a game anyway. So he used the PowerPoint and the instructions and did it completely on his own. His tower-defense game, Threat Level: Goose, is one of the best in the collection.
That is an extraordinary thing to discover as a teacher. The materials traveled farther than the room. Somebody who wasn’t there could follow the approach, bring his own imagination, and make something excellent.
John brings an inventive mind and real care to what he builds. I’m looking forward to having him on the Vibe Ops Lounge to talk about his innovative work, both personally and at Lumen. There is a lot I want to learn from that conversation.

Seif Allaoua
Seif’s game is PacketJedi: OSPF LSA flooding scope on a holomap, with five rounds that ask which routers actually receive each advertisement.
From those two bewildered comments to a working game in 68 minutes. Three more minutes to put it on the internet. That is his account of the build, and it captures the change in confidence better than any total in a table.
The idea is small enough to understand and complete enough to teach. Pick the receiving routers. See what you missed. Understand the flooding boundary. Play again.
Seif has become a close friend. I went into the workshop worrying about whether the lesson would work. I came out with relationships that matter to me.

Garrett · GTalksTech
Garrett’s Firewall Security Faceoff turns firewall decisions into a fully realized game world. Its hosted files include 22 3D models. The ambition is visible before you even start playing.
Go spend some time with Garrett at GTalksTech. Meeting young, hungry, brilliant, capable—and most of all curious—minds is one of the things I come to NAF AutoCon for.
I have an eye for talent. Garrett is a very kind, humble, witty, sharp young man, and I am excited about his future. Curiosity paired with the willingness to build and learn is a powerful combination.
His game belongs in this story. So does the person behind it.
Other contributors remain anonymous in this feature. Their work is celebrated below; the linked Arcade pages retain their existing credits.
Same workshop.
Wildly different worlds.
A specification gives an idea somewhere to stand. It doesn’t tell everybody to have the same idea.
This is the part I want you to spend time with. A room of network engineers looked at networking concepts and saw fishing, a kart circuit, a night shift, a Jedi holomap, a goose invasion, and a flying rack switch over a lava pit.
They brought taste, humor, field experience, memories of games they loved, and opinions about what would be fun. The agent could implement. The human still had to care.

Make a difficult topic feel gentle.
Subnetting becomes fishing. Soft colors and forgiving feedback turn repetition into something a beginner might actually want to do again.

Make the invisible visible.
A narrowing kart circuit makes a bottleneck tangible. Data and ACKs travel in opposite directions, while a separate evaluator keeps the networking answer honest.

Let the soundtrack carry the world.
Twenty original electronic tracks accompany a maze-building tower-defense campaign. The builder reshaped the design around the part that was actually fun.

Bring your own knowledge into the game.
Forty-two real command captures become three guided NOC investigations. The artwork sets the mood; the evidence determines what the player can conclude.

Leave room for ridiculous.
A flying 1U switch. A patch-cable lance. A lava pit. A recorded change to the constitution let a BGP lesson become an unapologetic arcade game.

Draw a world with code.
A pixel outpost, a switch rack, and six incidents until dawn. The first console quiz became a place the player could inhabit.
“This is not fun”
is useful feedback.
The foundation records five games that were substantially reworked after somebody played an early version and rejected the experience. That isn’t evidence the specification failed. It is evidence that the human was still paying attention.
The networking rules could survive while the interface changed. Tests could protect an answer while the animation became more expressive. A constitution could be amended when the creator deliberately changed direction.
In Uptime Survivors, scripted bots tried different strategies because one bot alone hid a balance problem. In Round Trip, a question about why the player should wait became a design rule. In Permit or Pew, the networking decisions live inside an arcade loop with movement, pressure, and feedback.
Creativity is also revision. Recognizing the part worth keeping. Admitting the part that isn’t working. Being specific enough that the next build gets better.
The bridge between
their agent and ours.
One Markdown file: ARCADE.md.
The workshop didn’t end at “it runs on my laptop.” To make an arcade, we needed a repeatable way to carry each game’s intent, history, runtime requirements, and evidence into this site.
The participant’s build agent had been there. It knew the specification, the tools it used, the changes the human requested, and the checks it actually ran. I wanted that knowledge to travel with the repository.
That is the role of ARCADE.md. It is a structured handoff, with machine-readable fields and a human-readable build story. It connects the session that made the game to the review that brings it here.
- HUMAN + BUILD AGENT
Make intent explicit.
A constitution states the rules. A specification describes the player, learning objective and behavior. A plan and task list turn that intent into work.
constitution · spec · plan · tasks - BUILD → VERIFY → REASSESS
Give the loop a target.
Implement a task. Run the relevant checks. Read the failure. Improve the work. A test that can reject an incorrect answer gives the next pass something concrete to fix.
implementation · evidence · next task - THE HANDOFF
Write what happened.
The agent records model, harness, sources, artifacts, assets, runtime and verification. The human supplies identity and consent. Unknown stays unknown; tokens and costs are never guessed.
ARCADE.md - OUR INTEGRATION PROCESS
Check the actual game.
Read the submission and source. Identify the revision. Run the checks. Play the important paths. Inspect layout, keyboard controls, recovery and accessibility. Preserve the original record.
review · playtest · document limits - THE ARCADE
Make it playable.
Package the runtime and assets, retain licenses, document necessary fixes, add the card and teaching story, then verify the site integration. A published game has a path back to its evidence.
Explore the Arcade
Ralph keeps returning.
The spec says why.
I introduced Geoffrey Huntley’s Ralph Wiggum approach because persistence becomes useful when there is a clear definition of done. The agent returns to the brief and the state on disk, attempts the next piece of work, and meets a verifier that can tell it the work is still wrong.
Repeating “make it better” is vague. “Complete the next task, run the relevant tests, compare the result with the specification, and record what remains” gives the iteration direction. The filesystem carries the work forward. A fresh model context does not need to remember an entire conversation.
The engineer still owns the intent and the judgment. A loop can continue confidently in the wrong direction if the expected behavior is wrong. That is why we clarified and analyzed the specifications, and why a person playing the result matters.
The connection to network automation is direct: define desired behavior, use authoritative sources, verify outcomes independently, preserve evidence, and know when to stop. The game made those habits approachable. The habits travel back to the network.
What travels in ARCADE.md?
| Section | What it carries | Why it matters |
|---|---|---|
| Game | Title, learning topics, level, card, repository and license | The player can understand what they are opening. |
| Creator | Human-supplied identity, optional links and consent | The agent cannot manufacture permission or identity. |
| Build | Exact reported model, harness, sources, skills, tools, specification artifacts and assets | Another engineer can understand the process. |
| Runtime | Start command, hosting model, dependencies, network/API requirements and save behavior | Building with an agent does not imply needing an agent to play. |
| Verification | Commands, recorded test results, factual sources and known limits | A claim is accompanied by something that can be checked. |
| Build story | Human decisions, failures, revisions and lessons | The creative process survives alongside the finished code. |
The file carries claims, not automatic trust. Our review may find a newer default mode, missing information, or a runtime fault. Those differences are documented instead of silently rewriting the original submission.
The workshop.
Open to you.
These are the original 98 slides, including the two embedded video clips. Browse the chapters, search the slide text, open the overview, or take the deck fullscreen. The original PowerPoint and a PDF are here too.
John Armstrong showed that the materials can be enough to get started, even if you couldn’t be in the room.
Original embedded clip. Use the video controls to play with sound.
Big numbers.
Specific meanings.
There is a lot of work here. Code that runs the games. Code that challenges their answers. Specifications that explain the intent. Art, sound, interfaces, and the revisions that make the result worth playing.
The tables distinguish the original 22-game write-up from the current 26-entry catalogue, and the builders’ recorded checks from our integration evidence. These are snapshots of the resulting work, including development after the workshop.
Original 22-game snapshot. The test counts were recorded by the builders; they are not 1,849 independently audited learning outcomes. Line counts include work completed after the workshop.
What does that scale
actually tell us?
The original corpus contains 187,654 non-blank lines across those three categories. There are about 39.5 lines of test code per 100 lines of game code. That is a measure of the material produced, not a coverage percentage.
Look at the distribution. Permit or Pew, Uptime Survivors, and AS You Were each have more test lines than game lines in the original snapshot. Small games can still have careful reasoning behind them.
I’m not converting lines of code into years of labor “saved.” Generated code can be verbose; test runners count different things; a small elegant program can be better than a large one. The more interesting question is what these engineers were able to imagine, finish, test, and share. For some, making a browser game had never felt like an available option.
| Subject | Games | Game lines | Test lines | Spec & doc lines | Recorded tests |
|---|---|---|---|---|---|
| Routing | 6 | 23,232 | 10,279 | 8,702 | 475 |
| Security | 3 | 23,568 | 7,881 | 5,030 | 468 |
| Network fundamentals | 8 | 30,326 | 15,717 | 13,958 | 588 |
| Pure arcade | 2 | 13,620 | 2,487 | 4,189 | 62 |
| Switching and the NOC | 2 | 9,412 | 3,535 | 7,576 | 146 |
| Automation | 1 | 4,518 | 1,416 | 2,208 | 110 |
| Original collection | 22 | 104,676 | 41,315 | 41,663 | 1,849 |
Every original game, by the numbers 22 games · foundation snapshot
| Game | Game code | Test code | Specs & docs | Recorded tests | Test / game lines |
|---|---|---|---|---|---|
| Firewall Security Faceoff | 14,704 | 2,207 | 2,531 | 193 | 15.0% |
| Backbone | 13,045 | 5,370 | 2,884 | 198 | 41.2% |
| Split Decision | 7,456 | 2,456 | 2,175 | 200 | 32.9% |
| Uptime Survivors | 7,074 | 8,763 | 6,776 | 165 | 123.9% |
| AS-PATH Of Glory | 7,029 | 0 | 264 | Not recorded | 0.0% |
| NetMaul: Defend the Datacenter | 6,591 | 2,487 | 3,925 | 62 | 37.7% |
| Threat Level: Goose | 5,867 | 1,857 | 1,208 | 67 | 31.7% |
| Peering Patrol | 4,972 | 1,674 | 1,994 | 93 | 33.7% |
| Round Trip | 4,518 | 1,416 | 2,208 | 110 | 31.3% |
| NOC Ninja — Guided NOC Patrol | 4,440 | 1,861 | 5,582 | 53 | 41.9% |
| PACketMan - Networking Maze | 3,647 | 1,425 | 828 | 48 | 39.1% |
| Packet Dash | 3,553 | 528 | 699 | 46 | 14.9% |
| Throughput | 3,338 | 975 | 859 | 60 | 29.2% |
| Permit or Pew | 2,997 | 3,817 | 1,291 | 208 | 127.4% |
| Exchange Hall | 2,509 | 969 | 1,268 | 100 | 38.6% |
| Slow Ping | 2,407 | 365 | 880 | 20 | 15.2% |
| TCP Kart: Congestion Control | 2,198 | 1,215 | 1,316 | 34 | 55.3% |
| AS You Were | 2,146 | 2,147 | 1,407 | 123 | 100.0% |
| RIBRush | 2,103 | 1,122 | 1,197 | 12 | 53.4% |
| Network Ops: Night Shift | 1,577 | 355 | 740 | 35 | 22.5% |
| Subnet Sashimi | 1,483 | 0 | 565 | Not recorded | 0.0% |
| PacketJedi | 1,022 | 306 | 1,066 | 22 | 29.9% |
Original method: JavaScript, TypeScript, CSS and HTML were formatted before non-blank lines were counted. Third-party libraries, Spec Kit templates, RFC reference text and generated traces were excluded. These measurements are preserved from the foundation, not represented as a fresh repository recount. “Not recorded” is not the same as zero tests. The final column measures code volume, not coverage.
The tests are part of the story.
A green test count is only useful when the checks can detect something that matters. These builds give concrete examples of what that means.
| Game | What was tested | What it protects |
|---|---|---|
| Split Decision | Hand-worked answers, a second implementation, and 26 deliberately planted bugs, all caught in the build record. | An independent expected answer and evidence that the tests can actually fail. |
| Uptime Survivors | Seeded runs with three bot strategies, rather than trusting the performance of one bot. | A balance problem that one play style concealed. |
| NetMaul | A recorded sequence of purchases replays the campaign through the player’s controls. | The whole experience remains completable after balance changes. |
| AS You Were | A winner must beat every other candidate one-on-one in the modeled BGP comparison. | The answer does not accidentally depend on candidate arrival order. |
| TCP Kart | The deterministic rule evaluator is separate from the animation; ACK timing was corrected after player feedback. | A convincing picture cannot override the protocol answer. |
| Round Trip | Commands sent, router configuration and packet behavior are represented separately. | “The script ran” is not confused with “the network works.” |
What our integration reviews added
These are recorded checks from the site’s existing game reviews. They are separate from the builders’ totals above and were not rerun simply to write this article.
| Game | Recorded checks | What the review established |
|---|---|---|
| Split Decision | 173 unit tests; 227 independent oracle comparisons; 27 upstream browser checks | Every one of the 20 designs matched an independently maintained answer key. All six rounds were completed with keyboard and touch emulation. |
| Permit or Pew | 208 upstream tests; 99 browser scenarios; 7 site checks | The six-wave campaign, movement, shooting, pause, hints and restart were exercised. The browser harness was adapted to macOS without changing the game. |
| Firewall Rule TypeRacer | 388 upstream browser checks; 18 integration checks; 17/17 runtime files unchanged | Keyboard and touch-emulated campaigns reached the endless finale. Failure recovery, restart, missed crossings and reduced motion were checked. |
| Network Change Roulette | 404 independent branch outcomes; 1,200 scoring combinations; 19 site checks | The review covered all 101 tickets (100 scored in the duel). Saved-state validation and an accessible retry screen were repaired in the hosted edition. |
Browser automation and touch emulation are not physical-phone testing, spoken screen-reader review, or a human learning study. No amount of passing software tests alone proves educational effectiveness. The games’ individual pages retain their specific limits.
Assets you can count.
Creativity you can’t reduce to a count.
The current local payload holds 619 files, totaling 30.58 MiB before transfer compression. The inventory below covers 25 locally hosted games. Uptime Survivors is externally hosted and excluded from this filesystem count.
The 39 model files include 22 in Firewall Security Faceoff and 17 in the Per-Hop Works starter. The 20 audio files belong to NetMaul. These are delivered files, not a claim that all 39 models were created during the workshop or that every image is original artwork.
A game can have zero audio files and still make sound: Peering Patrol synthesizes it in the browser. A game can have zero model files and still be 3D: TCP Kart constructs its circuit and karts in code. Inline SVG, canvas drawing, CSS illustration and procedural audio live inside code, beyond these extension counts.
The complete asset inventory 25 local payloads · 1 external game
| Game | All files | MiB | Raster | SVG | Audio | 3D | Fonts |
|---|---|---|---|---|---|---|---|
| AS You Were | 12 | 0.08 | 0 | 0 | 0 | 0 | 0 |
| AS-PATH Of Glory | 3 | 0.15 | 1 | 0 | 0 | 0 | 0 |
| Backbone | 13 | 0.33 | 1 | 0 | 0 | 0 | 8 |
| Exchange Hall | 13 | 0.16 | 1 | 0 | 0 | 0 | 0 |
| Firewall Rule TypeRacer | 17 | 0.17 | 0 | 0 | 0 | 0 | 2 |
| Firewall Security Faceoff | 61 | 5.28 | 11 | 0 | 0 | 22 | 0 |
| NetMaul: Defend the Datacenter | 65 | 7.90 | 1 | 1 | 20 | 0 | 0 |
| Network Change Roulette | 21 | 0.60 | 0 | 0 | 0 | 0 | 0 |
| Network Ops: Night Shift | 15 | 0.06 | 0 | 0 | 0 | 0 | 0 |
| NOC Ninja — Guided NOC Patrol | 19 | 2.35 | 5 | 1 | 0 | 0 | 0 |
| Packet Dash | 15 | 0.11 | 0 | 0 | 0 | 0 | 0 |
| PacketJedi | 19 | 0.05 | 0 | 5 | 0 | 0 | 0 |
| PACketMan - Networking Maze | 15 | 0.57 | 1 | 0 | 0 | 0 | 0 |
| Peering Patrol | 28 | 0.93 | 1 | 0 | 0 | 0 | 0 |
| Per-Hop Works | 113 | 4.49 | 10 | 0 | 0 | 17 | 0 |
| Permit or Pew | 19 | 0.19 | 1 | 0 | 0 | 0 | 0 |
| RIBRush | 12 | 0.13 | 1 | 0 | 0 | 0 | 0 |
| Round Trip | 14 | 1.19 | 2 | 0 | 0 | 0 | 0 |
| Signal Age | 31 | 2.13 | 15 | 0 | 0 | 0 | 0 |
| Slow Ping | 11 | 0.09 | 0 | 0 | 0 | 0 | 0 |
| Split Decision | 23 | 0.35 | 1 | 1 | 0 | 0 | 5 |
| Subnet Sashimi | 8 | 0.04 | 0 | 0 | 0 | 0 | 0 |
| TCP Kart: Congestion Control | 25 | 2.29 | 1 | 0 | 0 | 0 | 0 |
| Threat Level: Goose | 22 | 0.77 | 13 | 0 | 0 | 0 | 0 |
| Throughput | 25 | 0.16 | 2 | 0 | 0 | 0 | 0 |
| Uptime Survivors | Externally hosted · not counted | ||||||
| Local payload total | 619 | 30.58 | 68 | 8 | 20 | 39 | 15 |
Recursive file/byte counts include bundled dependencies and delivered documentation. Raster: PNG, JPG, JPEG, WebP, GIF, AVIF. Models: GLB, GLTF, OBJ, FBX, STL. Fonts: WOFF, WOFF2, TTF, OTF. The website’s separate Arcade card images and this lecture are outside the game payload totals. Zero means no standalone file of that type.
The current build records 26 entries · reported, not inferred
The current catalogue records 2,373 passing tests across 23 entries with positive numeric counts. Different suites count different units; do not add these to the earlier snapshot or treat their difference as measured improvement. Task, phase and prompt counts reflect different scopes and are not efficiency rankings.
| Game | Recorded tests | Tasks | Loops / phases | Human prompts | Harness |
|---|---|---|---|---|---|
| AS You Were | 123 | 37 | 6 | 15 | Claude Code (CLI, connected to VS Code) |
| AS-PATH Of Glory | Not recorded | Not recorded | Not recorded | Not recorded | Claude Code |
| Backbone | 198 | 70 | 9 | 19 | Claude Code |
| Exchange Hall | 100 | 46 | 6 | 15 | Claude Code |
| Firewall Rule TypeRacer | 388 | 6 | 3 | Not recorded | Codex |
| Firewall Security Faceoff | 193 | 68 | 9 | 29 | Claude Code |
| NetMaul: Defend the Datacenter | 62 | 11 | 5 | 20 | OpenAI Codex for VS Code |
| Network Change Roulette | 19 | 7 | 20 | Not recorded | Codex |
| Network Ops: Night Shift | 35 | 30 | 6 | Not recorded | Codex |
| NOC Ninja — Guided NOC Patrol | 53 | Not recorded | Not recorded | Not recorded | Codex |
| Packet Dash | 46 | 29 | 8 | 11 | Claude Code |
| PacketJedi | 22 | 28 | 6 | 11 | Codex CLI |
| PACketMan - Networking Maze | 48 | 39 | 6 | Not recorded | Copilot SDK in VS Code |
| Peering Patrol | 93 | 73 | 8 | 26 | Claude Code |
| Per-Hop Works | 78 | 69 | 5 | Not recorded | Codex |
| Permit or Pew | 208 | 51 | 9 | Not recorded | Claude Code |
| RIBRush | 12 | 31 | 6 | Not recorded | Copilot SDK in VS Code |
| Round Trip | 110 | 61 | 10 | 54 | Claude Code |
| Signal Age | 99 | 100 | Seven implementation slices recorded in tasks.md | Not recorded | Claude Code |
| Slow Ping | 20 | 29 | Not recorded | Not recorded | Codex desktop app |
| Split Decision | 200 | 83 | 9 | 14 | Claude Code |
| Subnet Sashimi | Not recorded | 16 | 3 implementation loops plus follow-up tasks | Not recorded | Not recorded |
| TCP Kart: Congestion Control | 34 | 30 | 6 | Not recorded | Copilot in VS Code |
| Threat Level: Goose | 67 | Not recorded | Not recorded | 263 | Claude Code |
| Throughput | Not recorded | 25 | Seven workshop steps run by hand, one at a time. No Ralph loop. | Not recorded | Claude Code in the Claude desktop app (Code tab) |
| Uptime Survivors | 165 | 292 | 6 | Not recorded | Claude Code |
Missing and zero-as-unknown build fields display “Not recorded.” Exact reported model IDs, sources and known limits remain on the linked game pages. The downloadable snapshot preserves the recorded fields without contributor identity.
Find something
you want to play.
All 22 games from the foundation are here with their original stories. The catalogue also includes my starter and three later additions: Signal Age, Network Change Roulette, and Firewall Rule TypeRacer.
Open a game’s story to see what it does, why it is interesting, and what it teaches. The cards are the actual Arcade cards.
26 games · a different idea behind every card

AS You Were
Pick the BGP path a router installs, then see which best-path step decided.
Read the game’s story
What it is
You play the route selector inside one router. Each round shows a table of candidate paths to a prefix and you pick the one that gets installed. Then a step ladder shows what happened at each of the first five best-path steps: tie, narrows, decides, or not reached.
Why it is cool
It was built in 59 minutes with 15 prompts. And it is rigorous. A wrong pick does not just say “incorrect”. It names the misconception behind it, such as believing a shorter AS-path beats a higher local preference. To make every answer match what a real router installs regardless of arrival order, each winner has to beat every other candidate one-on-one.
What it teaches
The order BGP compares attributes in: weight, local preference, AS-path length, origin, MED. That order is one of the most-memorized and most-forgotten lists in networking. Six rounds across three levels take about ten minutes, and the analysis pass caught out-of-range AS numbers before a line of code was written.
- 2,146 lines of game code
- 2,147 lines of tests
- 123 passing tests
- 59 minutes from first prompt to final report
- 15 human prompts
Story and figures from the original foundation snapshot.

AS-PATH Of Glory
Joust above a lava pit, riding a flying 1U switch.
Read the game’s story
What it is
A momentum-based jousting game in a single HTML file. You are a network automation engineer on a flying rack switch with a glowing patch-cable lance. Scalper bots, crypto miners and four parody boss characters come at you across twelve waves. Higher lance wins. You carry five lances you can throw and fly back to collect.
Why it is cool
It is gloriously silly, and it knows it. The graphics are drawn in code, the sound is synthesized at run time, and the boss waves are announced out loud by the browser’s own speech engine. The build record says it plainly: it is a fun arcade game with networking jokes, not a networking lesson.
What it teaches
The lesson here is in how it was made. The project began as a BGP AS_PATH teaching game. The builder changed direction, and the constitution was amended with the reason logged. The original rules banned projectiles, so the lance throw needed a recorded amendment before the code could change. That is spec-driven development doing its job on a game about jousting billionaires.
- 7,029 lines of game code
- One HTML file, 12 waves
- 17 scripted logic checks
Story and figures from the original foundation snapshot.

Backbone
Build the backbone. Never steer a packet. Predict where the congestion goes.
Read the game’s story
What it is
A dark map of North America and twelve cities. You lay fiber, set link costs and upgrade capacity. The traffic routes itself along OSPF’s lowest-cost paths. Overloaded links drop packets, fiber cuts force reconvergence, and you never get to touch a packet.
Why it is cool
It is the largest build in the collection, and it captures a feeling every backbone engineer knows: you tuned one metric to fix one path and were surprised by where the rest of the traffic went. It was first hand-built, then rebuilt from scratch the way the lab teaches, with nothing copied over. Three code reviews found thirty faults, and twenty-seven were fixed.
What it teaches
Shortest path first, link cost, reconvergence and capacity planning, grounded in RFC 2328. The lesson is prediction: before you change a cost or lose a link, where will the load move? It is aimed at working network engineers, not beginners.
- 13,045 lines of game code
- 5,370 lines of tests
- 198 passing tests
- 124 unit tests and 74 end-to-end tests
- Rendered in WebGL
Story and figures from the original foundation snapshot.

Exchange Hall
Choose where each packet leaves your network: IXP peer, route server, or transit.
Read the game’s story
What it is
You are on call at a small ISP that has just joined an Internet Exchange Point. It has an IXP port and a paid transit link. For each packet you decide which exit it takes, and wrong choices are explained with the exact prefixes and the rule you missed.
Why it is cool
The route server is always on the list of exits, and it is always wrong. That single design choice teaches the thing newcomers to peering get wrong most often. During analysis the agent found that a planned animation would have revealed the correct exit for free, and a new requirement fixed it before any code existed.
What it teaches
What really happens when a network joins an exchange: the route server never carries traffic, peers announce only their own and their customers’ prefixes, and longest prefix match wins before any peer-over-transit preference. It is for people who know what a /24 is and have never seen BGP peering.
- 2,509 lines of game code
- 969 lines of tests
- 100 passing tests
- 15 human prompts
- Every cited RFC section checked against the source text
Story and figures from the original foundation snapshot.

Firewall Rule TypeRacer
Read the flags and type firewall rules before the IPs hit the floor.
Read the game’s story
What it is
Read the request and threat flags on falling private IPv4 addresses. Type Allow, Deny, or Review when a rule is needed, then see how long you can keep up in the endless finale.
A later addition to the current catalogue, outside the original 22-game write-up. Open the Arcade page for its full build record and limitations.

Firewall Security Faceoff
Turn-based hex strategy where your firewall rules are the gates of a city.
Read the game’s story
What it is
Your network is a city on a 3D hex map and your firewall is its gatehouse. Wagons carry wanted traffic, raiders are attacks, and drifters are traffic nobody asked for. Each marches under a banner that says what your rules will do with it. Each turn you add, reorder and switch gates, then end the turn.
Why it is cool
A network engineer shipped a 3D strategy game with 22 models built by a Blender script the agent wrote, ten textures drawn by another script, and three pieces of music composed as note data. The story behind it is better still. The builder played it and said, four times, that it was not the game they wanted. The interface was thrown away and rebuilt four times. The rule engine and its tests did not change once.
What it teaches
First-match rule order, implicit deny, least privilege, application-aware rules, TLS inspection, DNS filtering and identity-based segmentation, sourced to NIST SP 800-41, NIST SP 800-207 and MITRE ATT&CK technique pages. A real-time arcade version and a text-only version of the same lessons ship alongside it.
- 14,704 lines of game code
- 2,207 lines of tests
- 193 passing tests
- 29 human prompts
- The largest attendee build: 14,704 lines of game code
Story and figures from the original foundation snapshot.

NetMaul: Defend the Datacenter
Build the maze. Make the next wave pass your best towers twice.
Read the game’s story
What it is
A maze-building tower defense across twenty waves, seven chapters and four bosses. You build walls of networking equipment, leave one passage open, and put your best towers where the same enemy will pass them on successive bends. Then you decide when to extend the maze and when to upgrade.
Why it is cool
It is a love letter to the custom tower-defense maps of the mid-2000s, with twenty original electronic tracks, one per encounter, synthesized offline. The first version was a routing, security and QoS simulator that could grade a packet trace. The builder’s verdict: configuring it took too much effort and building it was too little fun. So the campaign was built around the part they remembered loving.
What it teaches
The networking lives in an optional field guide that explains where every equipment name comes from, with sources from RFCs and vendor guides. The build teaches something too: a recorded shopping list of exact purchases replays the entire campaign through the same controls a player uses, so every balance change is re-proven.
- 6,591 lines of game code
- 2,487 lines of tests
- 62 passing tests
- 5 hours 4 minutes of build, 20 human prompts
- 20 original music tracks
Story and figures from the original foundation snapshot.

Network Change Roulette
Investigate a network change, challenge the bot, and decide whether to approve, hold, or roll back.
Read the game’s story
What it is
Challenge the change bot across 100 firewall, routing, Zscaler PZEN and PAC tickets. Investigate the pilot network, spend limited checks, then Approve, Hold or Rollback and compare the resulting service and access outcomes.
A later addition to the current catalogue, outside the original 22-game write-up. Open the Arcade page for its full build record and limitations.

Network Ops: Night Shift
Keep a pixel-art outpost online until dawn.
Read the game’s story
What it is
You are on call for a small outpost from midnight to daybreak. Six incidents come in. You follow a workstation cable into an eight-port rack, check the link light, compare the port’s VLAN with the work order, fix a host gateway or a router entry, and the outpost lights up as you bring things back.
Why it is cool
The first prototype played like a console quiz. The builder asked for a pixel survival game instead and got one: a little night scene, a switch rack you can inspect, and six collectible field patches. The habit it builds is the best one in troubleshooting: send the same ping before and after the repair and compare.
What it teaches
Access VLANs, default gateways, static routes and ICMP echo, all in a stable IPv4 snapshot with one root cause per incident. It teaches a method more than a fact: observe, change one thing, verify with the same probe. Sources are RFC 1812, RFC 1122, RFC 792 and vendor Layer 2 documentation.
- 1,577 lines of game code
- 355 lines of tests
- 35 passing tests
- Pixel art drawn entirely in code
Story and figures from the original foundation snapshot.

NOC Ninja — Guided NOC Patrol
Investigate the link, explain the evidence, and verify the outcome.
Read the game’s story
What it is
Three real link incidents and twelve guided decisions. You compare recorded commands at both ends of a link, read optical levels and error counters, choose a replacement sequence, and review the diagnosis. You answer by dragging a shuriken onto a target, in front of painted maple leaves and a castle at twilight.
Why it is cool
The incidents are not invented. They are built from 42 real command captures the builder supplied, and two of the three have operator-confirmed repair outcomes. The game is strict about evidence: it will not infer a rate from a historical counter or claim a recovery nobody reported. At the end you download a handoff note, the way a real shift ends.
What it teaches
Optical diagnostics, CRC and FCS errors, link flapping, and above all the discipline of NOC troubleshooting: compare both endpoints, separate current state from history, explain before you replace. Scenario, question and answer order shuffle on every patrol.
- 4,440 lines of game code
- 1,861 lines of tests
- 53 passing tests
- 42 recorded command outputs
- Original generated artwork, bundled locally
Story and figures from the original foundation snapshot.

Packet Dash
Run and jump as a packet; learn ports, latency versus bandwidth, and resends.
Read the game’s story
What it is
A platformer where you are Pak, a small envelope-shaped packet travelling from a laptop to a server. You run the cable trays, jump the dropped links, and at the end of each stretch make one delivery decision: which building and which door, which path, which numbered pieces to send again.
Why it is cool
The builder asked for “something like a Mario but with a networking theme”, and wanted ideas that need no networking background at all. The whole interface speaks networking: a header bar with real source and destination, a topology map, a terminal log, port doors lit as listening. After each level a news card ties the idea to a real outage from that week’s headlines.
What it teaches
Three ideas people who use networks every day rarely get taught. The address picks the machine and the port picks the program. Bandwidth is not the only thing that sets speed. Reliable delivery means resending exactly the pieces that went missing. The platformer and the accessible console mode are two views of one list of choices, so they can never disagree.
- 3,553 lines of game code
- 528 lines of tests
- 46 passing tests
- 11 human prompts
Story and figures from the original foundation snapshot.

PacketJedi
Trace OSPF LSAs to every router in scope.
Read the game’s story
What it is
A fictional three-area OSPF topology on a holomap. Each round shows an LSA type and its origin, and you select every router that receives it. Five rounds move from area-local LSAs to ABR summaries and Type 5 flooding around a stub area.
Why it is cool
It is the smallest game in the Arcade at about a thousand lines of code, and it has a complete idea: characters for each LSA, ranks that start at Youngling, a top-five leaderboard, and feedback that tells you which routers you added by mistake and which you missed. During the build, the RFC section references themselves were reviewed and corrected.
What it teaches
LSA flooding scope, the concept that makes OSPF areas click. Wrong answers point to the relevant section of RFC 2328. Scoring is kept apart from the receiver evaluator, so the networking answer is never bent to make the game feel better.
- 1,022 lines of game code
- 306 lines of tests
- 22 passing tests
- 11 human prompts
- Five hand-authored SVG characters
Story and figures from the original foundation snapshot.

PACketMan - Networking Maze
Move a packet through a network maze. Learn each decision along the way.
Read the game’s story
What it is
A 19-by-19 neon maze with a packet, three roaming ghosts and numbered checkpoint gates. Six lessons, three checkpoints each. You steer with the arrow keys, collect network bits, and at every gate you make a real networking decision before you can pass.
Why it is cool
It started as a campaign of six lessons, and the builder kept pushing it toward the arcade classic it honors: a real grid, gates, branching paths, collectibles, and then ghosts. When a ghost catches you it asks a bonus question about the current lesson. The clever part is the separation. Ghost questions never erase lesson progress, so arcade pressure and network correctness stay independent.
What it teaches
The broadest curriculum in the Arcade: routing by total latency, ordered ACL rules, TCP versus UDP, subnet boundaries and gateways, QoS queues, and congestion and loss. Eighteen checkpoints, each sourced to an RFC, in a deterministic teaching model.
- 3,647 lines of game code
- 1,425 lines of tests
- 48 passing tests
- 18 checkpoints across 6 lessons
Story and figures from the original foundation snapshot.

Peering Patrol
Run the NOC at an IXP and zap the packets that don’t belong on the peering LAN.
Read the game’s story
What it is
A glowing peering LAN in the center, eight member routers around it. Packets fly in, and broadcasts split into copies that flood every member. You zap discovery protocols, spanning tree, IGPs, multicast chatter and stray router advertisements, and you let BGP, unicast traffic and legitimate address resolution through.
Why it is cool
This is specialist knowledge turned into a reflex game. The packet catalog comes from real exchange-point operating practice, the kind of thing you normally learn by being told off on a mailing list. Five phases build up to “same protocol, different verdict” cases. Then the endless recall test hides the protocol names and shows only the header fields a capture would show.
What it teaches
Layer 2 hygiene on a shared peering LAN: what must never leak onto it and why, across IPv4 and IPv6. Every decision explains what the packet is and what to disable on your own exchange-facing interface. Packets are stored as structured header fields and every verdict is re-derived in tests.
- 4,972 lines of game code
- 1,674 lines of tests
- 93 passing tests
- 26 human prompts, built in one day
- Sound is synthesized in the browser
Story and figures from the original foundation snapshot.

Per-Hop Works
A playable packet factory for learning DiffServ, one work order at a time.
Read the game’s story
What it is
Players sort, mark, meter, queue and schedule packet crates on a 3D factory floor, then watch a deterministic trace show why each crate was forwarded, delayed or dropped. Twelve levels build from the DS octet to RFC 2697/2698 metering, strict priority, deficit round robin and AF drop precedence.
The starter used before the workshop build began. Open the Arcade page for its full build record and limitations.

Permit or Pew
Shoot the packets the ACL denies. Let the permitted ones through.
Read the game’s story
What it is
You are a firewall in a classic fixed shooter. A formation of packets dives toward your network, each labelled with protocol, addresses and port. The access list is on screen. You shoot what it denies and let the rest through, and every wrong call costs health.
Why it is cool
The best name in the Arcade, and a great pivot. The first build used four lanes and paused on every mistake, and playtesting called it “gamified flash cards”. So it became a free-moving shooter, with the constitution amended in the open. It has more lines of tests than lines of game, and the builder deliberately broke the code on a scratch copy to confirm the tests could fail.
What it teaches
Reading an ACL the way a device does: top to bottom, first match wins, implicit deny at the end, CIDR ranges. After each wave a review shows what you got wrong and which rule decided it. It is written for developers and IT beginners who have never read an access list.
- 2,997 lines of game code
- 3,817 lines of tests
- 208 passing tests
- 48 hand-checked reference cases
- Sound is synthesized in the browser
Story and figures from the original foundation snapshot.

RIBRush
Practice the route-selection rules that decide where packets go.
Read the game’s story
What it is
A packet arrives with a destination. Below it is a table of candidate routes. You pick the winning next hop, and the game explains the deciding rule. Thirty-five packets across seven levels, starting in IPv4 and carrying the same rules into IPv6.
Why it is cool
It is a keyboard-first puzzle with pressure: score, lives and a pace bar. The scenarios are generated from a seed, so the data varies while every answer stays reproducible and checked. It includes the classic trap of a more specific route against a more trusted one.
What it teaches
The three-step model every router follows: longest prefix match first, administrative distance only between identical prefixes, metric only within the same protocol and prefix. It is early routing practice, clearly scoped, and honest that it is not a simulation of a vendor’s full route-installation pipeline.
- 2,103 lines of game code
- 1,122 lines of tests
- 12 passing tests
- Seven levels, IPv4 into IPv6
Story and figures from the original foundation snapshot.

Round Trip
Finish the script, run it, and watch whether the ping makes it there and back.
Read the game’s story
What it is
Each of seven rounds is a short Netmiko-style script with blanks. You place code cards into the blanks, press Run, and watch a ping try to cross two simulated routers and come home. After every run the game shows what the script sent, what each router did with it, and where the traffic stopped.
Why it is cool
It targets one misconception with precision: a script that ran without crashing has not necessarily fixed the network. The game keeps three things apart that beginners blur together, namely what the script sent, what the router holds in its configuration, and what traffic actually does. The last round has you assemble a whole script that you can copy away as real code.
What it teaches
Network automation for network engineers who are new to it: connection handling, configuration mode, static routes, running versus startup config. It is the only automation game in the Arcade so far. The builder’s early question, why should a Run make the player wait, became a constitution rule that the player never waits.
- 4,518 lines of game code
- 1,416 lines of tests
- 110 passing tests
- 54 human prompts across several sittings
- Checked against the library’s own source code
Story and figures from the original foundation snapshot.

Signal Age
Build a civilization’s communications, from smoke signals to wireless and satellite.
Read the game’s story
What it is
Choose and build communication links across three eras and six demands. Match each demand’s reach, delivery time, capacity and construction schedule, then find the cheapest network that serves it.
A later addition to the current catalogue, outside the original 22-game write-up. Open the Arcade page for its full build record and limitations.

Slow Ping
Make the ping slow. Keep it working.
Read the game’s story
What it is
Every level starts with a working network and a fast ping. Your job is to edit static routes so the round trip takes as long as possible, and still gets there and back. Three levels grow from three routers and one editable route to eight routers and sixteen entries.
Why it is cool
It turns the usual goal upside down, and that is why it works. To make a ping slow without breaking it you have to understand everything that makes it fast. It is the only game rated advanced. The maximum for each level was proven twice, by a Python graph search and by a separate JavaScript path oracle: 59, 228 and 349 milliseconds.
What it teaches
Weighted paths, the fact that request and reply are routed independently, longest-prefix matching with host-route overrides, loops, and TTL expiry. The builder tried an MPLS traffic-engineering version, decided harder static routing taught more, and retired it. That decision is recorded in the specs.
- 2,407 lines of game code
- 365 lines of tests
- 20 passing tests
- 22 additional browser checks
Story and figures from the original foundation snapshot.

Split Decision
Pick the splitter that lights every home: not too dark, not too bright.
Read the game’s story
What it is
You design the outside plant of a small fiber network. Each of six work orders shows a PON, a loss card, the launch power at the OLT and the window of light an ONT can live with. You choose the splitter, or the attenuator, that keeps every home inside that window while serving as many homes as possible.
Why it is cool
It is the only game in the Arcade about light. A loss trace draws the signal falling at every connector, splice and splitter, and a dB-by-dB ledger adds it up, so a wrong design is as readable as a right one. The receive window and launch power are not textbook numbers. They came from the builder’s own field practice, and the game shows the ITU-T figures beside them for comparison.
What it teaches
Optical loss budgeting, the first question of PON design: how far can this route be split? It assumes you know IP and nothing about optics. Behind it sits one of the most careful builds in the room: every answer was worked by hand before any code existed, checked by a second implementation in another language, and 26 bugs were planted on purpose to prove the tests could fail. All 26 were caught.
- 7,456 lines of game code
- 2,456 lines of tests
- 200 passing tests
- 14 human prompts
- About 3 hours 50 minutes of active build time
Story and figures from the original foundation snapshot.

Subnet Sashimi
Fish for octets. Build a valid IPv4 host address.
Read the game’s story
What it is
A lake, a basket and a subnet. Numbered fish swim past; you catch the ones that complete a host address inside the prefix on screen, reel them in and submit. A one-octet warm-up leads to full addresses, then endless rounds with random prefixes from /8 to /30.
Why it is cool
It is the calmest game in the Arcade, and that is the point. Subnetting is the topic that makes new engineers anxious, and this game answers with soft colors, fish and no penalty for a wrong answer. A miss explains the subnet boundary, and after one wrong try you can ask to see a valid address and the whole acceptable range.
What it teaches
Finding the network and broadcast boundaries and recognizing a usable host address between them. It is drill practice, the kind you need a hundred repetitions of, wrapped in something you would happily do a hundred times. It is also one of the smallest builds here at under 1,500 lines, which shows how little code a good teaching idea needs.
- 1,483 lines of game code
- Endless mode after the two guided rounds
Story and figures from the original foundation snapshot.

TCP Kart: Congestion Control
Predict TCP’s next move and watch data and ACKs race.
Read the game’s story
What it is
A cartoon race circuit with a narrow bottleneck between sender and receiver. Before each lap you predict what the sender does to its congestion window, then the karts run: data one way, ACKs back the other, and the game compares your prediction with the result.
Why it is cool
Congestion control is usually taught with a sawtooth graph. Here it is a 3D kart track where you can see the road narrow. The builder kept the rule evaluator completely separate from the animation, so the picture can never decide whether an answer is right. A player noticed the ACKs were leaving too early, and the fix made each ACK wait for the data it covers, which is exactly how the protocol behaves.
What it teaches
Slow start, congestion avoidance and timeout response, grounded in RFC 5681. Three levels and six rounds take you from “what is a congestion window” to predicting the sender’s next state. There is a plain schematic view for browsers without WebGL, and a worked example before the first question.
- 2,198 lines of game code
- 1,215 lines of tests
- 34 passing tests
- 3D circuit and karts are generated in code
Story and figures from the original foundation snapshot.

Threat Level: Goose
Defend Chef Bear’s secret recipes with layered security, and keep an eye on Goose.
Read the game’s story
What it is
A tower defense game set in a pastry shop. The secret recipes sit in a safe at the center. Phishing emails, stolen logins, tailgaters, card skimmers and a ransomware gang walk in from the internet and the street, losing health at every layer of defense they pass.
Why it is cool
The name is the joke and the lesson. The biggest threat in the shop is Silly Goose, the friendliest employee, who clicks gift card links, props doors open and reads his Social Security number to callers. Every slip walks an attacker past your outer wall unless you catch him in time. Between waves, incident calls ask certification-style questions and show invoices to pay or refuse.
What it teaches
Defense in depth, and what each control really does. All 33 incident calls are sourced to NIST, CISA, OWASP, PCI and FBI guidance. A second AI model reviewed every line of the security text and found 29 issues, all fixed. This was the long-haul build: four days and 263 prompts, driven by play-testing at every step.
- 5,867 lines of game code
- 1,857 lines of tests
- 67 passing tests
- 263 human prompts
- 1,188 individual checks inside the 67 tests
Story and figures from the original foundation snapshot.

Throughput
Find the bottleneck, share the load, and outscore three bots.
Read the game’s story
What it is
An 8-by-8 board, a Source and a Destination. You place cables, switches, routers, firewalls and load balancers so packets flow, and every delivered packet scores. Three bots play the same map and attack you. Random events and attacks arrive with a five-second countdown so you can react.
Why it is cool
It is the only competitive game here. A live leaderboard ranks you against the bots until the last ten percent of the round hides it. Two of the six attacks need a combination of equipment to stop. The bots were tested against each other in scripted duels, and three of the bugs found during the build were in bot behavior, not in the rules.
What it teaches
A path is only as fast as its slowest device, and parallel paths share load. After each decision the game names the bottleneck and tells you when you upgraded the wrong link, which is the most common capacity-planning mistake there is. A practice round takes three minutes.
- 3,338 lines of game code
- 975 lines of tests
- 60 passing tests
- 7 random events and 6 attacks
Story and figures from the original foundation snapshot.

Uptime Survivors
Survive 20 levels of network problems with auto-firing network tools.
Read the game’s story
What it is
A survivors-style arcade run. You only steer. Your tools fire on their own: Ping, Firewall Rules, Ansible Playbooks, Load Balancers, Traceroute, Rate Limiters and Null Routes. Packet loss, route flaps, broadcast storms and DDoS botnets close in across 20 one-minute difficulty levels, with three Major Incidents along the way.
Why it is cool
This is the build that would not stop. It grew feature by feature through the week: procedural audio, phone and touch play, Major Incidents, a Field Guide, late-game upgrades. It carries more lines of test code than game code, and its balance was tuned by scripted bots playing seeded runs with three different strategies, because one bot alone hid a real balance problem.
What it teaches
Every enemy, tool and upgrade is tied to a real networking concept, and the pause-menu Field Guide explains each one. It is vocabulary and intuition for beginners: what a broadcast storm is, why you null-route, what a rate limiter is for. The build record is honest that these are metaphors and one-line descriptions, not protocol simulations.
- 7,074 lines of game code
- 8,763 lines of tests
- 165 passing tests
- 292 tasks across 6 loops
- Sound is synthesized in the browser
Story and figures from the original foundation snapshot.
No games match those filters.
Try another topic or reset the filters to see the collection.
You were willing
to be beginners.
Look what you made.
I have deep admiration, respect and gratitude for the open minds and open hearts in this community.
You chose this workshop. You trusted me with your time. You were willing to try something unfamiliar in front of your peers, ask whether we were really doing this, and then do it.
I used video games to teach a method. You used that method to make video games that teach other people. The lesson keeps moving.
I hoped for six games. You gave us an arcade.
Thank you.
John
