A Vibe Coding Stack for a Solo Game Developer

Most "vibe coding stack" advice assumes you're shipping a web app: a terminal agent, a couple of MCP servers for the database and the browser, done. Game development breaks that template. A solo developer or two-person team is simultaneously the engineer, the level designer, the UI artist, the marketer and the QA department, and the actual work happens inside a heavyweight editor (Unity, in this case) that a terminal agent can't see into just by reading files on disk.

This post puts together a stack for that situation: one coding agent, one MCP server that gives it eyes and hands inside the Unity Editor, a subagent pack that covers the roles you don't have people for, a skill that keeps solo development disciplined instead of chaotic, and two more MCP servers — one for design handoff, one for research — pulled from categories most "AI + games" posts never mention.

Why game dev needs a different stack

A terminal coding agent that only edits .cs files is working half-blind. It can write a script, but it can't see whether the GameObject it's supposed to attach that script to still exists, whether a prefab reference is wired up, or whether the scene even compiles in the Editor. Every change needs a human to tab into Unity, press play, and report back what broke. That loop is what a game-dev stack needs to close.

The other half of the problem is scope. Shipping even a small game touches disciplines a solo developer usually has to fake: UI layout, store listing copy, a content calendar for TikTok clips of the build. None of that needs a person hired for it, but it does need an agent that can be told to "act like" each of those roles on demand.

The core: an agent that can see the Editor, not just the files

Claude Code Paid

Anthropic's agentic coding tool for the terminal, IDE, desktop and web

★ 149k · +863 this week

🔥 Claude Pro billed annually: $17/month instead of $20

9.4 Visit ↗

Claude Code is the terminal agent underneath this stack, chosen because everything else here documents working with it directly — Editor MCP servers, the subagent pack, and the knowledge-graph skill all list it as a supported client. Install it with the command from its own docs:

curl -fsSL https://claude.ai/install.sh | bash

It's a paid tool: Claude Pro runs $20/month ($17/month billed annually), and Claude Code is included in every paid Claude plan, with per-token API billing as an alternative if you'd rather pay for usage directly. See /apps/claude-code for the full breakdown, and /deals for the current annual-billing discount.

On its own, though, Claude Code still only edits files. The next piece is what actually closes the loop with the Editor.

Giving the agent hands inside Unity

Unity MCP 🔌 MCP serverOpen source

Lets AI agents drive the Unity Editor: scenes, C# scripts, assets, tests and builds

★ 15k · +173 this week

8.0 Visit ↗

MCP for Unity (the CoplayDev project) runs as two halves: a C# package inside your Unity project, and a local Python server your MCP client talks to. Once both are running, the agent stops guessing at scene state and starts acting on it directly — creating and wiring GameObjects, editing components, managing prefabs and materials, reading the Console for compile errors, running the Unity Test Runner, and kicking off player builds. A unity_reflect tool even lets it inspect the live C# API instead of working from stale documentation.

Install it from Unity's Package Manager:

openupm add com.coplaydev.unity-mcp

