benyoung.ai
← Back 2025 case study, PDF

Case study · Proof of Play to Grimnoth · 2025 to 2026

I owned the game. The company closed. So I rebuilt it.

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.

Act 1: Owned a ~$500K product, team of 2 Act 2: CC0 release after the wind-down Act 3: Rebuilt, 1,000+ merged PRs, in staging
Act 1 · 2025

Pirate Nation Arcade: the product I owned

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.

What I owned and built

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;
The leverage: my tooling turned unusable raw data into balanced content a two-person team could ship on a schedule.

The tooling, on screen

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.

A narrated tour of the PN Arcade Manager. Built solo, the system that let two people run the game.
Attract-mode gameplay from Pirate Nation Arcade, 2025.

The outcome

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.

~$500K
Revenue in the first few months
2
People running a live product
504
Commits in the content tooling I built solo

The original 2025 case study, as a PDF: pirate-arcade.pdf.

Act 2 · Summer 2026

The turn: the company closed and the art went CC0

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.

Act 3 · September 2026 onward

The rebuild

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.

What I designed

What I built

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;
One rule set, two consumers. The green boxes are the parts I design and build; the server, not the client, decides who won.

How AI fit in

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.

The product, in motion

Eighty seconds of the rebuild, in staging: set sail, pick a fight, play the hand, take the spoils, sail again. Every card on the table is one I designed; every number is the shared rule set doing its work.
In staging now. Free to play in the browser once it is public; the pirate collection is optional. Ask me for a walkthrough in the meantime.

By the numbers

2,055
Commits under my name since 2026-09-21
1,086
Merged pull requests in that window
6,969
Pirates kept, from 9,999, by a tool I built
1
Combat rule set, shared by server and client
3
People. No studio, no payroll.
Staging
Live in a staging environment, October 2026. Public release next.
Act 1 proves I can own a revenue product and build the tooling that lets a tiny team run it. Act 3 proves I can design a game and direct its rebuild from the rules up. The same person did both, which is the point. Happy to walk through the combat rules, the economy, or the content pipeline in a conversation.