THE ARCADENAF AUTOCON 6 · FIELD NOTES

I hoped for
six games.
They built
an arcade.

A room full of network engineers.
Two hours to make something nobody had made before.

THE COMMUNITY ARCADE
1 / 26 · SELECT A CABINET

Threat Level: Goose

SPECIFICATIONS. IMAGINATION. PLAY.A workshop that kept growing after the room emptied.
~75people in the room
2 + 2hours of lecture + building
3rdsold-out workshop in a row
22games in the original write-up

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.

John Capobianco and Andy Lapteff in the original podcast
WHERE THE WORKSHOP BEGAN

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 YouTube

The 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?”

Seif Allaoua, between the two-hour blocks · as I remember the exchange

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.

WE DIDN’T START WITH A BLANK SCREEN

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.

Threat Level: Goose game card
Threat Level: GoosePlay the game
The first external submission

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.

PacketJedi game card
PacketJediPlay the game
68 minutes to build. Three to publish.

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.

Firewall Security Faceoff game card
Firewall Security FaceoffPlay the game
The reason I keep coming back

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.

Subnet Sashimi game card
Subnet Sashimi

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.

TCP Kart: Congestion Control game card
TCP Kart: Congestion Control

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.

NetMaul: Defend the Datacenter game card
NetMaul: Defend the Datacenter

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.

NOC Ninja — Guided NOC Patrol game card
NOC Ninja — Guided NOC Patrol

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.

AS-PATH Of Glory game card
AS-PATH Of Glory

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.

Network Ops: Night Shift game card
Network Ops: Night Shift

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.

  1. 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
  2. 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
  3. 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
  4. 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
  5. 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?
The submission contract
SectionWhat it carriesWhy it matters
GameTitle, learning topics, level, card, repository and licenseThe player can understand what they are opening.
CreatorHuman-supplied identity, optional links and consentThe agent cannot manufacture permission or identity.
BuildExact reported model, harness, sources, skills, tools, specification artifacts and assetsAnother engineer can understand the process.
RuntimeStart command, hosting model, dependencies, network/API requirements and save behaviorBuilding with an agent does not imply needing an agent to play.
VerificationCommands, recorded test results, factual sources and known limitsA claim is accompanied by something that can be checked.
Build storyHuman decisions, failures, revisions and lessonsThe 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.

NAF AC6 · THE ORIGINAL LECTURE98 slides · 2 video clips
Slide 1: NAF AC6 WORKSHOP  ·  WS:C1

Slide 1 · NAF AC6 WORKSHOP · WS:C1

Open PDFDownload PowerPoint
Read the complete lecture as text

Text is extracted from the original slides. Diagrams and visual demonstrations are available in the slide images. The two supplied video clips have no separate caption track in the original deck.

Slide 1 · NAF AC6 WORKSHOP · WS:C1

NAF AC6 WORKSHOP · WS:C1

Loop Engineering, Spec-Driven Development

& the Future of VibeOps

Slide 2 · Your Proctors

Your Proctors

John Capobianco

Head of AI & DevRel

Joksan Flores

Principal Solutions Engineer

Elliot Conner

Solutions Engineer

All three are on the floor during every lab: raise a hand any time.

Slide 3 · From an Idea to a Working Game on the Internet

From an Idea to a Working Game on the Internet

Session

Time

Lecture: LLMs, Ralph loops, SDD and Spec Kit

9:00 – 9:35

Demo: Itential Builder Skills, with Joksan and Elliot

9:35 – 9:45

Lecture: loop engineering

9:45 – 9:50

Set up your project

9:50 – 10:00

Lecture: gamification of networking

10:00 – 10:15

Group activity: ideas and templates

10:15 – 10:45

Break

10:45 – 11:15

Group activity, continued

11:15 – 11:30

Bring your idea to life

11:30 – 12:30

Show your games

12:30 – 1:00

Four Hours

Slide 4 · Agenda

Agenda

01

The Journey So Far

02

Preface: LLM, RAG, MCP, Skills and the Open Agent Standards

03

Ralph Wiggum Loops

04

Spec-Driven Development

05

Spec Kit, and Running it as a Ralph Loop

06

Itential Builder Skills and SDD, with a Live Demo from Joksan and Elliot

07

Loop Engineering, and What Comes Next: Graph Engineering

08

Project Setup and the Gamification of Networking

Slide 5 · Build agents make the thing.

Build agents make the thing.

Run-time agents are the thing doing the work.

Build Agent

The SDD and loop that builds the thing

Run-Time Agent

The operational thing that was built

WHERE IT RUNS

Your laptop: VS Code with a terminal

HARNESS

Claude Code, Codex or GitHub Copilot in the IDE

LOADED WITH

Frontier model, skills, MCPs, RAG sources

ITS JOB

Write specs, plan, generate and test code

WHAT IT PRODUCES

A game, a run-time agent, code, a website, even a SKILL.md or a spec

WHERE IT RUNS

A server, a platform or the user's browser

CONNECTED TO

A model, and possibly MCPs, RAG and skills

LOADED WITH

Only the tools its job needs, with permissions

ITS JOB

Operate: create, read, update and delete

EXAMPLE

An agent that checks and changes network config

Builds

Slide 6 · Preface - But I'm not a video game developer

Preface - But I'm not a video game developer

Open the original video clip

Slide 7 · Democratization of a Technology

Democratization of a Technology

Open the original video clip

Slide 8 · Today your build harness is loaded with Spec Kit, Ralph and whatever helps you build.

Today your build harness is loaded with Spec Kit, Ralph and whatever helps you build.

YOUR BUILD HARNESS FOR TODAY

Model

Sonnet 5 or GPT-5.6 (frontier model)

Required

Harness

Claude Code or Codex, in VS Code with a terminal

Required

Spec Kit

/constitution through /implement

Required

Ralph loop

Plugin or bash loop to finish tasks.md

Optional

MCP servers

e.g. NetBox, Blender, pyATS

Optional

RAG and skills

RFCs, vendor docs, a Three.js skill

Optional

YOUR RUN-TIME RESULT

A network-themed video game

index.html in a browser, built with Three.js, HTML and CSS

Pushed to your own GitHub repo

Builds

Load the build harness with what helps you build. None of it has to ship inside the game.

Slide 9 · Should your game be agentic?

Should your game be agentic?

For you to decide; enforced by your spec.

Not Agentic: A Deterministic Game

How it works: all questions, answers and levels are written into the code and data

Needs: a browser, nothing else

Cost to play: zero

Risk: low; the constitution's accuracy rule is easy to check

Example: a subnetting quiz with a fixed question bank and written explanations

Recommended starting point for a 60-minute build.

Agentic: The Game Calls A Model

How it works: a model plays a tutor, generates new scenarios or grades free-text answers

Needs: an API key or a local model, maybe an MCP or RAG source

Cost to play: tokens on every turn, or free on a local open-weight model via Ollama (your mileage may vary)

Risk: the model can say something wrong; your spec must guard against it

Example: a BGP tutor character who explains, in its own words, why a route won

This makes your game a run-time agent built by your build agent.

Decide in /specify, settle it in /clarify, and write the rule into your constitution.

Slide 10 · The journey

01

01

The journey

How we went from chatting with AI to designing loops that run it.

Slide 11 · In four years, AI coding went from a chat window to loops that prompt themselves.

In four years, AI coding went from a chat window to loops that prompt themselves.

Nov 2022

ChatGPT puts an LLM in a chat window

2023

RAG and copilots bring in your own data

Nov 2024

Anthropic open-sources MCP

Feb 2025

“Vibe coding” is named; Claude Code previews

Jul 2025

Huntley publishes the Ralph loop

Sep 2025

GitHub releases Spec Kit

Jun 2026

