I built a multiplayer NetHack clone over Labor Day weekend.

The subscriptions are still generous with tokens, so while I have to be careful at work where we pay full token cost, I’ve wanted a weekend project where I can truly go all out and see what it looks like to make a video game end to end with coding agents built to execute tasks in parallel. So on Saturday at two in the afternoon I typed a long prompt describing what I wanted. Monday evening a 300 hit point test priest walked all 5 dungeons, driven by the same agent that had built them. In between I mostly wrote cards, read reports, and slept.

The working title is Hollowdeep. The pitch I gave Claude was a mashup: NetHack movement and turns, Baldur’s Gate companions who join your party, a Zelda style overworld with dungeons as the reason to go places, Shadowdark for the rules, and Draw Steel for the non-combat encounters. Negotiations with an Interest and Patience track, montage tests, respites. NPCs voiced by a language model but adjudicated by the engine, so the model can improvise a line and never change a number.

What I was actually practicing

I want to be clear about what this was and wasn’t. It is not a game design or art project. Every mechanic is ripped off from a game I love, and every piece of art came out of a generative model. I leaned on the absorbed learnings of the models, so I don’t consider anything here my design. If you want to see the ideas done properly, go play Shadowdark and Draw Steel, or check out demos from an indie game design jam.

What I was practicing was the harness. How you structure tasks so that agents can operate in parallel, check each other, and keep going when I’m not in the chair. That’s the skill I wanted give a shot, and a game is a fun place to practice it because the feedback is immediate. Either I can walk into the goblin camp or I can’t.

A kanban board the agents can read

There are many ways to interact with AI agents, but I went for something familiar: a kanban board. The board is a folder of markdown files, one per card, describing a task I’ve given the agent or a cleanup or debugging task the agents have found for themselves. A little studio app renders them as columns in the browser so i can understand them as a human, but because they’re files, Claude Code can read and edit the board’s cards from the terminal.

The board on Monday morning. Every card is a markdown file, and every column move is a git commit.

On top of that sits a Claude Code skill I called board-run. It plays orchestrator. It reads each Ready card, writes numbered success criteria that a tester could check, cuts a git worktree and a branch for the card, and dispatches a subagent to build it. When the implementer reports back, a second subagent on a cheaper model merges the code into the main branch and runs static and live re-tests against the success criteria. Over the weekend that skill dispatched 364 implementer runs and 302 tester runs, merged 135 cards, and at its peak on Monday morning had 15 worktrees building at once.

It wasn’t smooth. But this run generated a data trail I can use to refine the process and consider what to do differently next time.

Graphics and 3D Models from a sentence

Again, this wasn’t an art project, but I did want a 3d GUI for the game. The art pipeline for this game was quick and dirty and got the job done almost entirely hands-off from me. The look is low poly, toon shaded, thick black outlines, with 2D textures as flat vector. Each creature already has a YAML file with a bio, a color, and tags, so the concept prompt is written from that file rather than invented.

The model catalogue. Concept on the right, normalized 3,000 triangle GLB on the left, same toon shader as the primitive shapes it replaced.

The generation of art assets runs on Replicate , my favorite commerical and open source gen ai model aggregator. A concept image through nano-banana costs about three cents. Image to 3D through TRELLIS costs another three cents and takes half a minute. Rodin costs forty cents and gives much cleaner topology, all told I spent $6.98 generating assets for the project.

The zone browser in the studio. This is the ice cave an agent built at midnight while I was asleep.

Two questions for the big model

Most of the cards went to Opus 5, which is a very good implementer. The orchestrator ran on Fable 5.1, and a couple of times I stopped feeding it cards and gave it a real engineering question instead.

The first was optimizing the network protocol for sharing updates with clients to reduce network traffic when the server is handling multiple players. The changed achieved a 13X drop in network usage with 20 players and a 20X drop at 50 compared to the first implementation, also reducing the heap usage of the server process.

The second tough question was whether to implement per zone processes sharding. The recommendation I got was not yet, given I needed to tune the protocol first and then decide the right places to shard later when the game is built out (zone based MMOs are easy to shard), which makes a lot of sense given this project is going to sit idle with no players for most of it’s future.

Turn based, together

I went turn based in multiplayer, which is atypical, and I’m glad I did because the design that fell out is the most interesting thing in the codebase. Players in a zone get grouped by presence: within 12 tiles of each other, or in the same room, or targeted by the same monster. Each group has its own clock and its own pacing. Alone with no monsters aware of you, your move resolves the instant the server gets it, exactly like NetHack. Two or more of you together and the group advances on a beat: 400 milliseconds, or sooner once everyone has acted. A fight puts everybody in one initiative order with a five second turn timer that resolves as defend if you walk away from the keyboard.

This isn’t a fully new concept. Agentic research on MUDS and Nethack clones looked at design choices in games like Angband, where the answer was a real-time tick that players describe as blitz chess, and later “time bubbles” that slow the world around a wounded player. Presence groups are the same idea generalized: the zone partitions into as many bubbles as there are clusters of players who can affect each other. Two people at opposite ends of a dungeon never pace each other. One can sit in a ninety second negotiation while the other explores at full speed.

Brak the Toll-Ogre. Interest and Patience straight out of Draw Steel. What you type gets classified, the engine decides, the model gives him a voice.

The story is per player and the dungeon is shared. Brak guards the toll gate for every party that comes through, alive and bored for the next group even if the last one killed him, while the rats and goblins between the story beats are one shared population that refills over time. There’s global chat, a leaderboard of the top twenty characters on the login screen, and you can explore the same level as a friend without stepping on their story. It is true MUD style multiplayer.

I’ll be honest that the UI for all this is rough. There’s a lot of rubber banding when groups merge and split, and the beat indicator is a tiny chip in the corner that nobody would understand without being told. The plumbing is right. The feel isn’t yet.

A montage test at the goblin camp gate. Two successes before three failures, and every obstacle is a line the party has to talk past.

The bill

I keep a small tracker that reads my Claude Code logs and prices every token at list. Each cell below is a token count and what it would cost at sticker price. Input is what went up to the model fresh, including the first write of each context into the cache. Cache reads are the same context read back on later turns at a tenth of the input price. Output is what the models actually wrote.

I didn’t pay $2,580. This is the $4 Uber ride again: a personal $200/month subscription. Assuming this burn 75% of my weekly limit on Claude Max, this cost me: $34.60 tokens + $6.98 replicate = $41.58.

Building while I slept

Spend per hour. Dark is the orchestrator, red is the workers. The shaded block on Sunday night is the run that kept going after I went to bed.

The part I actually set out to learn was the overnight run. With the main engine built by Sunday evening, I was able to make some general cards for expanding the game to 5th level and have a large amount of development done overnight.

The Red Under the Ice, built and placed at midnight. Its first breath took my 307 hit point test priest to 1.

At this point the game has been played by an AI test player, but not a human. There isn’t a lot of balance in the level design, so I’ll have to get good before I see all the content.

Where this leaves me

I had fun. I’m curious to try this again now that I’ve had this experience. I imagine with some more organization, I can make a cleaner design doc upfront that will lend itself to automated level generation and a more statistically balanced game. We’ll see, maybe I’ll try a different genre of game next time.