2025 · Pirate Nation ArcadeCase study · Proof of Play to Grimnoth · 2025 to 2026
One story in three acts. Pirate Nation Arcade was a revenue product I owned end to end at Proof of Play. When the company wound down and released the art as CC0, I rebuilt the game from the ground up: the cards, the combat rules, the economy, and the tooling to run it. A thousand merged pull requests later, it is live in a staging environment, ahead of a public release.
Proof of Play wanted to spin its flagship IP, Pirate Nation, into a standalone arcade product on the Abstract chain, fast and lean, as an experiment. The bet only worked if a very small team could stand it up and keep it fed with content. There was no budget for a full studio.
The hard part was the content. The game's data lived in an EAV schema (entity-attribute-value): properties scattered across thousands of rows, effectively unqueryable, and impossible to balance by hand. Authoring waves, enemies, decks, and cards by reading raw rows would have been slow and error-prone, exactly the bottleneck that sinks lean teams.
I owned the product end to end: scope, content, and operations. I personally built the content and analytics tooling that made a two-person team viable. The core was a pipeline that parsed the intractable EAV data into clean, hierarchical structures fit for analysis and balancing, plus a data viewer that let me inspect and tune content directly.
And the content itself was mine. I designed the cards, the enemies, the decks, the wave progression, and the meta the tool surfaces. So I sat on both sides of it: the designer deciding what should exist, and the engineer who built the system to author, inspect, and balance it.
flowchart LR EAV["Pirate Nation data
intractable EAV schema"]:::raw --> TOOL["Content pipeline I built
parse · structure · validate"]:::mine TOOL --> BAL["Balanceable content
waves · enemies · decks · cards"]:::mid BAL --> GAME["Live arcade game
owned + operated by 2"]:::good classDef raw fill:#fee2e2,stroke:#dc2626,color:#7f1d1d; classDef mine fill:#dcfce7,stroke:#16a34a,color:#14532d; classDef mid fill:#eef2ff,stroke:#6366f1,color:#1e1b4b; classDef good fill:#dbeafe,stroke:#2563eb,color:#0b3a8f;
This is the PN Arcade Manager I built, narrated in my own voice. It inspects every card, enemy, deck, and wave, computes drop odds and average damage per turn, calculates leaderboard reward payouts to player wallets, diffs test-net against production, and reads full battle logs to spot broken strategies.
The Arcade generated roughly half a million dollars in its first few months, run by two people. The point is not the headline number, it is the shape of it: a real revenue product, owned and operated by a team small enough to fit in a sentence, because the unglamorous work, wrangling data into shippable content, was solved once in tooling instead of paid for over and over in labor.
The original 2025 case study, as a PDF: pirate-arcade.pdf.
In mid-2026 Proof of Play wound down. The games had made money, but the company closed. The Arcade went dark with it. What did not go dark was the community in the Telegram group, or the art: Proof of Play released the Pirate Nation art under CC0, free for anyone to reuse.
That is a rare situation. A game I had owned and operated, whose content I had designed, whose tooling I had built, whose players I knew, suddenly had no owner and no legal barrier to a second life. The question was whether to let it end, or to treat the wind-down as the start of act three.
The decision. Rebuild it, properly this time. No studio, no payroll. Me on the game, a very small crew around it, and a set of AI agents, with me directing the game design, the content, and the build of everything on the game side.
The first job was not code. It was curation. The original collection was 9,999 Founder's Pirates. I built a swipe tool (think Tinder for pirates) so reviewers could cull trait slices collection-wide, vote on survivors, and hand-trim the rest. Every one of the seventy pages got a human review. We landed on exactly 6,969: duplicates and weak designs out, the rare and the memorable kept.
The rebuilt game is a pirate card battler in the Slay the Spire family: build a deck, fight escalating battles, take real risk for real reward. It keeps the IP and the feel of the Arcade and replaces everything underneath. It runs in a staging environment today, ahead of a public release under a new name.
The rebuilt platform has one shared combat-rules library, dependency-free and compiled byte-identically for the server-side C# runtime and the Unity 6 client. The server owns the fight: it validates every command, advances the opponents, checkpoints the run, and emits the canonical result. The client is untrusted for anything that touches score, rewards, or randomness. That boundary is what makes a competitive card game honest, and it is where most of my combat and rules commits live.
Around the rules sit the things a live card game needs every day: the content pipeline that compiles cards and decks into a release, the card-face renderer, the rewards logic, the deck tooling, and a test suite that exercises the rules with every change. The retired chain, wallet, and indexer systems from the original were cut, not carried.
flowchart LR RULES["Combat rules library
deterministic · shared"]:::mine --> RT["Authoritative runtime (C#)
owns the fight, checkpoints runs"]:::mid RULES --> UC["Unity 6 client
untrusted for score + rewards"]:::mid CONTENT["Cards · decks · faces
content pipeline"]:::mine --> RT CONTENT --> UC RT --> API["Backend (TypeScript + Postgres)
identity · admission · results"]:::good classDef mine fill:#dcfce7,stroke:#16a34a,color:#14532d; classDef mid fill:#eef2ff,stroke:#6366f1,color:#1e1b4b; classDef good fill:#dbeafe,stroke:#2563eb,color:#0b3a8f;
I did not write most of the lines. I wrote the design, the acceptance criteria, and the review. Agents build in slices, each slice is reviewed by a model from a different family before it can land, and I judge what ships. The commit log under my name is the receipt: just over two thousand commits and more than a thousand merged pull requests between the third week of September and today, across card design, card art, combat, rules, content, decks, rewards, and tests.
That is the product-and-engineering blend in practice. Knowing what a card should feel like is a design question. Knowing why the fight must be deterministic and server-owned is an engineering question. Being able to hold both, and direct a build that honors both, is the whole job.