“Loop engineering” is named

Each step made the model more useful by giving it more context, more tools, or more autonomy.

Slide 12 · Each era moved the human one step further from the keystroke.

Each era moved the human one step further from the keystroke.

2022–23

Prompt engineering

You write the words

2024

Context engineering

You choose what the model sees

2025

Harness engineering

You give it tools and a loop

2026

Loop engineering

You design the system that prompts it

Slide 13 · VibeOps keeps the speed of vibe coding and adds engineering discipline.

VibeOps keeps the speed of vibe coding and adds engineering discipline.

VIBE CODING

Prompt and hope

No spec: the model fills gaps with guesses

The human acts as QA, finding every bug

Fine for prototypes and throwaway demos

VIBEOPS

Intent written down as specs

A constitution sets rules the agent can't break

Tests and verifiers close the loop

Output is deterministic, reviewed and versioned

Slide 14 · Production networks can't run on vibes.

Production networks can't run on vibes.

A wrong ACL or route policy is an outage, not a bug report. Every change an AI produces has to meet the same bar a human change does.

Deterministic

The same intent produces the same change every time

Reviewed

A human approves the intent and the plan before anything touches a device

Auditable

Every change traces back to a spec, a test result and an approver

Specs, loops and verifiers let us keep these three guarantees at AI speed.

Slide 15 · Preface: LLM, RAG and MCP

02

02

Preface: LLM, RAG and MCP

The three building blocks under every coding agent

Slide 16 · An LLM predicts the next token from everything in its context window.

An LLM predicts the next token from everything in its context window.

Context window

System prompt, your prompt, history, files

LLM

Next Token

One word-piece at a time

Each token is appended and the model runs again

Stateless

Nothing carries over between calls unless you send it again

Finite Context

As the window fills, recall and reasoning degrade

Frozen Knowledge

It knows nothing after its training cutoff

Slide 17 · The context window is the model's only working memory.

The context window is the model's only working memory.

ONE CODING SESSION'S CONTEXT WINDOW (ILLUSTRATIVE)

System prompt

Tool definitions

Conversation history

Files and tool results

Free

As the session runs, history and tool output crowd out free space, and quality drops: context rot.

RALPH'S ANSWER

Throw the window away every iteration. Keep progress on disk where the next fresh agent can read it.

SDD'S ANSWER

Load only what the current step needs: the constitution, the spec, the plan and one task.

Slide 18 · RAG grounds answers in your own documents instead of training data.

RAG grounds answers in your own documents instead of training data.

INDEXING: DONE ONCE, AHEAD OF TIME

Your Documents

Runbooks, configs, RFCs, tickets

Chunk & Embed

Split text, turn each piece into a vector

Vector store

Searchable by meaning

QUERY: EVERY QUESTION

Question

“What is our BGP timer standard?”

Embed

Question becomes a vector

Retrieve

Top matching chunks

Augment

Prompt plus retrieved chunks

Generate

LLM writes the answer

Grounded answer

With sources cited

RAG fixes frozen knowledge without retraining: the model answers from your documents, and you can check its sources.

Slide 19 · MCP gives every model one standard connector for tools and data.

MCP gives every model one standard connector for tools and data.

Host Claude Code, Codex, VS Code

MCP Protocol

GitHub server Repos, issues, pull requests

Itential server Workflows and automations

NetBox server Devices, IPs, sites

Blender server 3D scenes and assets

Tools

Actions the model can call

Resources

Data the model can read

Prompts

Reusable templates the server offers

Anthropic open-sourced MCP in November 2024. Build one server and every MCP-capable host can use it.

MCP Client

MCP Client

MCP Client

MCP Client

Slide 20 · MCP servers turn network systems into tools an agent can call.

MCP servers turn network systems into tools an agent can call.

Sources of truth such as NetBox or Nautobot become resources the agent can read

Device actions such as show commands become tools, with approval on anything that writes

Itential exposes workflows and automations to agents through MCP

Today, Blender and Unreal Engine MCPs let your agent build 3D assets for your game

Slide 21 · 78 MCP servers already cover 12 layers of the infrastructure stack.

78 MCP servers already cover 12 layers of the infrastructure stack.

01

Devices & platforms

Itential, pyATS, Arista CVP, ContainerLab

02

Cisco platform suite

ACI, ISE, Meraki, ThousandEyes

03

Source of truth & ITSM

NetBox, Nautobot, Infoblox, ServiceNow

04

Cloud infrastructure

AWS, Azure, Terraform, kubectl

05

Observability

Grafana, Prometheus, Splunk, SuzieQ

06

Incident management

PagerDuty, ServiceNow

07

Security & compliance

NVD CVE, PAN-OS, Zscaler, Prisma AIRS

08

Developer & GitOps

GitHub, GAIT, Ansible AAP

09

Reference & standards

RFC Lookup, Subnet Calculator, Wikipedia

10

Diagramming

Draw.io, Excalidraw, Markmap

11

Packet analysis & lab

Wireshark, Packet Buddy, Kubeshark

12

Assurance & digital twin

Batfish, IP Fabric

Source: Itential, The Ultimate MCP Guide for Network Automation, 2026. Examples shown; the guide lists all 78 servers.

Slide 22 · Any MCP can feed the BUILD agent, the RUN-TIME agent, or both.

Any MCP can feed the BUILD agent, the RUN-TIME agent, or both.

MCP SOURCE

BUILD TIME

Pulled once by the coding agent

RUN TIME

Called live by the game agent

Source of truth

NetBox, Nautobot

Turn real sites and devices into level data

Load the player's own sites as a level

Devices and lab

ContainerLab, CML, pyATS

Capture real show output for each puzzle

Live break-fix level; pyATS checks the fix

Assurance

Batfish, IP Fabric

Validate every config before it is committed

Score the player's config against intent

Packets

Wireshark, Packet Buddy

Generate real captures for decode levels

Explain the packet the player clicks on

Reference

RFC Lookup, Subnet Calculator

Check every quiz answer against the source

Hints cite the RFC section by number

Itential

Workflows, golden config

Pull real workflow and compliance examples

Final level runs a governed workflow

Slide 23 · Default to BUILD time, and go live only when the player needs live state.

Default to BUILD time, and go live only when the player needs live state.

CHOOSE BUILD TIME WHEN

The data changes slowly: topologies, RFCs, configs

Every player should see the same content

The game must run offline, free and with no credentials

CHOOSE RUN TIME WHEN

The player's own network is the level

The right answer depends on live device state

The agent has to react to what the player just did

RUN-TIME GUARDRAILS treat the game agent like a junior engineer with root access

Read-only by default

PagerDuty needs an explicit flag before it will write

Governed writes

Itential MCP exposes 65+ tools behind workflows and approvals

Git audit trail

Record every AI-generated change in Git

MCP gateway

One place for the allow-list, RBAC and logging

Source: Itential, The Ultimate MCP Guide for Network Automation, 2026.

Slide 24 · Skills package know-how that an agent loads only when a task needs it.

Skills package know-how that an agent loads only when a task needs it.

A SKILL IS A FOLDER

network-change/

├─ SKILL.md name, description, steps

├─ scripts/ validate.py

├─ references/ golden-config.md

└─ assets/ templates

IT LOADS IN THREE STAGES

1

At Startup

Only the name and description, about 100 tokens per skill

2

When a Task Matches

The full SKILL.md instructions load

3

Only if Needed

Scripts and reference files are read or run

Why it Matters Today

Spec Kit's commands and Itential Builder Skills both ship as skills. The format is an open standard (agentskills.io), so the same SKILL.md works in Claude Code, Codex, Copilot and Cursor.

Slide 25 · One foundation now hosts the open standards for tools, agents and skills.

One foundation now hosts the open standards for tools, agents and skills.

