{
  "snapshot": "2026-11-20",
  "foundationSha256": "b4d01d16460b5bbfeb722c9adefcc6a76d4c5e6e685931e8adb744c08202f17f",
  "baselineTotals": {
    "gameLines": 104676,
    "testLines": 41315,
    "docLines": 41663,
    "reportedTests": 1849
  },
  "categories": [
    {
      "category": "Routing",
      "games": 6,
      "gameLines": 23232,
      "testLines": 10279,
      "docLines": 8702,
      "reportedTests": 475
    },
    {
      "category": "Security",
      "games": 3,
      "gameLines": 23568,
      "testLines": 7881,
      "docLines": 5030,
      "reportedTests": 468
    },
    {
      "category": "Network fundamentals",
      "games": 8,
      "gameLines": 30326,
      "testLines": 15717,
      "docLines": 13958,
      "reportedTests": 588
    },
    {
      "category": "Pure arcade",
      "games": 2,
      "gameLines": 13620,
      "testLines": 2487,
      "docLines": 4189,
      "reportedTests": 62
    },
    {
      "category": "Switching and the NOC",
      "games": 2,
      "gameLines": 9412,
      "testLines": 3535,
      "docLines": 7576,
      "reportedTests": 146
    },
    {
      "category": "Automation",
      "games": 1,
      "gameLines": 4518,
      "testLines": 1416,
      "docLines": 2208,
      "reportedTests": 110
    }
  ],
  "assetTotals": {
    "files": 619,
    "bytes": 32066136,
    "raster": 68,
    "vector": 8,
    "audio": 20,
    "models": 39,
    "fonts": 15
  },
  "games": [
    {
      "slug": "firewall-rule-typeracer",
      "title": "Firewall Rule TypeRacer",
      "tagline": "Read the flags and type firewall rules before the IPs hit the floor.",
      "summary": "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.",
      "category": "Security",
      "level": "beginner",
      "image": "/images/arcade/firewall-rule-typeracer.png",
      "href": "/arcade/firewall-rule-typeracer/",
      "playHref": "/arcade/play/firewall-rule-typeracer/",
      "scope": "Later addition",
      "original": null,
      "baseline": null,
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "gpt-6.2-sol",
        "harness": "Codex",
        "artifacts": [
          "constitution",
          "spec",
          "plan",
          "tasks",
          "checklists",
          "research",
          "data-model",
          "contracts",
          "quickstart"
        ],
        "taskCount": 6,
        "phases": 3,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 388
      },
      "inventory": {
        "files": 17,
        "bytes": 179530,
        "raster": 0,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 2
      }
    },
    {
      "slug": "network-change-roulette",
      "title": "Network Change Roulette",
      "tagline": "Investigate a network change, challenge the bot, and decide whether to approve, hold, or roll back.",
      "summary": "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.",
      "category": "Automation",
      "level": "intermediate",
      "image": "/images/arcade/network-change-roulette.jpg",
      "href": "/arcade/network-change-roulette/",
      "playHref": "/arcade/play/network-change-roulette/",
      "scope": "Later addition",
      "original": null,
      "baseline": null,
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "unknown",
        "harness": "Codex",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "analysis"
        ],
        "taskCount": 7,
        "phases": 20,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 19
      },
      "inventory": {
        "files": 21,
        "bytes": 629097,
        "raster": 0,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "signal-age",
      "title": "Signal Age",
      "tagline": "Build a civilization’s communications, from smoke signals to wireless and satellite.",
      "summary": "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.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/signal-age.jpg",
      "href": "/arcade/signal-age/",
      "playHref": "/arcade/play/signal-age/",
      "scope": "Later addition",
      "original": null,
      "baseline": null,
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "unknown",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "plan",
          "tasks",
          "research",
          "data-model",
          "contracts",
          "quickstart",
          "checklists"
        ],
        "taskCount": 100,
        "phases": "Seven implementation slices recorded in tasks.md",
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 99
      },
      "inventory": {
        "files": 31,
        "bytes": 2238372,
        "raster": 15,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "split-decision",
      "title": "Split Decision",
      "tagline": "Pick the splitter that lights every home: not too dark, not too bright.",
      "summary": "You design the outside plant of a small fiber network. Each work order shows a PON, and you choose the splitter or the attenuator that gives every ONT a receive level inside its window while serving the most homes. A loss trace and a dB-by-dB ledger explain every result, right or wrong.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/split-decision.webp",
      "href": "/arcade/split-decision/",
      "playHref": "/arcade/play/split-decision/",
      "scope": "Original collection",
      "original": {
        "slug": "split-decision",
        "title": "Split Decision",
        "category": "Network fundamentals",
        "timing": "Started at the workshop, tuned through the week",
        "tagline": "Pick the splitter that lights every home: not too dark, not too bright.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "split-decision",
        "title": "Split Decision",
        "category": "Network fundamentals",
        "gameLines": 7456,
        "testLines": 2456,
        "docLines": 2175,
        "reportedTests": 200
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-fable-5-2",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "analysis",
          "checklists"
        ],
        "taskCount": 83,
        "phases": 9,
        "humanPrompts": 14,
        "wallTime": "8h26m39s"
      },
      "verification": {
        "reportedTests": 200
      },
      "inventory": {
        "files": 23,
        "bytes": 361976,
        "raster": 1,
        "vector": 1,
        "audio": 0,
        "models": 0,
        "fonts": 5
      }
    },
    {
      "slug": "subnet-sashimi",
      "title": "Subnet Sashimi",
      "tagline": "Fish for octets. Build a valid IPv4 host address.",
      "summary": "Catch numbered fish and assemble a host address inside the displayed subnet. A one-octet warm-up leads to full addresses and endless subnet challenges, with hints, worked answers, and ten points for each correct catch.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/subnet-sashimi.png",
      "href": "/arcade/subnet-sashimi/",
      "playHref": "/arcade/play/subnet-sashimi/",
      "scope": "Original collection",
      "original": {
        "slug": "subnet-sashimi",
        "title": "Subnet Sashimi",
        "category": "Network fundamentals",
        "timing": "Started at the workshop, tuned through the week",
        "tagline": "Fish for octets. Build a valid IPv4 host address.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "1,483 lines of game code",
          "Endless mode after the two guided rounds"
        ]
      },
      "baseline": {
        "slug": "subnet-sashimi",
        "title": "Subnet Sashimi",
        "category": "Network fundamentals",
        "gameLines": 1483,
        "testLines": 0,
        "docLines": 565,
        "reportedTests": null
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "COMING SOON",
        "harness": "COMING SOON",
        "artifacts": [
          "constitution",
          "spec",
          "plan",
          "research",
          "data model",
          "tasks",
          "quickstart"
        ],
        "taskCount": 16,
        "phases": "3 implementation loops plus follow-up tasks",
        "humanPrompts": 0,
        "wallTime": ""
      },
      "verification": {
        "reportedTests": null
      },
      "inventory": {
        "files": 8,
        "bytes": 41484,
        "raster": 0,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "tcp-congestion-control-game",
      "title": "TCP Kart: Congestion Control",
      "tagline": "Predict TCP's next move and watch data and ACKs race.",
      "summary": "Players predict how a TCP sender changes its congestion window, then watch a race illustrate the event and compare the prediction with the result. Three levels introduce slow start, congestion avoidance, and timeout response.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/tcp-congestion-control-game.png",
      "href": "/arcade/tcp-congestion-control-game/",
      "playHref": "/arcade/play/tcp-congestion-control-game/",
      "scope": "Original collection",
      "original": {
        "slug": "tcp-congestion-control-game",
        "title": "TCP Kart: Congestion Control",
        "category": "Network fundamentals",
        "timing": "Started at the workshop, tuned through the week",
        "tagline": "Predict TCP’s next move and watch data and ACKs race.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "2,198 lines of game code",
          "1,215 lines of tests",
          "34 passing tests",
          "3D circuit and karts are generated in code"
        ]
      },
      "baseline": {
        "slug": "tcp-congestion-control-game",
        "title": "TCP Kart: Congestion Control",
        "category": "Network fundamentals",
        "gameLines": 2198,
        "testLines": 1215,
        "docLines": 1316,
        "reportedTests": 34
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "unknown",
        "harness": "Copilot in VS Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "checklists"
        ],
        "taskCount": 30,
        "phases": 6,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 34
      },
      "inventory": {
        "files": 25,
        "bytes": 2397119,
        "raster": 1,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "uptime-survivors",
      "title": "Uptime Survivors",
      "tagline": "Survive 20 levels of network problems with auto-firing network tools",
      "summary": "You are the network engineer: steer while your tools (Ping, Firewall Rules, Ansible Playbooks, Load Balancers, Traceroute, Rate Limiters, Null Routes) fire on their own at network problems such as packet loss, BGP route flaps, broadcast storms and DDoS botnets, plus three Major Incidents. Every enemy, tool and upgrade is tied to a real networking concept, and an in-game Field Guide explains each one.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/uptime-survivors.png",
      "href": "/arcade/uptime-survivors/",
      "playHref": "/arcade/uptime-survivors/",
      "scope": "Original collection",
      "original": {
        "slug": "uptime-survivors",
        "title": "Uptime Survivors",
        "category": "Network fundamentals",
        "timing": "Started at the workshop, tuned through the week",
        "tagline": "Survive 20 levels of network problems with auto-firing network tools.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "uptime-survivors",
        "title": "Uptime Survivors",
        "category": "Network fundamentals",
        "gameLines": 7074,
        "testLines": 8763,
        "docLines": 6776,
        "reportedTests": 165
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-opus-5-5",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "research",
          "data-model",
          "contracts",
          "quickstart",
          "tasks",
          "checklists"
        ],
        "taskCount": 292,
        "phases": 6,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 165
      },
      "inventory": null
    },
    {
      "slug": "noc-ninja",
      "title": "NOC Ninja — Guided NOC Patrol",
      "tagline": "Investigate the link, explain the evidence, and verify the outcome.",
      "summary": "Investigate three Arista EOS link incidents through twelve guided decisions. Compare recorded commands at both endpoints, choose the replacement sequence, and review the diagnosis or reported repair. Scenario, question and answer order shuffle each patrol. Drag the shuriken to answer, learn from feedback, and download a handoff.",
      "category": "Switching and the NOC",
      "level": "beginner",
      "image": "/images/arcade/noc-ninja.webp",
      "href": "/arcade/noc-ninja/",
      "playHref": "/arcade/play/noc-ninja/",
      "scope": "Original collection",
      "original": {
        "slug": "noc-ninja",
        "title": "NOC Ninja: Guided NOC Patrol",
        "category": "Switching and the NOC",
        "timing": "Started at the workshop, tuned through the week",
        "tagline": "Investigate the link, explain the evidence, and verify the outcome.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "4,440 lines of game code",
          "1,861 lines of tests",
          "53 passing tests",
          "42 recorded command outputs",
          "Original generated artwork, bundled locally"
        ]
      },
      "baseline": {
        "slug": "noc-ninja",
        "title": "NOC Ninja: Guided NOC Patrol",
        "category": "Switching and the NOC",
        "gameLines": 4440,
        "testLines": 1861,
        "docLines": 5582,
        "reportedTests": 53
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "unknown",
        "harness": "Codex",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "checklists",
          "research",
          "data-model",
          "contracts",
          "verification"
        ],
        "taskCount": -1,
        "phases": 0,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 53
      },
      "inventory": {
        "files": 19,
        "bytes": 2462843,
        "raster": 5,
        "vector": 1,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "round-trip",
      "title": "Round Trip",
      "tagline": "Finish the script, run it, and watch whether the ping makes it there and back.",
      "summary": "The player places code cards into the blanks of a short Netmiko-style script, runs it against two simulated routers, and watches a ping travel from hostA to hostB and back. They learn that a script that ran without crashing has not necessarily fixed the network, by keeping apart what the script sent, what the router holds in its configuration, and what traffic does.",
      "category": "Automation",
      "level": "beginner",
      "image": "/images/arcade/round-trip.png",
      "href": "/arcade/round-trip/",
      "playHref": "/arcade/play/round-trip/",
      "scope": "Original collection",
      "original": {
        "slug": "round-trip",
        "title": "Round Trip",
        "category": "Automation",
        "timing": "Started at the workshop, tuned through the week",
        "tagline": "Finish the script, run it, and watch whether the ping makes it there and back.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "round-trip",
        "title": "Round Trip",
        "category": "Automation",
        "gameLines": 4518,
        "testLines": 1416,
        "docLines": 2208,
        "reportedTests": 110
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-fable-5-2",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "checklists",
          "research",
          "data-model",
          "contracts",
          "quickstart"
        ],
        "taskCount": 61,
        "phases": 10,
        "humanPrompts": 54,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 110
      },
      "inventory": {
        "files": 14,
        "bytes": 1251466,
        "raster": 2,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "peering-patrol",
      "title": "Peering Patrol",
      "tagline": "Run the NOC at an IXP and zap the packets that don't belong on the peering LAN.",
      "summary": "You are the NOC operator at an IX.br-style Internet Exchange. Packets fly from 8 member routers to the shared ATM peering LAN, and broadcasts split into copies that flood every member. Zap CDP, MNDP, STP, OSPF, PIM, IGMP, MLD, IPv6 RA/RS, ARP/NS for non-ATM addresses and broadcast NTP; let BGP, unicast traffic and ARP/ND for ATM addresses through. Every decision explains what the packet is and what to disable on your own IX-facing interface.",
      "category": "Switching and the NOC",
      "level": "intermediate",
      "image": "/images/arcade/peering-patrol.png",
      "href": "/arcade/peering-patrol/",
      "playHref": "/arcade/play/peering-patrol/",
      "scope": "Original collection",
      "original": {
        "slug": "peering-patrol",
        "title": "Peering Patrol",
        "category": "Switching and the NOC",
        "timing": "Started at the workshop, tuned through the week",
        "tagline": "Run the NOC at an IXP and zap the packets that don’t belong on the peering LAN.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "peering-patrol",
        "title": "Peering Patrol",
        "category": "Switching and the NOC",
        "gameLines": 4972,
        "testLines": 1674,
        "docLines": 1994,
        "reportedTests": 93
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-opus-5-5",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "analysis",
          "checklists"
        ],
        "taskCount": 73,
        "phases": 8,
        "humanPrompts": 26,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 93
      },
      "inventory": {
        "files": 28,
        "bytes": 976943,
        "raster": 1,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "permit-or-pew",
      "title": "Permit or Pew",
      "tagline": "Shoot the packets the ACL denies. Let the permitted ones through.",
      "summary": "You are a firewall in a Galaga-style arcade game. Packets dive toward your network, and you read an access list to decide which to shoot and which to let through, losing health for every wrong call. After each wave, a review shows what you got wrong and which rule decided it.",
      "category": "Security",
      "level": "beginner",
      "image": "/images/arcade/permit-or-pew.png",
      "href": "/arcade/permit-or-pew/",
      "playHref": "/arcade/play/permit-or-pew/",
      "scope": "Original collection",
      "original": {
        "slug": "permit-or-pew",
        "title": "Permit or Pew",
        "category": "Security",
        "timing": "Started at the workshop, tuned through the week",
        "tagline": "Shoot the packets the ACL denies. Let the permitted ones through.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "permit-or-pew",
        "title": "Permit or Pew",
        "category": "Security",
        "gameLines": 2997,
        "testLines": 3817,
        "docLines": 1291,
        "reportedTests": 208
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-sonnet-5-5",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "checklists"
        ],
        "taskCount": 51,
        "phases": 9,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 208
      },
      "inventory": {
        "files": 19,
        "bytes": 199549,
        "raster": 1,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "as-you-were",
      "title": "AS You Were",
      "tagline": "Pick the BGP path a Cisco router installs, then see which best-path step decided.",
      "summary": "You play the route selector inside one Cisco IOS router and pick which of several candidate paths to 203.0.113.0/24 it installs. A step ladder then shows which of the first five best-path steps tied, narrowed or decided, and every wrong pick names the misconception behind it.",
      "category": "Routing",
      "level": "intermediate",
      "image": "/images/arcade/as-you-were.png",
      "href": "/arcade/as-you-were/",
      "playHref": "/arcade/play/as-you-were/",
      "scope": "Original collection",
      "original": {
        "slug": "as-you-were",
        "title": "AS You Were",
        "category": "Routing",
        "timing": "Built on workshop day",
        "tagline": "Pick the BGP path a router installs, then see which best-path step decided.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "as-you-were",
        "title": "AS You Were",
        "category": "Routing",
        "gameLines": 2146,
        "testLines": 2147,
        "docLines": 1407,
        "reportedTests": 123
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-opus-5-5",
        "harness": "Claude Code (CLI, connected to VS Code)",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "checklists",
          "research",
          "data-model",
          "contracts",
          "quickstart"
        ],
        "taskCount": 37,
        "phases": 6,
        "humanPrompts": 15,
        "wallTime": "59m"
      },
      "verification": {
        "reportedTests": 123
      },
      "inventory": {
        "files": 12,
        "bytes": 88099,
        "raster": 0,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "as-path-of-glory",
      "title": "AS-PATH Of Glory",
      "tagline": "Joust tech billionaires above a lava pit, riding a flying 1U switch.",
      "summary": "You are a network automation engineer on a flying switch with a patch-cable lance, jousting minions and four parody tech-billionaire bosses. Higher lance wins; throw your 5 lances and grab them back. It is a fun arcade game with networking jokes, not a networking lesson.",
      "category": "Pure arcade",
      "level": "beginner",
      "image": "/images/arcade/as-path-of-glory.webp",
      "href": "/arcade/as-path-of-glory/",
      "playHref": "/arcade/play/as-path-of-glory/",
      "scope": "Original collection",
      "original": {
        "slug": "as-path-of-glory",
        "title": "AS-PATH Of Glory",
        "category": "Pure arcade",
        "timing": "Built on workshop day",
        "tagline": "Joust above a lava pit, riding a flying 1U switch.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "7,029 lines of game code",
          "One HTML file, 12 waves",
          "17 scripted logic checks"
        ]
      },
      "baseline": {
        "slug": "as-path-of-glory",
        "title": "AS-PATH Of Glory",
        "category": "Pure arcade",
        "gameLines": 7029,
        "testLines": 0,
        "docLines": 264,
        "reportedTests": null
      },
      "build": {
        "framework": "custom",
        "model": "claude-opus-5-5",
        "harness": "Claude Code",
        "artifacts": [
          "constitution"
        ],
        "taskCount": 0,
        "phases": 0,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": null
      },
      "inventory": {
        "files": 3,
        "bytes": 155380,
        "raster": 1,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "exchange-hall",
      "title": "Exchange Hall",
      "tagline": "Choose where each packet leaves your network: IXP peer, route server, or transit.",
      "summary": "Players run the on-call desk of a small ISP that has joined an Internet Exchange Point and pick the exit each packet takes. Three levels teach that the route server never carries traffic, that peers announce only their own and their customers' prefixes, and that longest prefix match wins before the peer-over-transit preference.",
      "category": "Routing",
      "level": "beginner",
      "image": "/images/arcade/exchange-hall.webp",
      "href": "/arcade/exchange-hall/",
      "playHref": "/arcade/play/exchange-hall/",
      "scope": "Original collection",
      "original": {
        "slug": "exchange-hall",
        "title": "Exchange Hall",
        "category": "Routing",
        "timing": "Built on workshop day",
        "tagline": "Choose where each packet leaves your network: IXP peer, route server, or transit.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "exchange-hall",
        "title": "Exchange Hall",
        "category": "Routing",
        "gameLines": 2509,
        "testLines": 969,
        "docLines": 1268,
        "reportedTests": 100
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-opus-5-5",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "analysis",
          "checklists"
        ],
        "taskCount": 46,
        "phases": 6,
        "humanPrompts": 15,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 100
      },
      "inventory": {
        "files": 13,
        "bytes": 168714,
        "raster": 1,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "firewall-security-faceoff",
      "title": "Firewall Security Faceoff",
      "tagline": "Turn-based hex strategy where your firewall rules are the gates of a city.",
      "summary": "A turn-based 3D strategy game. Your network is a city on a hex map and your firewall is its gatehouse. Wanted traffic and attacks march toward it, each with a banner showing what your rules will do, and each turn you add, reorder and switch gates before ending the turn. Three levels teach first-match rule order, implicit deny, least privilege, application-aware rules, inspection and TLS decryption, DNS filtering, and identity-based segmentation. It has a home menu, a How to Play screen, level briefings, and a guided first level.",
      "category": "Security",
      "level": "intermediate",
      "image": "/images/arcade/firewall-security-faceoff.png",
      "href": "/arcade/firewall-security-faceoff/",
      "playHref": "/arcade/play/firewall-security-faceoff/",
      "scope": "Original collection",
      "original": {
        "slug": "firewall-security-faceoff",
        "title": "Firewall Security Faceoff",
        "category": "Security",
        "timing": "Built on workshop day",
        "tagline": "Turn-based hex strategy where your firewall rules are the gates of a city.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "firewall-security-faceoff",
        "title": "Firewall Security Faceoff",
        "category": "Security",
        "gameLines": 14704,
        "testLines": 2207,
        "docLines": 2531,
        "reportedTests": 193
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-fable-5-2",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "analyze",
          "checklists"
        ],
        "taskCount": 68,
        "phases": 9,
        "humanPrompts": 29,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 193
      },
      "inventory": {
        "files": 61,
        "bytes": 5532918,
        "raster": 11,
        "vector": 0,
        "audio": 0,
        "models": 22,
        "fonts": 0
      }
    },
    {
      "slug": "netmaul",
      "title": "NetMaul: Defend the Datacenter",
      "tagline": "Build the maze. Make the next wave pass your best towers twice.",
      "summary": "Build a maze from networking equipment and defend the datacenter across 20 waves. Learn how path length, tower placement and equipment matchups change the outcome, with an optional field guide to the networking ideas behind the names.",
      "category": "Pure arcade",
      "level": "beginner",
      "image": "/images/arcade/netmaul.jpg",
      "href": "/arcade/netmaul/",
      "playHref": "/arcade/play/netmaul/",
      "scope": "Original collection",
      "original": {
        "slug": "netmaul",
        "title": "NetMaul: Defend the Datacenter",
        "category": "Pure arcade",
        "timing": "Built on workshop day",
        "tagline": "Build the maze. Make the next wave pass your best towers twice.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "netmaul",
        "title": "NetMaul: Defend the Datacenter",
        "category": "Pure arcade",
        "gameLines": 6591,
        "testLines": 2487,
        "docLines": 3925,
        "reportedTests": 62
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "gpt-6.2-astra",
        "harness": "OpenAI Codex for VS Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "checklists"
        ],
        "taskCount": 11,
        "phases": 5,
        "humanPrompts": 20,
        "wallTime": "5h 03m 40s"
      },
      "verification": {
        "reportedTests": 62
      },
      "inventory": {
        "files": 65,
        "bytes": 8279607,
        "raster": 1,
        "vector": 1,
        "audio": 20,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "network-ops-night-shift",
      "title": "Network Ops: Night Shift",
      "tagline": "Keep a pixel-art outpost online until dawn.",
      "summary": "Work through six incidents by probing network paths and repairing switch ports, host gateways and router entries. Compare the same probe before and after a repair to earn a field patch.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/network-ops-night-shift.png",
      "href": "/arcade/network-ops-night-shift/",
      "playHref": "/arcade/play/network-ops-night-shift/",
      "scope": "Original collection",
      "original": {
        "slug": "network-ops-night-shift",
        "title": "Network Ops: Night Shift",
        "category": "Network fundamentals",
        "timing": "Built on workshop day",
        "tagline": "Keep a pixel-art outpost online until dawn.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "1,577 lines of game code",
          "355 lines of tests",
          "35 passing tests",
          "Pixel art drawn entirely in code"
        ]
      },
      "baseline": {
        "slug": "network-ops-night-shift",
        "title": "Network Ops: Night Shift",
        "category": "Network fundamentals",
        "gameLines": 1577,
        "testLines": 355,
        "docLines": 740,
        "reportedTests": 35
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "gpt-6.2-astra",
        "harness": "Codex",
        "artifacts": [
          ".specify/memory/constitution.md",
          "specs/001-network-ops-night-shift/spec.md",
          "specs/001-network-ops-night-shift/plan.md",
          "specs/001-network-ops-night-shift/tasks.md",
          "specs/001-network-ops-night-shift/research.md",
          "specs/001-network-ops-night-shift/data-model.md",
          "specs/001-network-ops-night-shift/quickstart.md",
          "specs/001-network-ops-night-shift/contracts/ui-and-evaluator.md",
          "specs/001-network-ops-night-shift/checklists/requirements.md"
        ],
        "taskCount": 30,
        "phases": 6,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 35
      },
      "inventory": {
        "files": 15,
        "bytes": 62288,
        "raster": 0,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "packet-dash",
      "title": "Packet Dash",
      "tagline": "Run and jump as a packet; learn ports, latency vs bandwidth and resends.",
      "summary": "Players run and jump as Pak, a data packet crossing the network, and at the end of each stretch make one delivery decision: which building and door (IP address and port), which path (latency vs bandwidth), which numbered pieces to resend. Each choice is explained in a network log, and after each level a news card links the idea to the November 2026 FAA ground stop and Chase outage.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/packet-dash.png",
      "href": "/arcade/packet-dash/",
      "playHref": "/arcade/play/packet-dash/",
      "scope": "Original collection",
      "original": {
        "slug": "packet-dash",
        "title": "Packet Dash",
        "category": "Network fundamentals",
        "timing": "Built on workshop day",
        "tagline": "Run and jump as a packet; learn ports, latency versus bandwidth, and resends.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "3,553 lines of game code",
          "528 lines of tests",
          "46 passing tests",
          "11 human prompts"
        ]
      },
      "baseline": {
        "slug": "packet-dash",
        "title": "Packet Dash",
        "category": "Network fundamentals",
        "gameLines": 3553,
        "testLines": 528,
        "docLines": 699,
        "reportedTests": 46
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-opus-5-5",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "analysis",
          "verification"
        ],
        "taskCount": 29,
        "phases": 8,
        "humanPrompts": 11,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 46
      },
      "inventory": {
        "files": 15,
        "bytes": 117673,
        "raster": 0,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "packetjedi",
      "title": "PacketJedi",
      "tagline": "Trace OSPF LSAs to every router in scope.",
      "summary": "Players select every router that receives each OSPF LSA in a fictional three-area topology. Five rounds teach area scope, ABR summaries, and Type 5 flooding around a stub area, with RFC-cited feedback after answers.",
      "category": "Routing",
      "level": "beginner",
      "image": "/images/arcade/packetjedi.png",
      "href": "/arcade/packetjedi/",
      "playHref": "/arcade/play/packetjedi/",
      "scope": "Original collection",
      "original": {
        "slug": "packetjedi",
        "title": "PacketJedi",
        "category": "Routing",
        "timing": "Built on workshop day",
        "tagline": "Trace OSPF LSAs to every router in scope.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "1,022 lines of game code",
          "306 lines of tests",
          "22 passing tests",
          "11 human prompts",
          "Five hand-authored SVG characters"
        ]
      },
      "baseline": {
        "slug": "packetjedi",
        "title": "PacketJedi",
        "category": "Routing",
        "gameLines": 1022,
        "testLines": 306,
        "docLines": 1066,
        "reportedTests": 22
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "unknown",
        "harness": "Codex CLI",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "checklists",
          "research",
          "data-model",
          "quickstart",
          "game-ui-contract"
        ],
        "taskCount": 28,
        "phases": 6,
        "humanPrompts": 11,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 22
      },
      "inventory": {
        "files": 19,
        "bytes": 57114,
        "raster": 0,
        "vector": 5,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "packetman-networking-maze",
      "title": "PACketMan - Networking Maze",
      "tagline": "Move a packet through a network maze. Learn each decision along the way.",
      "summary": "Move a packet through six networking lessons, choosing routes and making decisions at checkpoints. Learn how routing, ACLs, transport, subnets, QoS, and congestion affect packet delivery.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/packetman-networking-maze.png",
      "href": "/arcade/packetman-networking-maze/",
      "playHref": "/arcade/play/packetman-networking-maze/",
      "scope": "Original collection",
      "original": {
        "slug": "packetman-networking-maze",
        "title": "PACketMan: Networking Maze",
        "category": "Network fundamentals",
        "timing": "Built on workshop day",
        "tagline": "Move a packet through a network maze. Learn each decision along the way.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "3,647 lines of game code",
          "1,425 lines of tests",
          "48 passing tests",
          "18 checkpoints across 6 lessons"
        ]
      },
      "baseline": {
        "slug": "packetman-networking-maze",
        "title": "PACketMan: Networking Maze",
        "category": "Network fundamentals",
        "gameLines": 3647,
        "testLines": 1425,
        "docLines": 828,
        "reportedTests": 48
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "unknown",
        "harness": "Copilot SDK in VS Code",
        "artifacts": [
          "spec",
          "plan",
          "tasks",
          "research",
          "data-model",
          "quickstart",
          "checklists"
        ],
        "taskCount": 39,
        "phases": 6,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 48
      },
      "inventory": {
        "files": 15,
        "bytes": 598695,
        "raster": 1,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "slow-ping",
      "title": "Slow Ping",
      "tagline": "Make the ping slow. Keep it working.",
      "summary": "Change static routes in working networks to maximize successful ping round-trip time. Three increasingly difficult levels teach weighted paths, independent request/reply routing, longest-prefix matching and TTL limits.",
      "category": "Routing",
      "level": "advanced",
      "image": "/images/arcade/slow-ping.png",
      "href": "/arcade/slow-ping/",
      "playHref": "/arcade/play/slow-ping/",
      "scope": "Original collection",
      "original": {
        "slug": "slow-ping",
        "title": "Slow Ping",
        "category": "Routing",
        "timing": "Built on workshop day",
        "tagline": "Make the ping slow. Keep it working.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "2,407 lines of game code",
          "365 lines of tests",
          "20 passing tests",
          "22 additional browser checks"
        ]
      },
      "baseline": {
        "slug": "slow-ping",
        "title": "Slow Ping",
        "category": "Routing",
        "gameLines": 2407,
        "testLines": 365,
        "docLines": 880,
        "reportedTests": 20
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "gpt-6.1-sol",
        "harness": "Codex desktop app",
        "artifacts": [
          ".specify/memory/constitution.md",
          "StarterKit/CONSTITUTION.md",
          "StarterKit/SPEC.md",
          "StarterKit/PLAN.md",
          "specs/001-maximize-ping-latency/checklists/requirements.md",
          "specs/001-maximize-ping-latency/contracts/interaction.md",
          "specs/001-maximize-ping-latency/data-model.md",
          "specs/001-maximize-ping-latency/plan.md",
          "specs/001-maximize-ping-latency/quickstart.md",
          "specs/001-maximize-ping-latency/research.md",
          "specs/001-maximize-ping-latency/spec.md",
          "specs/001-maximize-ping-latency/tasks.md",
          "specs/002-explicit-path-tunnel/checklists/requirements.md",
          "specs/002-explicit-path-tunnel/contracts/interaction.md",
          "specs/002-explicit-path-tunnel/data-model.md",
          "specs/002-explicit-path-tunnel/plan.md",
          "specs/002-explicit-path-tunnel/quickstart.md",
          "specs/002-explicit-path-tunnel/research.md",
          "specs/002-explicit-path-tunnel/spec.md",
          "specs/002-explicit-path-tunnel/tasks.md",
          "specs/003-static-difficulty/checklists/requirements.md",
          "specs/003-static-difficulty/path-proof.json",
          "specs/003-static-difficulty/plan.md",
          "specs/003-static-difficulty/research.md",
          "specs/003-static-difficulty/spec.md",
          "specs/003-static-difficulty/tasks.md"
        ],
        "taskCount": 29,
        "phases": 0,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 20
      },
      "inventory": {
        "files": 11,
        "bytes": 93788,
        "raster": 0,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "threat-level-goose",
      "title": "Threat Level: Goose",
      "tagline": "Defend Chef Bear's secret recipes with layered security, and keep an eye on Goose.",
      "summary": "A security tower defense game: build layered defenses around a pastry shop's recipe safe while phishing, stolen logins, tailgaters, skimmers and a ransomware gang lose health at each layer. Between waves, incident calls ask Security+-style questions and show invoices to pay or refuse, so players learn defense in depth and what each control really does.",
      "category": "Security",
      "level": "beginner",
      "image": "/images/arcade/threat-level-goose.webp",
      "href": "/arcade/threat-level-goose/",
      "playHref": "/arcade/play/threat-level-goose/",
      "scope": "Original collection",
      "original": {
        "slug": "threat-level-goose",
        "title": "Threat Level: Goose",
        "category": "Security",
        "timing": "The long-haul build: four days of play-testing",
        "tagline": "Defend Chef Bear’s secret recipes with layered security, and keep an eye on Goose.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "threat-level-goose",
        "title": "Threat Level: Goose",
        "category": "Security",
        "gameLines": 5867,
        "testLines": 1857,
        "docLines": 1208,
        "reportedTests": 67
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-opus-5-5",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "checklists"
        ],
        "taskCount": 0,
        "phases": 0,
        "humanPrompts": 263,
        "wallTime": "4 days (2026-11-13 to 2026-11-16); hands-on hours not recorded"
      },
      "verification": {
        "reportedTests": 67
      },
      "inventory": {
        "files": 22,
        "bytes": 810524,
        "raster": 13,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "throughput",
      "title": "Throughput",
      "tagline": "Find the bottleneck, share the load, and outscore three bots.",
      "summary": "Throughput is a short browser game where you build a chain of network devices that carries packets from a Source to a Destination while three bots compete and attack. Seven random events and six attacks are announced with a five-second countdown, two of the attacks need a combination of equipment to stop, and a live leaderboard tracks the race. After each decision it names the bottleneck, teaching that a path is only as fast as its slowest device and that parallel paths share load.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/throughput.jpg",
      "href": "/arcade/throughput/",
      "playHref": "/arcade/play/throughput/",
      "scope": "Original collection",
      "original": {
        "slug": "throughput",
        "title": "Throughput",
        "category": "Network fundamentals",
        "timing": "Built on workshop day",
        "tagline": "Find the bottleneck, share the load, and outscore three bots.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "3,338 lines of game code",
          "975 lines of tests",
          "60 passing tests",
          "7 random events and 6 attacks"
        ]
      },
      "baseline": {
        "slug": "throughput",
        "title": "Throughput",
        "category": "Network fundamentals",
        "gameLines": 3338,
        "testLines": 975,
        "docLines": 859,
        "reportedTests": 60
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-sonnet-5-5",
        "harness": "Claude Code in the Claude desktop app (Code tab)",
        "artifacts": [
          ".specify/memory/constitution.md",
          "specs/001-solo-vs-bots/spec.md",
          "specs/001-solo-vs-bots/plan.md",
          "specs/001-solo-vs-bots/tasks.md",
          "specs/001-solo-vs-bots/analysis.md",
          "StarterKit/CONSTITUTION.md",
          "StarterKit/SPEC.md",
          "StarterKit/PLAN.md"
        ],
        "taskCount": 25,
        "phases": "Seven workshop steps run by hand, one at a time. No Ralph loop.",
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": null
      },
      "inventory": {
        "files": 25,
        "bytes": 170176,
        "raster": 2,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "ribrush",
      "title": "RIBRush",
      "tagline": "Practice the route-selection rules that decide where packets go.",
      "summary": "Players compare each packet destination with candidate routes and choose the winning next hop. Seven levels move from mixed IPv4 warmups through focused longest-prefix, administrative-distance, and metric practice, then transfer the rules to IPv6.",
      "category": "Routing",
      "level": "beginner",
      "image": "/images/arcade/ribrush.webp",
      "href": "/arcade/ribrush/",
      "playHref": "/arcade/play/ribrush/",
      "scope": "Workshop demo",
      "original": {
        "slug": "ribrush",
        "title": "RIBRush",
        "category": "Routing",
        "timing": "Worked example built ahead of the workshop",
        "tagline": "Practice the route-selection rules that decide where packets go.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "2,103 lines of game code",
          "1,122 lines of tests",
          "12 passing tests",
          "Seven levels, IPv4 into IPv6"
        ]
      },
      "baseline": {
        "slug": "ribrush",
        "title": "RIBRush",
        "category": "Routing",
        "gameLines": 2103,
        "testLines": 1122,
        "docLines": 1197,
        "reportedTests": 12
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-opus-5-5",
        "harness": "Copilot SDK in VS Code",
        "artifacts": [
          "constitution",
          "spec",
          "plan",
          "tasks",
          "checklists",
          "research",
          "data-model",
          "contracts",
          "quickstart"
        ],
        "taskCount": 31,
        "phases": 6,
        "humanPrompts": 0,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 12
      },
      "inventory": {
        "files": 12,
        "bytes": 138030,
        "raster": 1,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 0
      }
    },
    {
      "slug": "backbone",
      "title": "Backbone",
      "tagline": "Build the backbone. Never steer a packet. Predict where the congestion goes.",
      "summary": "The player lays fiber between cities, sets link costs and upgrades capacity while every packet follows OSPF's lowest-cost path. Overloaded links drop packets and fiber cuts force reconvergence, so the player learns to predict where load moves when the network changes.",
      "category": "Routing",
      "level": "intermediate",
      "image": "/images/arcade/backbone.webp",
      "href": "/arcade/backbone/",
      "playHref": "/arcade/play/backbone/",
      "scope": "Workshop demo",
      "original": {
        "slug": "backbone",
        "title": "Backbone",
        "category": "Routing",
        "timing": "Worked example built ahead of the workshop",
        "tagline": "Build the backbone. Never steer a packet. Predict where the congestion goes.",
        "paragraphs": {
          "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."
        },
        "facts": [
          "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"
        ]
      },
      "baseline": {
        "slug": "backbone",
        "title": "Backbone",
        "category": "Routing",
        "gameLines": 13045,
        "testLines": 5370,
        "docLines": 2884,
        "reportedTests": 198
      },
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "claude-fable-5-2",
        "harness": "Claude Code",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "analysis",
          "checklists"
        ],
        "taskCount": 70,
        "phases": 9,
        "humanPrompts": 19,
        "wallTime": "unknown"
      },
      "verification": {
        "reportedTests": 198
      },
      "inventory": {
        "files": 13,
        "bytes": 347971,
        "raster": 1,
        "vector": 0,
        "audio": 0,
        "models": 0,
        "fonts": 8
      }
    },
    {
      "slug": "per-hop-works",
      "title": "Per-Hop Works",
      "tagline": "A playable packet factory for learning DiffServ, one work order at a time.",
      "summary": "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.",
      "category": "Network fundamentals",
      "level": "beginner",
      "image": "/images/arcade/per-hop-works.webp",
      "href": "/arcade/per-hop-works/",
      "playHref": "/arcade/play/per-hop-works/",
      "scope": "Workshop demo",
      "original": null,
      "baseline": null,
      "build": {
        "framework": "GitHub Spec Kit",
        "model": "gpt-6-astra",
        "harness": "Codex",
        "artifacts": [
          "constitution",
          "spec",
          "clarify",
          "plan",
          "tasks",
          "analysis",
          "checklists"
        ],
        "taskCount": 69,
        "phases": 5,
        "humanPrompts": 0,
        "wallTime": "1h58m33s"
      },
      "verification": {
        "reportedTests": 78
      },
      "inventory": {
        "files": 113,
        "bytes": 4706780,
        "raster": 10,
        "vector": 0,
        "audio": 0,
        "models": 17,
        "fonts": 0
      }
    }
  ],
  "integration": [
    {
      "slug": "split-decision",
      "checks": "173 unit tests; 227 independent oracle comparisons; 27 upstream browser checks",
      "meaning": "Every one of the 20 designs matched an independently maintained answer key. All six rounds were completed with keyboard and touch emulation.",
      "source": "split-decision-local-verification.json"
    },
    {
      "slug": "permit-or-pew",
      "checks": "208 upstream tests; 99 browser scenarios; 7 site checks",
      "meaning": "The six-wave campaign, movement, shooting, pause, hints and restart were exercised. The browser harness was adapted to macOS without changing the game.",
      "source": "permit-or-pew-local-verification.json"
    },
    {
      "slug": "firewall-rule-typeracer",
      "checks": "388 upstream browser checks; 18 integration checks; 17/17 runtime files unchanged",
      "meaning": "Keyboard and touch-emulated campaigns reached the endless finale. Failure recovery, restart, missed crossings and reduced motion were checked.",
      "source": "firewall-rule-typeracer-local-verification.json"
    },
    {
      "slug": "network-change-roulette",
      "checks": "404 independent branch outcomes; 1,200 scoring combinations; 19 site checks",
      "meaning": "The review covered all 101 tickets (100 scored in the duel). Saved-state validation and an accessible retry screen were repaired in the hosted edition.",
      "source": "network-change-roulette-local-verification.json"
    }
  ],
  "recordedTests": {
    "games": 23,
    "total": 2373
  },
  "methodology": {
    "baseline": "Original 22-game foundation snapshot: non-blank formatted game, test and documentation lines; vendor libraries, templates, reference text and generated traces excluded by the original author. Retained, not re-counted here.",
    "inventory": "Current local hosted payload, recursively counted by extension. Includes bundled dependencies and all delivered files; no inferred authorship or uniqueness. Externally hosted Uptime Survivors excluded. Procedural assets have no standalone files and are not counted as zero creativity.",
    "tests": "Recorded counts from the original foundation and current catalogue are separate snapshots. Counts mix test types and runner conventions and are not measures of coverage, correctness or workshop-only output."
  }
}
