How I turned a viral offline hit into a scalable live service in 2 days of background prompting

This week, you might have seen a little football game called 38-0 go viral. I loved it, played it to death, and started dreaming of a multiplayer version. Lucky, then, that the timing was perfect: we're rolling out the public preview of the Metaplay Agent right now, which lets you build an online game backend, complete with a full metagame and LiveOps featureset, just by prompting. Two days and two overnight runs later, I had turned an offline hit into a scalable live service. Here's how.

The bet: A viral toy, a day job, and the new Metaplay Agent

If you haven't played 38-0: it hands you a random draft of footballers, you pick an XI, and a simulated season tells you whether your team can go all 38 games unbeaten. Two minutes, enormously shareable, and beautifully Champ Man 2004. The players hit every nostalgia sweet-spot going (David Healy bagging 35 goals for my team of nobodies, anyone?). And once the season ends, that's it. No account, no friend you're beating, no reason to come back tomorrow.

So I made myself a deal. I would keep doing my day job, and the Metaplay Agent would build the online version: a private league where up to 20 friends draft from one shared player pool and a season plays out over real weeks, with an economy and the LiveOps tooling to run it as a service. My contribution would be prompts written between meetings and before bed. If the agent needed me watching over its shoulder, the experiment failed. (Of course, given that we're still talking real team and player names here, I should add that this was an independent project all in the spirit of editorial, with no intention to commercialise anything nor produce anything 'official' or licensed).

This had to run in the browser, because the whole point is following a link from a group chat. Metaplay games are usually built with Unity, but the backend and game logic are plain C#, so the agent built the client in Blazor WebAssembly instead, meaning the same game logic compiles for the server and the browser. (I was building on a preview branch of our upcoming SDK release that bakes the web support in – stay tuned to get your hands on that in the coming months, or, because Metaplay ships as source code, you can download the SDK and extend it yourself in the meantime.)

Day one: A playable multiplayer game by the evening

Before the first prompt, I needed two things: somewhere to run the game and something to build it with.

Getting set up with Metaplay Cloud, Claude Code & the Metaplay CLI

The somewhere was Metaplay's managed cloud, and getting it ready was the only setup I did outside the coding harness all build. I created an account and an organisation in the Metaplay portal, spun up a new project, and took the Starter plan at €195 a month. That came with a hosted cloud environment I could deploy to and play online straight away – no infrastructure to stand up, nothing to babysit. Once the portal project existed, I linked it to my game project directly from the Metaplay CLI, and from there everything stayed in the harness. For something meant to be built between meetings, managed services were the whole reason it could move this quickly.

The something was Claude Code, with the Metaplay CLI installed into it – installing the CLI is how the Metaplay Agent lands in the harness. Day one ran on Opus 4.8; Fable shipped overnight, so day two ran on that, and the agent rode on top of whichever model I had loaded.

The morning prompts were the bones of the game, and the agent worked through them while I sat in meetings.

Building a server-side spin-the-wheel draft system & adding multiplayer

The draft came first: a corpus of legends, formations, and a pure draft engine with unit tests, with the spin mechanic wired so the random roll happens server-side. That made it cheat-proof from the first commit, because a client you can't trust is the default assumption in Metaplay's model.

Next came the match engine, a deterministic XI-vs-XI sim that turns two teams' ratings and a seed into timed goals.

Last came the bit I (and my friends) had actually been daydreaming about, the 20-manager league. Invite codes, a turn-based snake draft from one shared pool (yes, that means only one of you can have David Bentley), a double round-robin fixture engine, and a live standings table.

It was all so easy. But what still took me by surprise was just how much checking the agent does before it claims anything. It runs the unit suite, boots the actual game server, then plays the real game in a headless browser, creating leagues, drafting squads and simulating seasons, before telling me a feature works.

By dinner I could create a league on my phone, have a second browser join it with the code, draft against myself and watch a season resolve. Later that night I shared it with my friends and we started a joint league.

The first overnight run: 23,913 rows of data into a configurable spreadsheet

Overnight, I pointed the agent at a squad dataset and woke up to spin-the-wheel drafting from 23,913 real player-seasons, 1992 to 2024, deduplicated so each footballer can only be on one team per league.

The part that mattered wasn't the volume, though. The agent had landed every one of those players as rows in a Google Sheet that builds into the game's configs (that's the real sheet, open to view). Names, clubs, seasons, positions, ratings: all of it sits in a spreadsheet a designer can edit, not in code. Want 2003/04 Henry a touch stronger? Change a cell, and re-publish the latest config in the Metaplay LiveOps Dashboard. That one structural decision set up everything that happened on day two.

Day two: Building the LiveOps foundations

Now I had the base setup, the focus for day two was building the game into more of a live service, with more of a meta and more borrowed characteristics and features from top-grossing titles.

To that end, the morning brief extended what the overnight run started: get every remaining tunable out of the code and into the config sheet.

Adding the first LiveOps building blocks

League size, the daily sim time, transfer rules, quest definitions and formations all got added to the sheet configs, with publishing wired to a button on the pre-built Metaplay LiveOps Dashboard. In imagining how operators would run the game as an actual live service, I tasked the agent with building out more dashboard features - for example, the 'Season Leagues' view in the dashboard lists every running league, with controls to force-advance a matchday, open or close a transfer window, or grant currency to a player.

Layering a deeper meta for better retention and monetization

Then came the retention basics. Login streaks, an in-game inbox fed from the dashboard, and scheduled LiveOps events like a weekend Coin Rush that multiplies earnings.

Mid-afternoon I changed the transfer-window hours in the sheet, hit publish on the dashboard, and watched a league that real friends were already playing in pick up the new rules while the server kept running. No deploy, no app store review, about forty seconds all told.

Fixing the game economy and adding more ways to spend

With friends now mid-season, the gaps showed. Coins existed but bought nothing meaningful. Gems had no use at all. Three thin quests ran out in a day. So the afternoon prompt was the most fun one to write, something along the lines of: "Review the meta like a game lead at a top-grossing casual game would do – make the currency meaningful and ensure the meta is one smooth, interconnected system." (Yes, really that loose.)

Somehow the result was a proper economy. Coins became transfer money: every matchday, quest, streak and pass tier pays them, and signing a better player costs coins scaled to his rating, so a daily player affords roughly one signing a day. Gems became the indulgences. They buy a guaranteed top-tier club spin during the draft, a marquee signing, a quest reroll, or the premium pass track. The quest book grew to 14, split between daily quests and season-long arcs across all 38 matchdays, and the whole thing got a persistent currency HUD and a full-screen transfer market. All of it config, all of it in the sheet, all of it rebalanceable from the dashboard.

Staying hands-off and letting Metaplay Agent build autonomously

Again, this was all built autonomously, and I literally didn't know about it until long after it had been designed, implemented, and tested. The agent reported hiccups along the way – for example by how it dealt with transfer fees – but fixed them itself, and I didn't even need to get involved. (To go a bit deeper into that: a transfer fee has to be charged the moment you confirm a signing, otherwise a hacked client just skips the payment. But the league lives in a different server entity, and that entity might still reject the swap. The agent worked this out by itself, charging first and refunding by server action if the league says no, with tests proving both paths.)

The second overnight run: The polish list

That evening I played a full season and went to bed having sent the agent some feedback: a broken ribbon in the shop UI, "the season pass explains nothing", and a note about match results appearing out of nowhere, so could we get a playing-the-match screen with the goals going in as they happen?

I woke up to a ticking match clock revealing goals minute by minute, with a full-time screen showing the rewards land. Along the way the agent had found and fixed a real bug, because the server endpoint for playing a matchday had never actually returned your scoreline.

The last morning: shipping it

The final session was wrap-up, and the prep for writing this and sharing the journey. The build went to the cloud, the config sheet was published, and the whole project went public at metaplay-shared/footdraft under Apache 2.0, so you can see every prompt's worth of output for yourself.

Why background prompting worked here

Over the two days my prompts were ridiculously vague. No 'you are an X', no guardrails, yes 'please do as much implementation as you can and test as you go and stop to tell me or ask me anything unless you really have to'. I had to make some design decisions, but even then not many – the Metaplay SDK has the bones and the infrastructure for building any kind of meta, and the implementation specifics I borrowed from the market (again one-shotted, as outlined above).

Great results with very little effort

Yes, the game is rough around the edges – and will be broken in parts I haven't discovered yet, I'm sure, but I'm still astounded at what the agent's been able to produce with really very little human effort or intervention. With real intent, and if I didn't have a day-job dedicated to trying to get you to buy the thing rather than play around with it myself, I'd marvel at the possibilities of what could be produced, verified, and implemented. Especially when it's the hand of a real coder or someone with actual engineering chops.

If I take my Metaplay goggles off for a moment and look at the possibilities here from the perspective of a neutral observer who's worked in the games industry for a decade and has been experimenting deeply with AI since vibe coding first became a thing, the Metaplay Agent really is impressive. And it makes sense as to why: Metaplay already had all of the building blocks for top-tier live service game development: server authority, state persistence, config publishing, a fully-customizable game control panel, in-built online and social features, and a ready-to-go cloud infra setup, to name a few. Everything I added to this game came from the Metaplay SDK rather than being built from scratch, and that's the kind of stuff that would normally eat the first year of a live-service project.

In short, the Metaplay Agent is fast and good because it's assembling from a purpose-built live service game backend platform it already knows deeply. Give your AI a pile of undocumented backend services and it will be exactly as miserable as you would be. Give it a smooth, vertically integrated system like Metaplay's, and you're laughing.

My take on what this means for game studios

Standing up a live-service game used to be a year of backend plumbing before you reached the fun part. I am not a coder, and I built a fully configurable one, economy and all, in two days of prompting between meetings. The kind of top-tier game development that used to need a full team is now in reach of almost anyone, as long as they have a clear vision of what they want to build, and some idea of the piping that would need to go into it to bring it to life. For the industry that's a big deal: every studio becomes a place where the results of a brainstorm can be a playable service by the weekend.

There's an obvious catch. If anyone can build anything, does quality go out the window? Over two days I never shipped something broken by design, and I think that's down to the Metaplay Agent having been built on the backbones of years of experience working tightly with the likes of Supercell, Metacore, Trailmix, Lessmore, and others, serving millions of players a day. That history and those learnings have compounded, and are baked into how Metaplay Agent works: it holds a quality bar and won't drop below it. That bar holds whether you're hammering away at the keyboard, or fast asleep in bed.

Bringing it back to football, in the same way the hallmark of a good referee is not noticing they're there in the first place, a clear proof-point of the quality of the Metaplay Agent was that I didn't even realise it was fixing itself as it went, reviewing its own work and testing as it built, start to finish.

A watershed moment for forward-thinking game studios

The handful of people who start doing this now get a genuine head start. You could already vibe code a game; now you can vibe code an actually good one – the social features, the economy, the LiveOps controls of a top-grossing title – in the time it used to take to wire up a login screen.

If you write backend code for a living, I think what you get is trust and confidence. You're not throwing the hard or boring parts over a wall to some flaky tool and hoping. It's closer to handing them to a very senior server engineer who gets it done and doesn't pester you. I reckon that counts for a lot.

If you run a game or a studio, I think there are huge wins to be made in incorporating these kinds of high-end agentic workflows into how the team operates. You stop putting people on grunt work like wiring up automated tests, because the Metaplay Agent can now do that itself. Your team gets to turn their attention to growing the game instead – playing modes of attack rather than modes of defence, shipping features faster to push retention, LTV and monetisation, trusting that what's underneath them holds. Done right, that quickly turns into increased momentum, faster shipping, and more revenue.

And if I were in a studio founder's seat, I'd be getting the Metaplay Agent into as many hands on the team as I could, and encouraging them to go wild with it. Watch what they build from scratch, and watch what they bolt onto the games you already run – new features, faster code review, their own automations and reporting. The more your team grasps what the agent can do, the more they build, and the more potential they uncover going forward. I don't think it's an exaggeration to say that this really is a game-changer.

Play it, read it, fork it

The game is live. Grab some friends and start a league, then go and check the repo and the config sheet linked above to see how any of it works. If you want to try this way of working on your own game, the Metaplay Agent ships with the SDK, and if you'd like a walkthrough first, book a demo and we'll show you a league mid-season.

Links mentioned

• Play 38-0-20 – the live game, in your browser
• metaplay-shared/footdraft – the full source code, Apache 2.0
• The game config sheet – every legend, formation, league rule and quest, open to view
• 38-0 – the original that started this
• Set up the Metaplay Agent – install guide in the Metaplay docs
• Get the Metaplay SDK – downloads and getting started
• Metaplay CLI – the command-line tool used to run and deploy the project
• Metaplay documentation – everything else
• Talk to us – we'd love to hear about what you're working on