MCP

How an agent reaches tools and data

Anthropic, Nov 2024

modelcontextprotocol.io

A2A

How agents find and delegate work to other agents

Google, Apr 2025

a2a-protocol.org

Agent Skills

How an agent learns a procedure

Anthropic, Dec 2025

agentskills.io

AGENTS.md

How a repo tells any agent its rules

OpenAI, Aug 2025

agents.md

Agentic AI Foundation (Linux Foundation)

Launched Dec 2025 with MCP, goose and AGENTS.md. Now hosts 10 projects, including A2A and Agent Skills (Oct 2026), under vendor-neutral governance. aaif.io

Slide 26 · A harness wraps the model in a loop with tools: reason, act, observe.

A harness wraps the model in a loop with tools: reason, act, observe.

1 Reason

Plan the next step

2 Act

Call a tool

3 Observe

Read the result

4 Decide

Done, or go again?

Context grows each lap

Claude Code

Anthropic's agentic coding harness, in the terminal and IDE

Codex

OpenAI's agentic coding harness, as a CLI, IDE extension and cloud agent

What both give the model

Read and edit files, run shell commands, call MCP servers

Today's models: Sonnet 5 or GPT-5.6

Slide 27 · Ralph Wiggum loops

03

03

Ralph Wiggum loops

Brute-force persistence with a fresh context every time.

Slide 28 · “It’s better to fail predictably than succeed unpredictably.”— Geoffrey Huntley, creator of the Ralph loop

“It’s better to fail predictably than succeed unpredictably.”— Geoffrey Huntley, creator of the Ralph loop

Slide 29 · “Ralph is a Bash loop.”

“Ralph is a Bash loop.”

while :; do cat PROMPT.md | claude-code ; done

Geoffrey Huntley, July 2025

while :; do … done

Run forever, until a human or a stop rule ends it

cat PROMPT.md

Feed the same instructions every time; the plan on disk changes, the prompt doesn't

| claude-code

Start a fresh agent process with an empty context window

Slide 30 · Ralph works because the filesystem remembers what the model forgets.

Ralph works because the filesystem remembers what the model forgets.

01

Fresh context every loop

Each iteration starts a new agent process, so context rot never builds up

02

State lives on disk

Specs, the plan, the code and git history carry progress between iterations

03

One task per iteration

Small, finished steps instead of one long session that drifts

04

Backpressure from tests

Builds, tests and linters reject bad work, and the failure output feeds the next loop

“LLMs are stateless. Filesystems aren't.”

Slide 31 · Each Ralph iteration reads the plan, ships one task and exits.

Each Ralph iteration reads the plan, ships one task and exits.

1 Read

PROMPT.md and the specs

2 Pick

The top task in the plan

3 Implement

That one task only

4 Verify

Build, tests, linters

5 Record

Commit and tick the task

6 Exit

The loop starts a fresh agent

Repeat until the plan is empty

ON DISK: THE MEMORY THAT SURVIVES EACH LOOP

specs/*.md

IMPLEMENTATION_PLAN.md

src/ and tests/

git history

Slide 32 · Ralph runs in two modes: plan first, then build.

Ralph runs in two modes: plan first, then build.

Plan Mode

Compare the specs against the current code

Write a prioritized IMPLEMENTATION_PLAN.md

Change no code

Build Mode

Take the top task from the plan

Implement it and run the tests

Commit, tick the task, exit

Slide 33 · Ralph needs guardrails because it never decides to stop on its own.

Ralph needs guardrails because it never decides to stop on its own.

Iteration Capa hard maximum, such as 50 loops

Completion Promisethe agent prints DONE only when the tests pass

Sandbox scoped permissions and no production credentials

BudgetHuntley measured about $10.42 an hour running Sonnet 4.5 in a loop

Review at the commit, not at every keystroke

Slide 34 · Within a year, the harnesses built Ralph in as a native command.

Within a year, the harnesses built Ralph in as a native command.

Jul 2025

Ralph is a hand-written Bash loop

while :; do … done

Mar 2026

Claude Code adds a recurring /loop command

/loop

Apr 2026

Codex adds goals with machine-checkable completion conditions

goal objects

May 2026

Claude Code and other harnesses add /goal

/goal

Jun 2026

The practice gets a name: loop engineering

/loop + /goal + verifier

Anthropic also packaged the technique as an official Claude Code plugin, ralph-loop.

Slide 35 · For networks, Ralph loops until the config passes validation.

For networks, Ralph loops until the config passes validation.

# PROMPT.md

Study specs/bgp-peering.md.

Pick the highest-priority unchecked

item in IMPLEMENTATION_PLAN.md.

Generate the config for that item only.

Run: make validate

If it fails, read the errors and fix.

When it passes: commit, tick the item,

and exit.

WHAT MAKE VALIDATE CAN RUN

Syntax lint

Vendor parser rejects malformed config

Batfish

Reachability and policy checks on a model of the network

pyATS in a lab

Live state checks against virtual devices

Pre/post diff

Proves nothing changed that the spec didn't ask for

Slide 36 · Spec-driven development

04

04

Spec-driven development

Write the intent down before anyone writes code.

Slide 37 · A vague prompt makes the model guess, and every guess is a bug you find later.

A vague prompt makes the model guess, and every guess is a bug you find later.

THE WHOLE PROMPT

“Make me a networking game.”

Six words. The model has to make every other decision itself, and you only see those decisions when you read the code.

WHAT THE MODEL HAS TO GUESS

?

Which networking concepts to teach

?

Who plays it and how hard it is

?

Genre, controls and game loop

?

Scoring and win conditions

?

Tech stack and file layout

?

What “done” looks like

Slide 38 · In SDD the spec is the source of truth and code is the output.

In SDD the spec is the source of truth and code is the output.

CODE-FIRST

Prompt, read the code, fix, prompt again

Intent lives in chat history and is lost

A change means rewriting code by hand

Reviewers read diffs and guess the intent

SPEC-FIRST

Intent, then spec, plan, tasks and code

Intent lives in versioned Markdown in the repo

A change means editing the spec and regenerating

Reviewers approve intent before code exists

Slide 39 · SDD splits intent into four files, each answering one question.

SDD splits intent into four files, each answering one question.

File

Question it answers

Example for a networking game

constitution.md

What rules never change?

Runs in a browser. No backend. Every level teaches one networking concept.

spec.md

What are we building, and why?

Players route packets across a topology to learn subnetting.

plan.md

How will we build it?

Three.js scene, plain HTML and CSS for the UI, levels stored as JSON.

tasks.md

In what order?

T001 scaffold the scene, T002 packet movement, T003 subnet puzzle…

You review each file before the agent generates the next one.

Slide 40 · A good spec describes behaviour and leaves out the tech stack.

A good spec describes behaviour and leaves out the tech stack.

SPEC.MD (EXCERPT)

User story 1: Subnet the packet home (P1)

As a new network engineer, I route a packet to the right host by choosing the correct subnet mask, so I learn CIDR by doing.

Acceptance criteria

Given a /24 and a host count, when I pick the right mask, then the packet reaches the host.

Given a wrong mask, then the packet drops and the game explains why.

Out of scope: multiplayer, user accounts

[NEEDS CLARIFICATION: how many levels ship in v1?]

User stories with priorities

Each one is a slice the agent can build and test alone

Testable acceptance criteria

Given, when, then: the loop's tests come from these

Explicit non-goals

Stop the agent building what nobody asked for

Unknowns marked, not guessed

Spec Kit tags them, and /clarify resolves them

Slide 41 · A spec gives the loop its definition of done.

A spec gives the loop its definition of done.

Spec

Says what done looks like

+

Loop

Keeps trying with fresh context

+

Verifier

Proves each step meets the spec

=

Convergence

Working code that matches intent

Without a spec

A Ralph loop keeps going until the budget runs out, because nothing tells it the work is finished.

With a spec

Each iteration checks acceptance criteria, and tests written from those criteria tell the loop when to stop.

Slide 42 · Spec Kit

05

05

Spec Kit

GitHub's open-source toolkit for spec-driven development.

Slide 43 · Spec Kit adds SDD commands to the coding agent you already use.

Spec Kit adds SDD commands to the coding agent you already use.

The specify CLI scaffolds a project and installs the slash commands

Works in Claude Code, Codex, Copilot, Cursor and 30+ other agents

Every command is a Markdown prompt file you can read and edit

Every command produces an artifact you review in the repo

Slide 44 · One command scaffolds the project and its folders.

One command scaffolds the project and its folders.

uvx --from git+https://github.com/github/spec-kit.git specify init my-game

my-game/

├─ .specify/

│ ├─ memory/constitution.md

│ ├─ scripts/

│ └─ templates/

└─ specs/

└─ 001-packet-game/

├─ spec.md

├─ plan.md

└─ tasks.md

init asks which agent you use

Claude Code or Codex today; it installs the matching slash commands

memory/ holds the constitution

Every later command reads it and checks its output against it

Each feature gets its own folder

/specify creates the folder and a git branch for the feature

Slide 45 · Seven commands take an idea to working code.

Seven commands take an idea to working code.

STEP

COMMAND

WHAT IT DOES

PRODUCES

1

/constitution

Project rules, set once

constitution.md

2

/specify

What and why

spec.md and a feature branch

3

/clarify

Removes ambiguity

Answers written into spec.md

4

/plan

How: stack and design

plan.md, research.md, data-model.md

5

/tasks

Ordered work items

tasks.md

6

/analyze

Finds gaps and conflicts

Read-only report

7

/implement

Builds from tasks.md

Source code

Quality gates: optional in Spec Kit, required checkpoints in today's workshop

Spec Kit also ships /checklist, which writes quality checks for the requirements, and /converge, which verifies the code against the spec. Command names vary by agent: /speckit.specify, /speckit-specify or $speckit-specify.

Slide 46 · Clarify and analyze catch mistakes before any code is written.

Clarify and analyze catch mistakes before any code is written.

/clarify

Asks targeted questions about underspecified areas

Writes your answers back into spec.md

Costs minutes now instead of hours mid-build

/analyze

Read-only check across spec, plan and tasks

Flags constitution violations as CRITICAL

Fix the source file, not the output

Slide 47 · Today you run the full pipeline with two room-wide checkpoints.

Today you run the full pipeline with two room-wide checkpoints.

Step

Command

What to do

1

/constitution

Point to the constitution your group personalized

2

/specify

Point to your group's personalized specification

3

/clarify

Room checkpoint: compare the questions everyone is asked

4

/plan

Ask for the plan in Markdown

5

/tasks

No prompt needed

6

/analyze

Room checkpoint: review the findings together

7

/implement

Build your game

Slide 48 · SDD defines what done looks like; Ralph keeps going until the work gets there.

SDD defines what done looks like; Ralph keeps going until the work gets there.

SDD WRITES THE FILES (YOU REVIEW THEM)

constitution.md

rules that never change

spec.md

acceptance criteria = done

plan.md

stack and architecture

tasks.md

ordered, checkable tasks

RALPH RUNS THE LOOP (FRESH CONTEXT EACH PASS)

Read

constitution, spec, plan

Pick

first unchecked task

Build

that task only

Verify

tests and build pass

Commit

tick the task, exit

Next pass,

new process

Specs without a loop stop after one pass. A loop without specs never knows it has finished.

Slide 49 · Run /implement as a Ralph loop: one task from tasks.md per fresh context.

Run /implement as a Ralph loop: one task from tasks.md per fresh context.

PROMPT.MD

Read .specify/memory/constitution.md and

specs/001-*/spec.md.