or add the git URL directly (https://github.com/CoplayDev/unity-mcp.git?path=/MCPForUnity#main) through "Add package from git URL." A setup window inside Unity then writes the client config for you. It's MIT-licensed and free, supports Unity 2021.3 LTS through Unity 6, and — because it can delete scripts and assets and run arbitrary menu items — it's worth keeping the project under version control and turning off tool groups (animation, ProBuilder, AI asset generation) you don't need. See /mcp-servers/unity-mcp for the full tool list.

There are competing Unity MCP servers in the directory (a lighter WebSocket-based one, and a runtime-focused one that exposes any [AiTool]-tagged C# method), so if this one's tool surface doesn't match your workflow, /apps/claude-code/mcp-servers is worth a browse before you commit to one.

Covering the roles you don't have people for

Contains Studio Agents 🤖 AgentFree

Subagents for a rapid product studio: engineering, design, marketing and ops

★ 12k · +-4 this week

7.5 GitHub ↗

This is the piece that's easy to skip and shouldn't be. Contains Studio Agents is a set of roughly 37 Claude Code subagents modeled on the departments of a small app studio that ships on six-day sprints — not just engineering roles, but a UI designer, a UX researcher, a brand guardian, a "whimsy injector" for small delight moments, and marketing subagents for app store optimization, growth, and platform-specific content (TikTok, Instagram, Reddit, X). For a solo game developer, this is the closest thing to hiring a design pass and a marketing pass without hiring anyone.

Install it by copying the agents into your project or user config:

git clone https://github.com/contains-studio/agents.git && cp -r agents/* ~/.claude/agents/

It's free, Claude Code-specific, and documented at /agents/contains-studio-agents.

Superpowers 🧩 SkillFree

A skills library that makes coding agents plan, test-first and debug systematically

★ 294k · +2.7k this week

9.0 GitHub ↗

The risk with subagents covering that many roles is that a solo project turns into an undisciplined pile of half-finished features. Superpowers is a skills library (Jesse Vincent and Prime Radiant) that gives the main agent a development method rather than one-off tricks: it asks what you're actually trying to build before writing code, produces a plan of small tasks, then executes that plan with test-driven development and code review between steps. A bootstrap skill makes the agent check for relevant skills on its own, so this isn't something you have to remember to invoke. Install it as a Claude Code plugin:

/plugin install superpowers@claude-plugins-official

It's free and documented at /skills/superpowers.

Keeping a solo codebase legible to yourself

Understand Anything 🧩 SkillOpen source

Turns a codebase into an interactive knowledge graph with tours, search and Q&A

★ 85k · +858 this week

8.0 Visit ↗

A game project that started as a weekend prototype tends to accumulate systems — inventory, dialogue, save data, a combat state machine — that nobody but you (six months ago) ever fully understood. Understand Anything turns the codebase into a browsable knowledge graph: tree-sitter extracts the real structure (imports, definitions, call sites, inheritance) and an LLM layers on plain-English summaries, architectural layers and guided tours. The /understand command builds it incrementally and can update itself on every commit; a local dashboard lets you search it by layer, and /understand-chat lets you ask it questions directly. Because the graph is saved as JSON under .ua/, you can commit it and avoid re-running the analysis from scratch after a break.

Install it as a plugin:

/plugin marketplace add Egonex-AI/Understand-Anything

Open-source and free, documented at /skills/understand-anything.

Design handoff and research: two MCP servers most game-dev posts skip

Most "AI for game dev" writeups stop at the engine integration. Two more MCP servers, from categories that have nothing to do with Unity specifically, round out a stack that also has to handle UI and content research.

Figma MCP Server 🔌 MCP serverFreemium

Figma's official MCP server: give agents design context from your Figma files

🔥 Students & teachers: Figma and FigJam professional features free with a verified education account

8.3 Visit ↗

If your UI mockups live in Figma, Figma's own MCP server gives the agent structured design context — layout, variables, styles, components and screenshots — instead of a rough guess from a screenshot you paste in. If you use Code Connect, it can map Figma components to the matching components in your codebase, and the remote server can write back to the canvas: creating files, turning a Mermaid diagram into a FigJam board, or capturing a live web UI as editable design layers. It's a freemium, official server with no dedicated install command; see /mcp-servers/figma-mcp for setup.

Firecrawl MCP 🔌 MCP serverFreemium

Scrape, crawl and search the web as clean Markdown from your agent

★ 7.5k · +24 this week

🔥 Free plan: 1,000 credits every month, no card needed

8.5 Visit ↗

Research is the part of solo game development that eats the most context-switching time: checking how a competing game handles a mechanic, pulling a platform's store-listing requirements, or grabbing a font license page. Firecrawl MCP turns messy web pages into clean Markdown or structured JSON the agent can act on directly — scraping a page, crawling a docs site, or searching the web with full page content in the results, plus a firecrawl_interact tool that can click and type before reading a page. It's freemium and works with Firecrawl's cloud or a self-hosted instance; details at /mcp-servers/firecrawl-mcp.

Putting it together

Everything below Claude Code itself is free or freemium, which matters for a stack aimed at solo developers and small teams rather than funded studios. The only recurring cost that's fixed is the coding agent's own subscription.

A day in this stack

A realistic loop looks like this: you paste a Figma mockup link and ask Claude Code, via the Figma MCP server, to build the matching UI prefab in Unity. Superpowers kicks in uninvited, asking what the panel actually needs to do before generating a plan. The plan gets executed with the Contains Studio Agents' UI designer and frontend/engineering subagents doing the actual construction, with Unity MCP wiring the resulting prefab into the scene and running the relevant tests. If a bug shows up three weeks later in a save-data system you haven't touched since, Understand Anything's /understand-chat answers "what actually calls this function" faster than reading the file yourself. And when it's time to write the Steam page, a marketing subagent from Contains Studio Agents drafts the copy while Firecrawl MCP pulls three competitors' store pages for reference.

None of these tools know about each other. They're stitched together only by the fact that they all speak to the same agent through the same handful of open standards — MCP for the Editor, design and research connections; the Claude Code plugin/skill format for the workflow discipline and subagent roster. That's the actual argument for building a stack this way instead of waiting for an all-in-one "AI game engine": you can swap any one piece (a different Unity MCP server, a different subagent pack) without the rest of the stack noticing.

Where to go from here

If Unity isn't your engine, the model still holds: look for an MCP server that gives the agent real read/write access to your engine's live state (not just its files on disk), a subagent or skill set that covers the roles you're missing, and a design/research MCP server or two, from /ecosystem, to round it out. The glossary has short explanations of MCP, Agent Skills and subagents if any of those terms are new. The concrete takeaway: don't just point a coding agent at a .cs file and hope — give it a way to see the Editor itself, and hand off the roles you don't have time to play yourself.