Building a Browser MMO TCG Alone
October 23, 2026
How developers contribute meaningful software has dramatically changed within a few years. Whereas previously hand chiseling code was the only respected way to contribute, much of that manual labor is now outsourced to AI. This has expanded the capacity of a single developer. What took a team of engineers to accomplish before can be done by one engineer, with certain tradeoffs. I tested this hypothesis by devoting a year of my life creating a browser MMO trading card game alone. Instead of a team of individual experts for frontend, backend, DevOps, and QA, I believed I could be the engineering team
At 29-years-old I quit my stable job as a frontend developer to pursue my dream of working for myself. Working remotely for a Japanese company from South Korea, it was decently well-paid, good work-life balance, generous holidays, and I could have stayed for much longer. But I wanted to give myself the first year of my 30s to create a product from scratch. Growing up with card games like Yu-Gi-Oh!, Magic the Gathering, and playing browser MMOs because my Windows XP computer wouldn't run anything else, I wanted to combine both genres and create an MMO trading card game. I made different browser game prototypes, but they all lacked depth. I was bottlenecked by my capacity as a single developer for a project that required a team.
My goal was to create a browser MMO alone within a year. The deadline was because I wanted to soon be married, start raising kids, and be employed while doing so. I was doing it alone because the project was entirely bootstrapped. I realized it was better to start sooner than later because delaying further meant higher consequences to pursuing a passion project than building a family. Creating a browser MMO required interdisciplinary skills across both technology and art, and I was willing to invest in myself. But it was unfeasible to have expertise in all areas when I only had 5 years of experience as a frontend developer.
With advancements in AI, it was entirely possible to build what once required an engineering team as a solo developer. By the time I quit at the end of 2025, harnesses like Claude Code could create entire features with guidance. Using all my prior experience building web applications, discipline, and conviction, I had all the tools necessary to build my vision. I planned the necessary art, frontend, and backend requirements. I would purchase pixel art from professional artists for the game world. I had confidence in the frontend and AI would assist with the backend. After many months of self-reflection and discussions with my girlfriend, I submitted my resignation and was excitedly self-employed for the new year of 2026.
After 5 years using Javascript and React, it would have been trivial to use React for the frontend and a Node.js multiplayer game framework for the backend. However, I wanted to leverage AI to ease the transition into using new technologies that were better solutions than what I was familiar with. Javascript’s single-threaded design means it can only do one thing at a time. It can appear to work concurrently by completing tasks quickly using the event loop, but as soon as one task takes too long or an unhandled error occurs, the blast radius can slow or crash the entire application. Because realtime concurrency is not a first-class citizen in Node.js, developers need external dependencies like Redis to know how many users are online across all servers at any time. If the application ever crashes and needs to restart, developers require another external dependency like PM2 which reboots the entire application. Instead of a web of dependencies, I wanted something that could provide these solutions out of the box.
The answer was Elixir. Built on top of the Erlang Virtual Machine which powers applications like WhatsApp and Discord that serve millions of users, Elixir is a functional programming language with concurrency, server-to-server communication, and recovery from crashes built in. The Phoenix web framework is the Elixir equivalent of Next.js to build web applications but with batteries fully included for authentication, realtime PubSub, and database wrappers to simplify queries. I had never used these technologies before, but in the age of software engineering with AI, domain expertise was less of an absolute requirement. I would pick up the Elixir in Action programming book by Saša Jurić to supplement my understanding and be fortunate to befriend a senior Elixir backend engineer from my previous company who I could ask questions to (thank you Nathan!).
I wasn’t done with Javascript. Instead of using something like Godot or Unity and transitioning careers as a game developer, I wanted to leverage my experience of building web applications. The browser MMO needed to be performant on both mobile and desktop and be lightweight. The best option I found was the Phaser Javascript 2D game framework which had over 10 years of development being optimized for the web. I had tinkered with it previously, and it had enough longevity for LLMs to be trained on. Although the Phoenix web framework favors functional programming in Elixir and Phaser favors object-oriented programming in Javascript and Typescript, both are interoperable with each other. I could organize files with Typescript classes for the frontend and Elixir modules in the backend all in the same codebase. For the UI, I didn’t want to add another Javascript library like React just to render some plain HTML over the Phaser WebGL, so I used native Web APIs like document.createElement. For the scope of a turn-based trading card game with a 2D WebGL overworld using minimal HTML overlays, this was enough for the job.
Before AI, it was more typical to have a separate frontend and backend developer with a high level of expertise in their respective languages to work together. Now the seams between every layer in the stack were more porous and one generalist could act as several specialists. I would not say that an AI agent writing code that requires nuanced judgement performs as well as a human expert. But even in traditional software engineering, we sometimes favor speed over quality instead of letting perfection be the enemy of good. One developer doing acceptable work with multiple agents is superior to a team of developers who never ship anything by sweating over every line of code.
Like humans, a team of agent engineers need unified guidelines. From the beginning, I rarely handwrote code and let AI drive the feature work. Global AI context files loaded in every session like
CLAUDE.md
and AGENTS.md
were dropped. I wasn’t convinced that AI needed some predetermined context for every session, especially if the prompt was entirely unrelated to that context. If I trust my driver to drive my car to its destination, I don't think I need to keep telling them how to drive every time. Instead I selectively told AI how to write code under certain conditions. By creating markdown files under a rules folder, AI was guided on Typescript and Elixir best practices if it wrote code with their file extensions. For instance, I added a rule to avoid
innerHTML
because it was more susceptible to cross-site scripting attacks and preferred alternatives like
textContent
or innerText. The Phoenix web framework already came with Elixir guidelines I copy pasted into my rules. I mostly used two skills. One called
grill-me
popularized by Matt Pocock that questions the developer in multiple rounds until they achieve understanding of some concept. And another called
cleanup
that I made that targets code changes against the main branch for simplifications and deleting dead or redundant code. As the project matured I used
grill-me
less and cleanup
more because the latter was faster, spent less tokens, and gave more autonomy to the AI.
To maximize one engineer acting as a team, each agent team member needs to work without disrupting another. At the time Claude Code was my daily driver. I was initially very skeptical of its output during code review, especially for Elixir which I lacked expertise in. But over the months, the Opus models gradually improved, and I could not find any meaningful nitpicks in the code. At a certain point I realized the bottleneck of productive code contributions was not the AI but the limit of context switching I could handle. My workflow evolved from git branches to git worktrees so the LLM could confidently make changes in each session without tripping over itself if I wanted to pivot. This involved custom shell commands and git aliases to create new worktrees by copy pasting the Javascript and Elixir dependencies instead of waiting for fresh installs and opening new instances of VSCode to visually verify the changes. I saw a tweet on X from @MelkeyDev that developers who use complex workflows make them think they are gaining productivity when they’re not and that “all you need is a harness, and a good way to navigate git worktrees.” I entirely agree.
Using traditional software engineering best practices like limiting the scope of complexity per feature was still relevant for working with AI. Broadcasting realtime player movements required multiple pull request changes in both Typescript and Elixir. The initial pull request had the server broadcast to the client 10 times a second each moving player’s X and Y velocity. The client created a timestamp of when the server velocity was received and delayed rendering the movement so the client could catch up to the server and absorb lag. Imagine flipping through a flipbook but purposely slowing down while new pages are drawn so the animation continues.
Early implementation of broadcasting player movement
A separate pull request was created to include the art that I bought (credits to LimeZu ).
Broadcasting player movement with pixel art
Even if a developer could be a team, a team can make wrong decisions. There were drawbacks of relying solely on AI in a domain where I lacked expertise. Networking realtime multiplayer movements is notoriously difficult. Claude’s approach sounded great in theory and worked on my local computer where there was virtually zero latency. But it wasn’t until I deployed to production 2 months later I realized the game felt awful to move around. Phaser had the camera track its own player’s movement. But the artificial animation latency added with the real network latency of a player broadcasting their own velocity to a server and having it sent back to them caused a noticeable stutter every move. I scrambled to fix it. Decreasing the artificial animation latency and increasing the tick rate didn’t work. Vertically scaling to increase the CPU to see if that would change anything didn’t either. I spent days hitting Claude’s usage limits to have it solve the problem for me. But after multiple rounds of Claude confidently offering fixes that didn’t work, I was at a roadblock.
Just like how one engineer can fix the mistakes of another in traditional software engineering teams, I stopped letting AI drive the solution and took the steering wheel. After discussing with my senior backend engineer friend Nathan, he said
"The server can be driving the positions of players, especially other players, but your own character should probably be driven by the client. You want the least amount of latency for the player and their own character. It would be really annoying to have a character that was moving really poorly because of your own internet connection"
It was human feedback over AI recommendations that led to the correct solution. I had to rework the entire approach. The player’s own character would be client authoritative, no server is involved for a player to see their own character moving across the screen. However, the moving player would send their velocity to the server for other players to receive multiple times a second. These other users would see the player chase an invisible target, which was the most recent velocity the player sent to the server. Imagine a doppelganger that moves exactly as the original with some delay. The doppelganger tries to catch up to the original. The original is the invisible target, and all other users the player sees on their screen are doppelgangers. This technique is called dead reckoning from when ship navigators had to deduce their location using landmarks or positions from the stars. If latency or poor internet connection causes the invisible target to be too far behind the server updates, the doppelganger character is teleported to the last known location of the original. To guard against player abuse of client authoritative movement, clamp impossible velocities and positions.
With the correct architecture shaped by human opinion, AI could be an effective workhorse to fill the details. There are over 500 spritesheets for character customization. Instead of making over 500 HTTP requests to load all images simultaneously, I wanted to lazy load them on demand. I compressed the spritesheets using pngquant and converted the compression to .webp to reduce their size further until their total size was 3 MB. Then I concatenated all the images into a binary .bin file which is served from Cloudflare R2 to save bandwidth costs instead of serving them from the Fly virtual machine. As soon as the player enters the game, the .bin file is downloaded. If the player sees a character spritesheet they haven’t seen before, the image is selectively decoded from the .bin file. If they already have the image from the cache, decoding is skipped. The same concept applies for background game world art.
Lazy loading character images from a binary file
One developer being their own team meant being able to outsource research into a narrow field of expertise. With AI, I didn’t need to spend days fussing over Javascript typed arrays to read and write binary data. I still reviewed documentation to understand the flow, but the encoding and decoding scripts AI created could be treated as black boxes or external dependencies that just work. While creating the scripts, Phaser had a major update from version 3 to 4. Their docs stated that most people would update without issue unless they were creating custom WebGL pipelines, which was me. After updating, my game world looked like a jumble of broken jigsaw puzzles. I prompted Claude to fix the issue. It read the Phaser source code via the node modules and made the fix. It was related to how Phaser 4's WebGL texture upload now expects a bottom-left origin. If a human engineering team inexperienced in Phaser WebGL pipelines had to investigate the source code to debug, I am certain one developer with a team of agents would still debug faster.
Solving complex networking issues became streamlined with AI. I had two Fly machine servers, one located in Ashburn, Virginia USA and another in Tokyo, Japan. Each region was its own independent world. Players in Ashburn do not see players in Tokyo and vice-versa. Users geographically closer together didn’t have to broadcast their positions to servers on the other side of the world.
One shared world per independent region
However during testing on production, my implementation wasn’t working. By taking screenshots of browser devtools network requests for Claude, it reported the problem was related to Cloudflare. I was using Cloudflare proxy for DDoS protection, caching, and performance benefits for my website. With Cloudflare proxy enabled, the HTTP request flow is the user’s browser → Cloudflare → Fly.io’s machine server. This caused an issue where a user from South Korea would connect to the Cloudflare Hong Kong edge, which would redirect to Fly’s connection in Los Angeles where the closest server is in Ashburn instead of Tokyo. So a user from South Korea would connect to a server in Ashburn instead of a closer one in Tokyo.
The easy fix was to remove the Cloudflare proxy and switch to DNS only for the geolocation to work properly. However, this would sacrifice all security and performance benefits from Cloudflare. I researched the Cloudflare documentation and found they have an HTTP header called CF-IPCountry which contains a code for the user’s origin country. I prompted Claude if I could use this header with Fly to redirect the user to the closer server. Claude found a primitive called fly-replay that could route requests between servers in different regions. By adding a list of country codes for the server to check against CF-IPCountry, I could selectively intercept and reroute connections that landed in a server region different from the user’s origin country. So a user from South Korea that was redirected by Cloudflare and Fly to the Ashburn server would be rerouted to the closer Tokyo server. If the user’s country matched the server region, like an American user connecting to the Ashburn server, the extra network hop is entirely ignored. After creating two servers in different regions and testing on a VPN, I confirmed the solution.
I am uncertain if it would have been this easy had I prompted Claude without guidance. Researching documentation, understanding devtools, and core software engineering skills are still relevant with AI. Claude could have recommended the easy fix of turning off the Cloudflare proxy, it was one possibility of many. But I decided to not settle for less, and I think that makes all the difference.
After two-thirds of the year using Claude as my daily driver, I wanted to explore other models. I was getting skeptical of Claude’s vendor lock-in for my engineering team and tried other harnesses like Opencode and Cursor. Using Muse Spark 1.3 Free in Opencode on the extra high effort worked surprisingly well for pure Typescript related tasks, although I didn’t trust its output for the more complex and less trained Elixir code. The gamechanger was how well Cursor’s Grok 4.6 and 4.7 understood both Typescript and Elixir. Grok was not always as thorough as the latest Claude Opus or Fable models, but it was good enough and became my daily driver.
Up to now I mainly focused on the networking aspect of an MMO, and it was time to tackle the card game. I had prior experience with finite state machines in my previous company and thought it was well suited for a turn-based card game. By using the Model Context Protocol to connect my Notion document of the card game rules with Cursor, I prompted Grok to implement them into an Elixir finite state machine. Elixir uses the
:gen_statem
module from Erlang, its language predecessor from the 1980s, for finite state machines. Its usage is rare enough that experienced Elixir developers probably never have to use it. But with some research to create a guided prompt, I easily translated a concept into a working implementation without any practical experience in :gen_statem. Prior to AI, a human developer team implementing and fixing all the unforeseen consequences of timers and networking issues in a realtime card game would have taken weeks. With an AI team lead by one human engineer, I had a working implementation in days.
Card game using Elixir finite state machine
There were certain areas I restricted myself from using AI. I would not use AI for art. Another solo developer may have used AI art because they lacked expertise to create their own. But besides the general public sentiment against using AI as an artistic form of self-expression, I wanted to genuinely express my artistic vision, learn pixel art, and draw my own cards. Even if AI could do it faster or better, the best way to learn a craft is to spend time on it. For similar reasons, using AI for any creative writing related to the game was prohibited. The capabilities of AI are expanding, but like any tool it is limited by the decision making of the user. Making great products appreciated by other humans is as hard as it was before, and having all the capabilities of an engineering team at our fingertips doesn’t mean the end result is any better.
The next evolution of a developer being their own engineering team is to have a team of personal agents. The current trend is for each big AI company to make their own personal agent such as SpaceX’s Grok Bot, Meta’s Muse, OpenAI’s Dot, and whatever else comes next. But solo developers prefer the freedom of customization. My ideal workflow is to connect the open source Hermes agent with Discord and deploy it to some virtual private server to restrict file access and blast radius. Then use any model for Hermes to read files and contribute work, and have that work be done in a sandboxed server environment that can rollback and restore saved checkpoints if the agent makes mistakes. Ideally if a customer sends a screenshot of a bug report in Discord, the Hermes agent should scan the report and create a bug fix pull request for a human engineer to later review. The impact of one engineer is greater than ever before and both the floor and ceiling of software engineering have been raised. Despite what any frontier AI lab says about the death of software engineering, I believe the future is always unpredictable. I am excited by the potential of unpredictability.
It has nearly been one year since I started my journey to create a browser MMO trading card game with battlecitymmo.com. There is so much more I want to accomplish like adding more cards, a story mode, competitive rankings, trading, and payments. When I started, I thought I could accomplish all of these within a year. I overestimated myself. However, I did more with AI than I could ever have done without it. Without requiring a team of human engineers, I context switched between different engineering roles that were out of reach before. A single engineer can be a force multiplier now more than ever. We are only limited by the scope of our imagination.