Open specs/001-*/tasks.md; take the first

unchecked task. Implement only that task,

then run the tests.

If they pass: tick the task, commit, exit.

If every task is ticked: print ALL_TASKS_DONE.

RALPH.SH

for i in $(seq 1 30); do

cat PROMPT.md | claude -p | tee -a ralph.log

grep -q ALL_TASKS_DONE ralph.log && break

done

Why it helps

Each task gets a clean context window, so task 40 is built as carefully as task 1.

Two stop rules

The completion word ends it when done; the 30-pass cap ends it if it never converges.

Other harnesses

Codex: codex exec

Claude Code: the ralph-loop plugin

Slide 50 · Itential Builder Skills and SDD

06

06

Itential Builder Skills and SDD

Spec-driven development for infrastructure automation.

Slide 51 · Builder Skills give a coding agent the domain knowledge to build on Itential.

Builder Skills give a coding agent the domain knowledge to build on Itential.

Install from the Anthropic marketplace in one command

Runs in Claude Code, Codex CLI, Copilot CLI, Copilot in VS Code and Cursor

Builds workflows, command templates, golden config, Lifecycle Manager models, IAG services, FlowAgents and JSON forms

17

Total Skills

8

Delivery Skills

9

Platform Skills

Slide 52 · Six stages, each producing an artifact the engineer must approve.

Six stages, each producing an artifact the engineer must approve.

Stage

Agent

Artifact

Engineer gate

Requirements

spec-agent

customer-spec.md

Approves the spec

Feasibility

solution-arch-agent

feasibility.md

Approves the feasibility decision

Design

solution-arch-agent

solution-design.md

Approves the design

Build

builder-agent

Deployed assets

Reviews and accepts the delivery

Test

qa-agent

test-plan.md, test-report.md

Approves the test plan before anything runs live

As-Built

qa-agent

as-built.md

Signs off

Slide 53 · Builder Skills follow the same SDD pattern as Spec Kit, tuned for infrastructure.

Builder Skills follow the same SDD pattern as Spec Kit, tuned for infrastructure.

Spec Kit command

Builder Skills equivalent

Artifact

/constitution

Constitution

High-level guardrails

/specify + /clarify

spec-agent

customer-spec.md

/analyze

solution-arch-agent: feasibility

feasibility.md

/plan

solution-arch-agent: design

solution-design.md

/tasks + /implement

builder-agent

Deployed assets

No direct equivalent

qa-agent

test-plan.md, test-report.md, as-built.md

Slide 54 · The agent that builds never certifies its own work.

The agent that builds never certifies its own work.

In the original five-stage model, builder-agent built, tested and documented

Version 2 hands Test and As-Built to a separate qa-agent

qa-agent writes the test plan from the approved acceptance criteria

The engineer approves the test plan before anything runs live

Slide 55 · Explore with agents first, then ship a deterministic build.

Explore with agents first, then ship a deterministic build.

flowagent-to-spec: reads a FlowAgent's mission history and writes the spec for a deterministic equivalent

project-to-spec: reverse-engineers an existing Itential project into a spec and design

In a live session, John and Ankit Bansali built VPN tunnel, DNS A record and BGP peer workflows from specs

Slide 56 · Each stage hands the next one a document, not a chat history.

Each stage hands the next one a document, not a chat history.

REQUIREMENTS

spec-agent

customer-spec.md

Reads your use case, or one of 22 built-in specs

FEASIBILITY & DESIGN

solution-arch-agent

feasibility.md

solution-design.md

Reads the approved spec and your live platform

BUILD

builder-agent

workflows

templates

configs

Reads the approved design

TEST AND AS-BUILT

qa-agent

test-plan.md

test-report.md

as-built.md

Reads the acceptance criteria and the build

Between every pair of agents, an engineer approves the document before the next agent starts.

Slide 57 · Watch three moves in the demo: write the spec, check feasibility, build.

