One Human, One Team: How GRAKKON Is Built

I’m the only human on this team.

Not “I work solo with some AI tools.” There is a team. It has defined roles, a chain of review, a branching model, and parallel execution. I set the direction. The team builds the game. Let me tell you what that actually looks like.

The team

On the game side: engineering, design, and PM agents. They implement features, carry the architecture, write and review code. The PM tracks the ticket backlog and routes work through the engineering agents in dependency order.

On the website and marketing side: a web engineering agent (Astro, Tailwind, SEO infrastructure), an editor (copy, patch notes, the cabinet voice on every published word), a strategist (brand positioning, Steam go-to-market, what claims are safe to make), and a challenger.

The challenger’s job is adversarial review. Every strategy decision the strategist proposes gets stress-tested by the challenger before it reaches me. The challenger can’t propose alternatives — it can only break things. It reads the same data the strategist read and tells me where the argument fails.

All of these are a team of specialized AI agents working in a shared codebase under a branching model with review gates.

How work actually flows

Something arrives from me — a direction, a brief, a question. It routes by domain. A copy request goes to the editor. An SEO question goes to web engineering. A positioning question goes to the strategist, who delivers, and then immediately the challenger gets the same brief and returns a rebuttal. The lead synthesizes the debate and surfaces the resolved position plus the genuine open calls to me.

The open calls are the ones that require taste. What should the brand name feel like. Whether a particular framing forecloses something on the roadmap. Whether the voice in a draft patch note sounds like the cabinet or sounds like a SaaS company. Those decisions come to me. The agents make everything else.

No mixed-domain tasks. Sequencing is explicit. Parallel agents don’t touch overlapping files — the lead routes and sequences before anyone starts work. The branching model is the same you’d use on a professional team: feature branches, monolithic commits, no direct master edits, merge gates that require explicit approval before anything lands. The agents tag their own rollback points.

What I actually do

I set creative direction. I make product decisions. I write the first brief. I approve or redirect. I think about the game. I talk to pilots. I make judgment calls that require taste.

I don’t write boilerplate. I don’t implement components. I don’t run SEO audits or draft first-pass copy or debug TypeScript type errors. That’s the team’s job.

The bottleneck isn’t execution capacity. There’s enough execution capacity to outpace my ability to give clear direction. The bottleneck is the clarity of direction, and the judgment calls only I can make. One human with clear taste and a bias toward decisions is sufficient to run a structured AI team. GRAKKON is the proof.

What this doesn’t replace

I want to be honest about this, because the honest version is more interesting than the promotional one.

Creative vision comes from me. The soul of the game — the late-night arcade cabinet in the pizza parlor, vectors over voxels, warmth without a retention loop — that’s not agent-generated. The agents implement the brief. They can’t author it.

The SPIRIT_BRIEF — the canonical doc that describes what GRAKKON feels like and why — is a document I wrote. It’s the one artifact the whole team reads before doing anything. It tells them what the game is trying to be at an emotional level. Every design proposal, every line of copy, every palette choice gets evaluated against it.

The agents can hold the brief and apply it. What they can’t do is produce the brief from nothing. They can’t tell me whether the game feels right the way a pilot who came back for the third time in a week feels right. Player empathy still comes from me.

Why I think this matters

This isn’t “I used ChatGPT to write my README.”

The difference is structure. A single LLM prompt is autocomplete with good grammar. A structured team with defined roles, bounded debates, adversarial review, and parallel execution is something closer to a studio. The Challenger exists specifically to catch the Strategist. The editor is authorized to push back on any copy that drifts from the cabinet voice, including copy I ask them to write. The Git discipline is enforced at the process level, not at my attention level.

This is what an indie studio looks like in 2026 when you take agent collaboration seriously. Not a shortcut. A genuine structural change in how one person can build a real product.

The agents move the bricks. I’m still drawing the building.

That line has been true since the first devlog. It’s going to stay true. The building only means something if the drawing is any good.

— Ray