Say "Make Me a Game" in Claude — and Get a Real, Playable Game, Not a Code Dump

Go Bananas now speaks MCP: create, edit, remix, and publish multiplayer browser games from inside Claude, ChatGPT, or Cursor — then share them with a link or QR code, without leaving the chat.

What if you could create a multiplayer browser game without leaving your AI chat? Not "describe a game and get code you have to deploy somewhere." Actually playable. Shareable. With a QR code your friend can scan to join.

We spent the last month wiring Go Bananas into Claude, ChatGPT, and every other AI that speaks the Model Context Protocol. The result is strange: you're having a conversation, and then suddenly there's a game. No tab switching. No copy-paste. No "here's some code, good luck."

Quick context, because the rest only makes sense with it: Go Bananas is a platform where you type a game idea in plain English and an AI builds the whole thing in 15–30 seconds. It runs in any browser, and anyone can play it — free, no signup: play one now. Every game automatically gets a cross-player leaderboard, a full audio engine, and multiplayer rooms friends can join with a link or QR code — and any published game can be remixed, with credit flowing back to the original. (Here's the full story of the platform.)

This isn't a technical achievement post. It's an argument about distribution.

The Demo Nobody Asked For

Here's what it looks like in Claude:

You: "Show me what's trending on Go Bananas this week."

Claude calls trending_games. Back comes a list — say, a space shooter with a few thousand plays.

You: "Remix that one but make it underwater. Jellyfish instead of asteroids. Submarine controls."

Claude calls remix_game, then edit_game. Thirty seconds pass. A link appears.

You: "Add sound effects and a high-score leaderboard."

Another edit_game. The game updates in place.

You: "Make it two-player — a submarine each."

One more edit. Multiplayer is a platform primitive — shareable room codes, up to 16 players, no server code — so this is a one-sentence change, not a rewrite.

You: "Publish it and give me a QR code to share."

publish_game flips your private draft public — searchable, remixable by others. Then get_share_link: the game's screenshot and a QR code render right there in the chat. Your friend scans it, joins the room, and you're both dodging jellyfish.

Total time: under three minutes. Zero installation. You never opened a browser tab.

*▶ Want to feel the end product first? Play Goat Kart Racing, a 4-player game on the platform — free, no signup: gobananas.co/game/goat-kart*

Already Made a Game in a Claude Artifact?

Here's the part nobody expects: if Claude has already built you a game in an artifact, you don't need to regenerate anything. Say "import this game to Go Bananas" and the import_game tool deploys your HTML byte-for-byte — free, zero tokens, no AI rewriting pass (a chunked variant handles games up to ~900KB). Thirty seconds later your artifact has a real URL that unfurls with its own screenshot, a QR code, and a home where strangers can find and remix it. Your game stops dying in the chat scrollback and starts collecting players.

That's this post's whole argument compressed into one tool: the AI already makes games. What games need is somewhere to live.

What "a Game" Means Here

Claude can write you game code anywhere. The difference is what the code lands on. Every game on Go Bananas ships with platform superpowers, no extra code required:

A real URL that unfurls with the game's own screenshot, plus a QR code
A cross-player leaderboard — one call, window.__leaderboard.gameOver(score), and your friends are competing
Drop-in multiplayer — rooms with join codes, up to 16 players, turn-based or real-time
Sound — an audio engine with positional 3D audio and a bundled sound-effects pack
Version history — every chat edit is saved; restore any earlier version
A remix graph — anyone can fork your published game, with permanent attribution back to you

An artifact is a demo. This is a game other people play.

What Is MCP, and Why Should You Care?

Model Context Protocol is Anthropic's answer to a simple question: how do you give an AI access to the outside world without building a custom integration for every platform?

The old model: every company builds a ChatGPT plugin, a Claude integration, a Cursor extension — three codebases doing the same thing. The MCP model: you build one server that speaks a standard protocol, and every AI client that supports it can connect. One codebase, infinite distribution.

For non-technical readers: think of MCP as a universal adapter. Your toaster doesn't need a different plug for every outlet brand. MCP is the outlet standard for AI.

The protocol defines tools (functions the AI can call), resources (data it can read), and prompts (one-click conversation starters); the AI decides when to use them. But what makes it interesting isn't the protocol. It's the distribution model hiding inside it.

The Distribution Argument

The old mental model: game platforms are destinations. You go to Steam. You go to the App Store. Discovery happens on the platform.

The new mental model: game platforms are capabilities. They live wherever you already are, and discovery happens in conversation.

That's the contrarian take: MCP is not primarily a developer convenience. It's a distribution channel disguised as a protocol.

Think about where attention lives right now. People spend hours in Claude, in ChatGPT, in AI coding editors like Cursor. These aren't just tools — they're environments, and environments accumulate habits. If our platform is reachable where you already spend your time, distribution is solved: you're in the chat, and suddenly the platform is there.

It's the browser-wars logic applied to AI interfaces — in the '90s, whoever shipped the default browser decided which sites won. MCP lets us show up in every environment simultaneously. Go Bananas as a standalone website competes with every other website. Go Bananas as an MCP connector competes with nothing. There's no other game platform inside your Claude chat.

The Technical Shape

Go Bananas is one Node.js server, and the MCP integration is just another door into it — the same process that serves the website answers requests at /mcp. Each request is handled statelessly and authenticated by its OAuth token: no session to hijack, no cross-request state to corrupt, nothing separate to deploy.

Connecting works like "Sign in with Google." Click Connect in Claude's settings, log in on Go Bananas, click Allow — and the AI gets a revocable permission slip to act as you. You never paste an API key, and you never type a password into a chat window. (For the protocol-curious: OAuth 2.1 with PKCE. Tokens are stored hashed, /mcp is rate-limited per IP, and every write tool checks ownership.)

The server exposes 46 tools — effectively the entire website made callable from a sentence. A connected AI can build a game from a description (create_game) and keep editing it conversationally, or kick off generation in the background and check back; import a game you already built in the chat, for free; remix anything on the platform; search, browse trending, pull personalized recommendations; comment, follow creators, read your notifications; check your play stats and per-game analytics; upload art straight from the chat, and get an upload link for music and 3D models; hand off to the visual editor; and hand you a share link, a QR code, or an exported copy that runs offline.

Each tool has a description the AI reads to decide when to use it. The AI never sees the implementation — just the interface. You're building an API for a reader that can infer intent. Here's an excerpt from the real description for create_game:

Create a new browser game from a text description. [...] Generation takes 15-30 seconds. [...] If complete game HTML ALREADY EXISTS (e.g., built as an artifact/canvas in this chat, or pasted by the user), use import_game instead — it uploads the exact code for free; create_game would regenerate a DIFFERENT game and spend tokens.

That's not documentation for humans — it's written for a machine that decides, mid-conversation, which door to walk through. Building an MCP server turns out to be half engineering, half technical writing for an audience of AIs; when the writing is good, the AI does the right thing without being told.

The Remix Graph

Every game published through MCP feeds back into the platform. It becomes searchable; other users — human or AI — can find it, play it, remix it. (Until you say "publish," everything you create stays a private draft. When an AI is acting on your behalf, that's a feature, not a footnote.)

The remix_game tool doesn't just copy code. A straight clone is free — zero tokens — and it creates a link in the remix graph: your underwater shooter stays permanently connected to the space shooter it came from, and the original creator gets notified.

This creates a flywheel: more AI-created games mean more starting points for other AI-created games. And here's the part that feels slightly unfair: the AI is good at this — it can browse what's trending, see what works, and synthesize variations faster than any human.

The network isn't just growing. It's evolving.

The Numbers

15–30 seconds from prompt to playable game
150,000 free tokens with every new account (75K at signup, 75K after your first game); a typical game costs 5K–15K — roughly 10–20 games on the house
Always free: playing and sharing games, importing games your AI already built, and straight-clone remixes of anything published
46 tools, one endpoint: https://gobananas.co/mcp — works today in claude.ai, Claude Code, Cursor, and Windsurf, with ChatGPT as OpenAI rolls out MCP connector support
Zero installation — your AI subscription covers the conversation; Go Bananas covers hosting, multiplayer, and leaderboards

How to Try It

Fastest (ten seconds, no account): open gobananas.co/game/zombie and play a game built on the platform (here's how it was made). Everything you create from chat ships exactly like this.

From your AI (three minutes):

In Claude: Settings → Connectors → "Add custom connector" → paste https://gobananas.co/mcp. That's the entire setup — no API key, no developer account. (Claude Code takes one command; gobananas.co/connect has copy-paste instructions for every client.)
Click Connect and log in — the connector requires a Go Bananas account. Don't have one yet? The login page links straight to free signup (tokens included); create your account, come back, and sign in.
Type: "Show me what's trending on Go Bananas" — or open Claude's prompt picker and click a starter like create-first-game or remix-challenge.

The people you share with never need an account: on the website, games are free to play — no download, no signup. Your game is a link; the link just works.

What's Next

Today, the integration is 46 tools, four one-click prompt starters, and a built-in platform guide the AI reads to teach itself how everything works — Go Bananas literally onboards the AI. Screenshots and QR codes already render inline in the chat.

What's next is wilder. MCP supports "apps" — interactive elements inside the chat interface. Imagine a playable embed of your game right in the conversation, where the line between "chatting with an AI" and "using a game editor" disappears.

Every new client that adopts the protocol is a distribution channel that opens automatically, with zero new code from us. The endgame isn't "Go Bananas works in Claude." It's "Go Bananas works everywhere AI works." And AI is starting to work everywhere.

The Bet

The bet we're making is simple: creative tools will be consumed through AI interfaces.

Not because AI interfaces are better. Because AI interfaces are where attention is moving. And attention is the only resource that matters for distribution.

MCP is the plumbing that makes this possible. It's boring in the way that HTTP is boring — a protocol that disappears into the background while enabling everything built on top of it.

If we're right, game platforms that integrate early will be the defaults when someone says "make me a game" in their AI chat, and everyone else will be fighting for the leftover traffic. If we're wrong, we've built a nice developer tool that a few enthusiasts will use.

The asymmetry is what makes it worth doing.

*▶ Play Zombie Files now — free, no signup: gobananas.co/game/zombie*

▶ Make your own at gobananas.co — describe it in a sentence, play it in about half a minute. A free account comes with 150K AI tokens: roughly 10–20 games on the house. Or connect your AI at gobananas.co/connect and never leave the chat.

Describe a game in plain language; get a real, playable, shareable game back; refine it by chatting.