Watch three moves in the demo: write the spec, check feasibility, build.

01

Write the spec

spec-agent

Turns a use case into customer-spec.md through a back-and-forth dialogue

Can start from one of 22 built-in specs

Engineer approves the spec

02

Check feasibility

solution-arch-agent

Connects to your platform and finds the adapters and integrations you have

Decides whether the spec can be built here, before anything is built

Designs what to build or reuse, and in what order

03

Build

builder-agent

Builds the approved design in dependency order

Tests each component, then hands off to qa-agent

Builds only what the design approved

Question to hold during the demo: what did the feasibility check catch that a single prompt would have missed?

Slide 58 · LIVE DEMO

LIVE DEMO

Itential Builder Skills, live

Joksan Flores and Elliot Connor show how they use Builder Skills, and how the artifacts each stage generates become the supporting documents the agent follows.

Slide 59 · Itential opened a public directory of 336 skills for infrastructure agents.

Itential opened a public directory of 336 skills for infrastructure agents.

ANNOUNCING infraagentskills.ai

336

skills

83

vendors

32

contributors

Open GitHub repo: github.com/itential/infra-agent-skills

Vendor and community submissions through pull requests, with issues for fixes and requests

A front end to browse it all: filter by category, vendor, contributor and source

Works in any harness that reads SKILL.md: Claude Code, Codex, Copilot, Cursor, FlowAgents

agent — ~/network-ops

$ use bgp-neighbor-troubleshooting

↳ loading SKILL.md ... ok

▸ neighbor 10.0.0.2 state: Active

▸ tcp/179 reachable ...... pass

▸ remote-as match ....... mismatch

▸ inbound policy ........ pass

✔ cause: peer AS 65010 ≠ 65001

$ ▌

Recreated from the infraagentskills.ai home page, November 2026.

Slide 60 · Vendors and the community contribute through GitHub, and maintainers review every change.

Vendors and the community contribute through GitHub, and maintainers review every change.

Skills by contributor, top 8 of 32

A ADD TO THE REPOSITORY

Fork and branch from main

Write a short SKILL.md; vendor steps go in references/

Check every step against vendor docs

Open a PR and sign the CLA; a maintainer reviews it

B LIST YOUR OWN SKILL

Add one entry to CATALOG.yaml. The skill stays in your repo under your license, and the directory links to it.

Not ready to write one? Open an issue to report a problem or propose a new skill or vendor.

Slide 61 · Each skill tells an agent what to check, in what order, and what it has proved.

Each skill tells an agent what to check, in what order, and what it has proved.

oob-console-access/SKILL.md

---

name: oob-console-access

description: Reach a device through

its console server when SSH is down

---

## Tools

- console server, device CLI

## Method

1. Find the console server and port

2. Confirm hostname and serial match

## Guardrails

- Read-only; writes need approval

## Output

- Say what the evidence can't prove

1

Purpose

The question it answers and when to use it

2

Tools

Which tools or MCP servers it may call

3

Method

The order of checks an expert would run

4

Guardrails

Read-only by default; writes need approval

5

Output

What the evidence does and does not establish

BUILD Copy into .claude/skills for Claude Code

RUN-TIME Load the same skills into Itential FlowAgents

Slide 62 · Loop engineering

07

07

Loop engineering

Stop prompting the agent. Design the loop that prompts it.

Slide 63 · “Design loops that prompt your agents.”

“Design loops that prompt your agents.”

Peter Steinberger, June 2026

Boris ChernyCREATOR OF CLAUDE CODE

Said his job is now writing the loops that drive Claude

Addy OsmaniNAMED THE PRACTICE DAYS LATER

“A recursive goal where you define a purpose and the AI iterates until complete”

Andrew NgLATER THAT MONTH

Framed it as three loops: agentic coding, developer feedback and external feedback

The skill moved from writing good prompts to designing the system that writes them.

Slide 64 · You write the intent; the LLM writes its own next prompt.

You write the intent; the LLM writes its own next prompt.

YOU, ONCE

Intent

The goal, what done looks like, and the rules

“Every level teaches one subnetting concept and all acceptance tests pass.”

THE LOOP, EVERY LAP

1 Read state

Repo, plan, last test results

2 Write the next prompt

The LLM decides what to ask itself next

3 Execute

The agent carries out its own prompt

4 Verify

Tests and checks score the result

Stop rule metgoal reached, iteration cap or budget hit, or a human gate. The loop reports back to you.

Slide 65 · Every loop has four parts: trigger, topology, verifier and stop rules.

Every loop has four parts: trigger, topology, verifier and stop rules.

Trigger

What starts a lap

A schedule, a commit, an alert or a ticket

IN A NETWORK LOOP

A config drift alert

Topology

How agents are arranged

One agent, a planner with workers, or a builder with a reviewer

IN A NETWORK LOOP

Builder agent plus a separate QA agent

Verifier

What proves progress

Tests, linters, a proof checker or a second model

IN A NETWORK LOOP

Batfish and pyATS checks

Stop rules

When it quits

Goal met, iteration cap, spend cap or a human gate

IN A NETWORK LOOP

Engineer approval before deploy

Anatomy from Addy Osmani, June 2026

Slide 66 · Andrew Ng describes three nested loops, each slower and more human.

Andrew Ng describes three nested loops, each slower and more human.

External feedback days to weeks

Developer feedback hours

Agentic coding loop

minutes

Agentic coding loop

Given a spec and optional evals, the agent writes code, tests it and keeps iterating. Ng's agent worked about an hour on its own, checking its work in a browser.

Developer feedback loop

You review what was built and steer the next round. This is where today's /clarify and /analyze checkpoints sit.

External feedback loop

Users react, and their response sets product direction. The agent can't see this unless you feed it in.

Slide 67 · The verifier, not the model, decides how far a loop can go.

The verifier, not the model, decides how far a loop can go.

Ralph loops: unit tests, builds and linters push back on bad code

DeepMind's AlphaProof Nexus: ran Ralph-style loops with a formal proof checker and solved 9 open Erdős problems

Networks: Batfish models, pyATS tests and pre/post state checks

Without a verifier, a loop only produces wrong output faster.

Slide 68 · In operations, loop engineering closes the gap between intent and network state.

In operations, loop engineering closes the gap between intent and network state.

Intent

The spec says what the network should be

Generate

Agent drafts the change

Validate

Verifier tests it before it ships

Approve and deploy

Engineer gate, then governed push

Observe

Telemetry and state collection

Detect drift

State no longer matches intent

STOP WRITING PROMPTS

MOVE TO INTENT LET THE AI WRITE ITS OWN PROMPTS

Slide 69 · Loops multiply cost and risk as fast as they multiply output.

Loops multiply cost and risk as fast as they multiply output.

Cost

Send scanning and drafting to small models; cap iterations and spend

Runaway loops

Every loop needs a hard stop rule

Permissions

Least privilege, and no production credentials in build loops

Review gates

Humans approve specs, plans and deployments

Slide 70 · Next comes graph engineering: many loops wired into one governed system.

Next comes graph engineering: many loops wired into one governed system.

Nodes do the work.

Edges route it, including branches and retries.

A single loop is one node with an edge back to itself.

Intent

spec.md

Planner

splits the work

Builder A ↻

own loop

Builder B ↻

own loop

Verifier

tests, QA agent

Human gate

approve change

fails: route back

Shared state on every edge: specs, artifacts, test results, approvals

The term surfaced in July 2026 and is still contested; the practice (graph-based orchestration) is older.

Slide 71 · A loop repeats one agent's cycle; a graph decides which agent works next.

A loop repeats one agent's cycle; a graph decides which agent works next.

Loop engineering

Graph engineering

Unit of design

One agent's repeated cycle

