taking a 2012 html5 demo and modernizing it the way i've modernized enterprise systems for 25 years
In 2012, Mozilla shipped BrowserQuest — an HTML5 technology demo. A multiplayer RPG running in the browser, built to prove that the web could handle real-time games. It worked. Then Mozilla archived it.
It was a vertical slice: just enough code to prove the concept. No persistence beyond localStorage. No tests. No security. No observability. No separation of concerns. The kind of prototype that ships to prove a point, not to run in production.
That's the same starting point as most legacy enterprise systems I've worked on. Something that worked once, never got the supporting infrastructure it needed, and now needs to scale. So I built those systems.
The same process that works on enterprise software. It works on games too.
Read every file. Map the dependency graph. Identify what the prototype does and what it's missing. The original had no module boundaries, no error handling, and no separation between game logic and transport. Figure out what production systems it needs before writing any code.
3,161 tests before refactoring anything. When I extracted the combat system, every interaction was verified. When I built the aggro policy engine, tests caught edge cases I'd have shipped as bugs.
No big rewrites. Extract a module, test it, ship it. The MessageRouter was one change. Each handler module was one change. The CombatTracker was one change. At every step the game kept running.
Every abstraction solved a real problem. The SpatialManager exists because the aggro tick was O(n×m) and needed spatial partitioning. The AggroPolicy exists because safe zones, density caps, and level scaling were scattered across three files. The EventBus exists because mob death needed to notify five decoupled systems.
Three layers of AI integration that demonstrate contemporary understanding — not just using AI, but engineering systems around it.
Built with Claude as a development partner. Not copy-paste from ChatGPT — iterative architectural discussion, test-driven extraction, incremental refactoring with an AI that understands the full codebase context. This is how AI changes software engineering: not by replacing engineers, but by making one engineer ship what used to take a team.
8 specialized AI services power the game world. NPCs generate contextual dialogue through Venice AI (llama-3.3-70b). A narrator system provides voice-synthesized commentary via Fish Audio TTS. Mobs have ambient thought bubbles. Quests are generated dynamically. A Town Crier reports world events. The AI layer is fully decoupled — the game runs fine without API keys.
Production AI integration means handling failure gracefully. Circuit breaker pattern (closed → open after 5 failures → half-open recovery). Retry with exponential backoff. Error classification (timeout, auth, rate_limit, server_error, network). Latency histogram with sliding window. The game survives API outages without players noticing.
Hate-based aggro ranking, party XP sharing, kill streaks, 4 skills (phase shift, power strike, war cry, whirlwind), stun mechanics, leash distance.
6 zones from village safe haven to endgame lava fields. Per-zone loot modifiers, rarity scaling, level-gated difficulty. 172×314 tile map.
Endgame infinite-depth dungeon runs. 8 stacking modifiers (fortified, empowered, cursed…). Dynamic difficulty scaling. 100-entry leaderboard.
Pino structured logging (50 modules). OpenTelemetry traces on message routing, persistence, AI calls. SigNoz + Grafana dashboards. Log-trace correlation.
Socket.IO with 105 message types. Spatial partitioning for zone broadcasting. Per-message rate limiting. SQLite persistence with 60s auto-save.
3,161 tests, 65 test files. Vitest with v8 coverage. Tests written before refactors. Coverage thresholds enforced.
A pattern of AI-related projects, not a one-off.