A network of agents, tools, verifiers and people

Who picks the next step

The same agent, every pass

Routing rules on the edges between nodes

State

Files and git for one task

Shared, versioned state across all nodes

Verification

Tests at the end of each pass

Dedicated verifier nodes and approval gates

Network example

Loop a config until Batfish passes

Spec, design, parallel builds, QA, change approval

For network teams: Itential workflows already model work as a graph of tasks with approval gates. Graph engineering puts agents on those nodes.

Slide 72 · Stacked together, these pieces are VibeOps.

Stacked together, these pieces are VibeOps.

Loop Engineering Loops that write their own next prompt

SDD & Spec Kit Written intent and review gates

Ralph Loop Persistence with a fresh context each lap

Harness Claude Code or Codex: the agent loop with tools

RAG & MCP Your data and your systems

LLM Predicts the next token

VibeOps

AI speed with engineering discipline

Each layer fixes a limit of the one below it.

Slide 73 · Gamification of networking

08

08

Gamification of networking

10:00 – 10:15 lecture, then the group activity

Slide 74 · Next: set up your project (10 minutes)

Next: set up your project (10 minutes)

1

Open VS Code

2

Install your harness: Claude Code or Codex

3

Choose your model: GPT 6 Astra; Opus 5-5; Fable 5.2 best results most costly context windows

4

Install the Ralph loop plugin (in Claude Code): /plugin install ralph-loop@claude-plugins-official

5

Install Spec Kit: uv tool install specify-cli --from git+https://github.com/github/spec-kit.git

6

Create your GitHub repository – Using https://github.com/automateyournetwork/NAF_AC6 as a starting point

Room-wide check: raise a hand if anything fails

Slide 75 · Then: write your constitution and spec

Then: write your constitution and spec

7

Clone your repo git clone <your-repo-url> then cd into it

8

Add Spec Kit specify init . --integration claude (or codex, copilot)

9

Copy John's starter files CONSTITUTION.md, SPEC.md and PLAN.md into the project root

10

Fill them in as a team replace the [BRACKETED] placeholders with your topic, rules and stack

11

/speckit.constitution “Please refer to the CONSTITUTION.md file and build the constitution”

12

/speckit.specify “Please refer to the SPEC.md file and build the specification”

Room-wide check: everyone should have a constitution and a spec before we clarify together

Slide 76 · Then: clarify, plan, analyze and build

Then: clarify, plan, analyze and build

13

GROUP BREAK /speckit.clarify answer its questions, then we catch up and share ours

14

/speckit.plan “Please refer to the PLAN.md file and build the plan”

15

/speckit.tasks break the plan into small, ordered tasks

16

GROUP BREAK /speckit.analyze check spec, plan and tasks agree, then we compare findings

17

/speckit.implement build it task by task, as a Ralph loop

18

Play it open index.html in a browser and test against your spec

At each break: stop typing, and bring one question or finding to share with the room

Slide 77 · John's starter kit is three Markdown templates you fill in.

John's starter kit is three Markdown templates you fill in.

CONSTITUTION.md

The rules that must never break

Feeds /speckit.constitution

SPEC.md

What you're building, for whom and why

Feeds /speckit.specify

PLAN.md

How: tech stack, architecture and data schema

Feeds /speckit.plan

Each file arrives pre-loaded with the defaults that made the 3 instructor example games work, plus [BRACKETED] placeholders for your topic and idea.

https://github.com/automateyournetwork/NAF_AC6

Slide 78 · The constitution sets the rules your game can never break.

The constitution sets the rules your game can never break.

Accuracythe game must never present incorrect information, even to be more fun

Feedbackevery wrong answer explains why

Difficultydriven by data, not hardcoded

Your editsreplace the [BRACKETED] placeholders and add your own non-negotiables

Slide 79 · The specification says what you're building, for whom and why.

The specification says what you're building, for whom and why.

Topicthe networking concept you know cold

Learning outcomeswhat a player can do after playing

Gameplay loopthe action the player repeats, and how it teaches

No idea yetuse the Inspiration section at the bottom of SPEC.md

Slide 80 · The plan says how: tech stack, architecture and data schema.

The plan says how: tech stack, architecture and data schema.

Suggested stackruns in a browser with Three.js, HTML and optional CSS

Data schemaquestions, levels and difficulty live in data files, not code

Done meansopen index.html in a browser and play

Want more?Add tools to your build harness to build the game better, and to the game itself to make it better to play (next two slides)

Slide 81 · Augment your BUILD harness so it builds a better game.

Augment your BUILD harness so it builds a better game.

BUILD Used while you build. Nothing here ships inside the game or costs players anything.

MCP servers

Blender or Unreal Engine MCP to make 3D models and scenes. An RFC or CVE MCP so questions match the source. GitHub MCP. Your favourite MCP.

RAG sources

Point the build agent at vendor docs, RFC PDFs or HTML pages so it writes accurate questions and explanations.

AI-generated assets

Images: OpenAI Image 2.5, Nano Banana. Voice: ElevenLabs. Video: Veo 3. Generate once, commit the files.

Skills and loops

A Three.js or front-end skill for better code. The Ralph loop to work through tasks.md unattended.

Slide 82 · Augment your RUN-TIME game so it plays better.

Augment your RUN-TIME game so it plays better.

RUN-TIME Used while someone plays. Each addition makes the game an agent, with a cost and a risk.

A model in the game

A tutor or opponent that explains answers. Free and local with Ollama, or through an API key the player supplies.

RAG at play time

The game looks up the RFC or vendor page behind each answer and shows the player the source.

MCP at play time

The game calls an RFC or CVE MCP to pull fresh scenarios, so no two rounds are the same.

Live generated media

ElevenLabs narrates hints, or an image model draws each new level. Costs per play, so cap it.

Whatever you add, write it into your spec and keep the constitution rule: the game never presents incorrect information.

Slide 83 · Sound, art and scores make a game feel finished.

Sound, art and scores make a game feel finished.

BUILD used while you build RUN-TIME used while someone plays BOTH either one

BOTH

Text to speech

Free: gTTS, generated once and committed as MP3s. Paid: ElevenLabs for richer voices, or live narration at play time.

BUILD

Soundtracks and audio

Ask your agent to install local audio tools and make MP3 tracks. Tested on Mac, not yet on Windows or Linux.

BUILD

Images

AI image tools such as ChatGPT image generation or Google Gemini. Generate once and commit the files.

BUILD

Abandonware and homage

Start from the code of a legacy game, or build a homage to one people already know. Check the license first.

RUN-TIME

Leaderboards and statistics

High scores and per-player stats. Browser storage covers one player; a shared board needs a small backend.

RUN-TIME

Multiplayer

Players race or compete on the same network puzzle. A server has to sync state, so scope it in the spec.

BUILD

Video cutscenes

Intro, cutscene and ending clips from Google Veo 3.1, Kling or Runway. Paid per second ($$$) for ~7-second clips; compress MP4s for cloud hosting.

Most of these are BUILD-time: generate once, commit the files, and the game stays free to play.

Slide 84 · Borrow from the lab to make both agents better.

Borrow from the lab to make both agents better.

BUILD used while you build RUN-TIME used while someone plays BOTH either one

BUILD

Lab as source of truth

A containerlab or CML MCP lets the agent capture real show output instead of inventing it.

BUILD

Batfish on every config

Any config the game shows is parsed and validated before the loop commits it.

BUILD

A QA agent that plays

Playwright MCP plays every level and logs errors, so the builder never grades its own work.

BUILD

Real packets via Scapy

Generate real PCAPs at build time; the game decodes the actual headers, Wireshark style.

RUN-TIME

Break-fix final level

The player fixes a broken router in a live containerlab; pyATS checks the state and scores it.

RUN-TIME

Routers as NPC agents

Each router is a small agent with its own table. Poison a route and watch the others react.

BOTH

Adaptive difficulty

Tag every question by concept; the game serves more of what the player misses. No model needed.

BOTH

A NetBox-shaped world

Build levels from NetBox demo data, then let players load their own sites and devices.

Bonus level: route the final change through an Itential workflow with an approval gate, the way production does.

Slide 85 · Classic game genres already have a mechanic for most networking concepts.

Classic game genres already have a mechanic for most networking concepts.

DDoS mitigation

× Tower defense: place firewalls and rate limiters before each wave of traffic lands.

Spanning tree

× Snake: the snake is a broadcast storm; block the right port before it eats itself.

VLANs and trunks

× Pipe Dream: lay access and trunk links before the traffic starts to flow.

OSI troubleshooting

× Roguelike: each dungeon floor is a layer; clear Layer 1 to unlock Layer 2.

Stateful firewalls

× Papers, Please: inspect each packet at the border and remember the sessions you let in.

TCP handshake

× Rhythm game: hit SYN, SYN-ACK and ACK on the beat; miss a keepalive and the session drops.

Network design

× City builder: build a campus on a budget; outages strike wherever you skipped redundancy.

ARP spoofing

× Social deduction: one player is the rogue device; the rest catch them from the ARP tables.

More pairings: Wordle × subnet masks, Typing of the Dead × CLI, Tetris × MTU, Frogger × collisions.

Slide 86 · Pair a networking concept you know with a game mechanic people already love.

Pair a networking concept you know with a game mechanic people already love.

BUILT LIVE: PACKET QUEST

Routing

× Play as the packet

Subnetting

× Daily Duolingo-style lessons

Load balancing

× Duolingo for F5

QoS queuing

× A racing game

ACLs

× Arkanoid: block or permit what bounces in

BGP

× A path-hijack thriller

Ideas from the Inspiration section of SPEC.md. This list is a starting point, not the ceiling.

Slide 87 · Group activity

09

09

Group activity

45 minutes · join the group that matches the number you were given.

Slide 88 · The group shapes the ideas; you build solo or as a team.

The group shapes the ideas; you build solo or as a team.

10:15

10:30

10:45

11:15

11:30

Block 1 · 15 min

Introductions and game ideas

Block 2 · 15 min

Read aloud and personalize the templates

Break · 30 min

Block 3 · 15 min

Finish personalizing the templates

Ideate as a group

Everyone shares a networking-themed game idea; the group helps refine each one

Build solo, or as a team

Each person, pair or team leaves with its own constitution, spec and plan (next slide)

Draw from everywhere

Networking, network automation, video games and the templates

Templates: about 10 minutes per file. One person reads aloud; the group reviews and adjusts.

Slide 89 · Ideas overlap? Pair up or form a small team, with one person driving.

Ideas overlap? Pair up or form a small team, with one person driving.

Recommended: one driver

1

The driver creates the repo

on their own GitHub account (previous steps)

2

Add everyone as collaborators

Repo Settings, then Collaborators, then Add people

3

One person types, everyone steers

Answer /clarify together and review /analyze as a group

Advanced: split the work another layer to manage

Agree on one shared constitution first, then each person owns one feature:

Alex

/specify levels → 001-levels branch

Sam

/specify scoring → 002-scoring branch

Priya

/specify visuals → 003-visuals branch

Merge each branch with a pull request. Separate specs keep each agent inside its own files, so you don't overwrite each other.

Short on time? Stay with one driver. Splitting the work pays off on a longer build, not in a 60-minute block.

Slide 90 · Bring your idea to life: run these seven commands in order.

Bring your idea to life: run these seven commands in order.

Step

Command

What to type or do

1

/speckit.constitution

Please reference the StarterKit/CONSTITUTION.md file and start the SDD process for my network-themed educational game.

2

/speckit.specify

Please reference the StarterKit/SPEC.md file for your specifications.

3

/speckit.clarify

Answer the questions. Room checkpoint: compare what everyone is being asked.

4

/speckit.plan

Please reference the StarterKit/PLAN.md file and start planning. Use Markdown.

5

/speckit.tasks

No prompt needed.

6

/speckit.analyze

Room checkpoint: review findings, then ask the agent to fix everything found in your analysis.

7

/speckit.implement

Build the game, then open index.html in a browser.

Slide 91 · Show your games.

Show your games.

Each group picks two to share with the room.

12:30

Return to your group and play each other's games

Pick two

Each group chooses two games to show the room

Push

Commit your work to your GitHub repository

Share

Open an issue on the starter kit repo or tag @automateyournetwork

Slide 92 · Bring Your Game to the Internet

Bring Your Game to the Internet

Inside the repo there is an ARCADE.md template Have your agent complete the template

When you are happy and totally optionally send me your GitHub URL

I will add the game to the automateyournetwork.com/arcade

Slide 93 · Links to everything you need today.

Links to everything you need today.

Starter kit: github.com/automateyournetwork/NetworkingVideoGameStarterKit

Spec Kit: github.com/github/spec-kit

uv (installs the specify CLI): docs.astral.sh/uv

Claude Code: claude.com/claude-code

Codex: openai.com/codex

Ralph loop plugin for Claude Code: /plugin install ralph-loop@claude-plugins-official

VS Code: code.visualstudio.com

Itential Builder Skills: github.com/itential/builder-skills

Guide to spec-driven development: itential.com/resource/guide/spec-driven-development

AONE episode, Stop Vibe Coding: youtube.com/watch?v=9iWDteEhYk0

Slide 94 · Standards and guides for going further.

Standards and guides for going further.

Agentic AI Foundation (MCP, A2A, Agent Skills, AGENTS.md): aaif.io

Model Context Protocol: modelcontextprotocol.io

Agent2Agent (A2A) Protocol: a2a-protocol.org

Agent Skills open standard: agentskills.io

AGENTS.md: agents.md

Ralph, by Geoffrey Huntley (the original post): ghuntley.com/ralph

Ralph explained, plan and build modes: ralph-wiggum.ai

Ralph loop plugin for Claude Code: github.com/anthropics/claude-plugins-official

Loop Engineering, by Addy Osmani: addyosmani.com/blog/loop-engineering

Graph Engineering in the Era of LLM Agents (survey): arxiv.org/abs/2608.21156

Slide 95 · Sources

Sources

Geoffrey Huntley, “Ralph Wiggum as a ‘software engineer’,” July 2025: ghuntley.com/ralph

LinearB Dev Interrupted, “Inventing the Ralph Wiggum Loop,” January 2026: linearb.io

Anthropic, ralph-loop plugin for Claude Code: github.com/anthropics/claude-plugins-official

GitHub, Spec Kit repository and documentation: github.com/github/spec-kit

Anthropic, Model Context Protocol, November 2024: modelcontextprotocol.io

Itential, “Bring Your Own Coding Agent: Itential Builder Skills,” October 2026: itential.com

Itential, “Getting Started with Itential Builder Skills in Claude Code” (demo): itential.com

“Loop Engineering: Building Blocks, Adoption, and Impact,” 2026: arXiv:2608.21884

ADTmag, “Loop Engineering Emerges as Developers Put AI Coding Agents on Repeat,” July 2026: adtmag.com

Google DeepMind, AlphaProof Nexus preprint, 2026: arXiv:2605.22763

John Capobianco, Networking Video Game Starter Kit: github.com/automateyournetwork/NetworkingVideoGameStarterKit

The Art of Network Engineering, “Stop Vibe Coding: Start Spec-Driven Development,” August 2026: youtube.com/watch?v=9iWDteEhYk0

Slide 96 · Join the

Join the

Slide 97 · Build & Orchestrate Infrastructure AI Agents

Build & Orchestrate Infrastructure AI Agents

Live Virtual Workshop

Dec. 18, 2026

12–3 p.m. ET

Virtual

Free to Attend

Register Now

FPO

Slide 98 · Thank you

Thank you

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.

104,676lines of game code
41,315lines of test code
41,663lines of specs & documentation
1,849recorded passing tests

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.

One workshop, six directions · original 22 games
SubjectGamesGame linesTest linesSpec & doc linesRecorded tests
Routing623,23210,2798,702475
Security323,5687,8815,030468
Network fundamentals830,32615,71713,958588
Pure arcade213,6202,4874,18962
Switching and the NOC29,4123,5357,576146
Automation14,5181,4162,208110
Original collection22104,67641,31541,6631,849
Every original game, by the numbers 22 games · foundation snapshot
Formatted, non-blank source lines · original foundation measurements
GameGame codeTest codeSpecs & docsRecorded testsTest / game lines
Firewall Security Faceoff14,7042,2072,53119315.0%
Backbone13,0455,3702,88419841.2%
Split Decision7,4562,4562,17520032.9%
Uptime Survivors7,0748,7636,776165123.9%
AS-PATH Of Glory7,0290264Not recorded0.0%
NetMaul: Defend the Datacenter6,5912,4873,9256237.7%
Threat Level: Goose5,8671,8571,2086731.7%
Peering Patrol4,9721,6741,9949333.7%
Round Trip4,5181,4162,20811031.3%
NOC Ninja — Guided NOC Patrol4,4401,8615,5825341.9%
PACketMan - Networking Maze3,6471,4258284839.1%
Packet Dash3,5535286994614.9%
Throughput3,3389758596029.2%
Permit or Pew2,9973,8171,291208127.4%
Exchange Hall2,5099691,26810038.6%
Slow Ping2,4073658802015.2%
TCP Kart: Congestion Control2,1981,2151,3163455.3%
AS You Were2,1462,1471,407123100.0%
RIBRush2,1031,1221,1971253.4%
Network Ops: Night Shift1,5773557403522.5%
Subnet Sashimi1,4830565Not recorded0.0%
PacketJedi1,0223061,0662229.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.

TEST THE ANSWER, NOT JUST THE BUTTON

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.

Six habits worth taking back to your automation work
GameWhat was testedWhat it protects
Split DecisionHand-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 SurvivorsSeeded runs with three bot strategies, rather than trusting the performance of one bot.A balance problem that one play style concealed.
NetMaulA recorded sequence of purchases replays the campaign through the player’s controls.The whole experience remains completable after balance changes.
AS You WereA 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 KartThe deterministic rule evaluator is separate from the animation; ACK timing was corrected after player feedback.A convincing picture cannot override the protocol answer.
Round TripCommands 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.

Selected site-review records · preserved evidence
GameRecorded checksWhat the review established
Split Decision173 unit tests; 227 independent oracle comparisons; 27 upstream browser checksEvery one of the 20 designs matched an independently maintained answer key. All six rounds were completed with keyboard and touch emulation.
Permit or Pew208 upstream tests; 99 browser scenarios; 7 site checksThe six-wave campaign, movement, shooting, pause, hints and restart were exercised. The browser harness was adapted to macOS without changing the game.
Firewall Rule TypeRacer388 upstream browser checks; 18 integration checks; 17/17 runtime files unchangedKeyboard and touch-emulated campaigns reached the endless finale. Failure recovery, restart, missed crossings and reduced motion were checked.
Network Change Roulette404 independent branch outcomes; 1,200 scoring combinations; 19 site checksThe 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.

THE WORLDS HAVE MATERIAL

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.

393D model files
20audio files
68raster images
8SVG files
15font files

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
Local hosted files as of 2026-11-20 · file types, not creative works
GameAll filesMiBRasterSVGAudio3DFonts
AS You Were120.0800000
AS-PATH Of Glory30.1510000
Backbone130.3310008
Exchange Hall130.1610000
Firewall Rule TypeRacer170.1700002
Firewall Security Faceoff615.281100220
NetMaul: Defend the Datacenter657.90112000
Network Change Roulette210.6000000
Network Ops: Night Shift150.0600000
NOC Ninja — Guided NOC Patrol192.3551000
Packet Dash150.1100000
PacketJedi190.0505000
PACketMan - Networking Maze150.5710000
Peering Patrol280.9310000
Per-Hop Works1134.491000170
Permit or Pew190.1910000
RIBRush120.1310000
Round Trip141.1920000
Signal Age312.13150000
Slow Ping110.0900000
Split Decision230.3511005
Subnet Sashimi80.0400000
TCP Kart: Congestion Control252.2910000
Threat Level: Goose220.77130000
Throughput250.1620000
Uptime SurvivorsExternally hosted · not counted
Local payload total61930.58688203915

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.

Current catalogue records · 2026-11-20
GameRecorded testsTasksLoops / phasesHuman promptsHarness
AS You Were12337615Claude Code (CLI, connected to VS Code)
AS-PATH Of GloryNot recordedNot recordedNot recordedNot recordedClaude Code
Backbone19870919Claude Code
Exchange Hall10046615Claude Code
Firewall Rule TypeRacer38863Not recordedCodex
Firewall Security Faceoff19368929Claude Code
NetMaul: Defend the Datacenter6211520OpenAI Codex for VS Code
Network Change Roulette19720Not recordedCodex
Network Ops: Night Shift35306Not recordedCodex
NOC Ninja — Guided NOC Patrol53Not recordedNot recordedNot recordedCodex
Packet Dash4629811Claude Code
PacketJedi2228611Codex CLI
PACketMan - Networking Maze48396Not recordedCopilot SDK in VS Code
Peering Patrol9373826Claude Code
Per-Hop Works78695Not recordedCodex
Permit or Pew208519Not recordedClaude Code
RIBRush12316Not recordedCopilot SDK in VS Code
Round Trip110611054Claude Code
Signal Age99100Seven implementation slices recorded in tasks.mdNot recordedClaude Code
Slow Ping2029Not recordedNot recordedCodex desktop app
Split Decision20083914Claude Code
Subnet SashimiNot recorded163 implementation loops plus follow-up tasksNot recordedNot recorded
TCP Kart: Congestion Control34306Not recordedCopilot in VS Code
Threat Level: Goose67Not recordedNot recorded263Claude Code
ThroughputNot recorded25Seven workshop steps run by hand, one at a time. No Ralph loop.Not recordedClaude Code in the Claude desktop app (Code tab)
Uptime Survivors1652926Not recordedClaude 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 game card
RoutingOriginal collection

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 game card
Pure arcadeOriginal collection

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 game card
RoutingWorkshop demo

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 game card
RoutingOriginal collection

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 game card
SecurityLater addition

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 game card
SecurityOriginal collection

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 game card
Pure arcadeOriginal collection

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 game card
AutomationLater addition

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 game card
Network fundamentalsOriginal collection

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 game card
Switching and the NOCOriginal collection

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 game card
Network fundamentalsOriginal collection

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 game card
RoutingOriginal collection

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 game card
Network fundamentalsOriginal collection

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 game card
Switching and the NOCOriginal collection

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 game card
Network fundamentalsWorkshop demo

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 game card
SecurityOriginal collection

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 game card
RoutingWorkshop demo

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 game card
AutomationOriginal collection

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 game card
Network fundamentalsLater addition

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 game card
RoutingOriginal collection

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 game card
Network fundamentalsOriginal collection

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 game card
Network fundamentalsOriginal collection

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 game card
Network fundamentalsOriginal collection

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 game card
SecurityOriginal collection

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 game card
Network fundamentalsOriginal collection

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 game card
Network fundamentalsOriginal collection

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.

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