I'm a solo game developer in Japan. I ship iOS games and small web services by myself — design, code, art direction, store operations, marketing, support. For the past stretch of work, a large part of that operation has been running with an AI agent called Muse as my development partner. Not as a chat window I occasionally ask questions, but as a persistent worker: it lives on a virtual machine that runs around the clock, has access to my project files, my notes, and my schedules, and takes on tasks the way a very tireless junior colleague would.
This is what that actually looks like, including where it works and where it doesn't.
The setup: one human, one agent, several products
At any given time I'm maintaining multiple released products — a few iOS games, a web service or two — while developing a new browser game. A solo developer's real bottleneck is rarely writing code. It's the hundred small things around the code: checking store metrics, resizing a project that has bloated to tens of gigabytes, investigating why a build got rejected, writing release notes, preparing promotional posts, keeping track of what was decided last week.
The agent handles a surprising amount of that outer ring. It collects store and ad revenue numbers every morning and assembles them into one dashboard. It runs bulk file operations on game projects. It drafts articles and posts. It watches for security advisories that match my tech stack. My job concentrates on the center: game design, feel, and final decisions.
How I give instructions
The single biggest lesson: the quality of the output is mostly determined before the work starts, by how the task is framed.
Give a goal, not just a step. When I delegate through a goal-oriented mode — a clear statement of the end state I want, not a sequence of micro-instructions — the work runs to completion much more reliably. When I only gave step-by-step prompts, sessions tended to stall halfway, waiting for the next nudge.
Keep tasks small, with a hard stop and one verifiable result. "Fix the hitboxes" is a bad task. "Extend the combo hitbox slightly past the visible tip of the blade effect, for these three characters, and prove it with the test suite" is a good one. Small tasks fail small.
Demand evidence, not conclusions. I require reports to say what was actually measured: which tests ran, what the screenshots showed, what was not verified. This rule exists because of real failures, which I'll get to below.
Write decisions down once. Every settled decision — controls are frozen at this version, this character's size ratio is final, never re-propose option A — goes into a persistent memory the agent reads. Without that, you re-litigate the same choices every session, and the agent cheerfully re-suggests things you rejected last week.
What the agent is genuinely good at
- Tireless verification. Running the same test suite in two orientations, auditing hundreds of sprite frames against numeric gates, re-checking a deployed page byte for byte. Humans get bored and skip; the agent doesn't.
- Bulk and patience work. Sorting tens of thousands of asset files by whether anything references them. Reading long official documentation and cross-checking my assumptions against it.
- Operational memory. It remembers that three weeks ago we decided X, and applies X consistently at 3 a.m. when I'm asleep.
- Drafting. First drafts of articles, store text, and documentation — which I then edit for taste.
What it is bad at
- Judging how something looks and feels. The agent once reported a motion fix as complete because the animation frames existed and the pose transitions were correct. On my phone, the character looked essentially unchanged. Numbers said "done"; eyes said "no." Pixel-level measurement helps (I wrote about that separately), but final visual judgment stays with me, on a real device.
- Knowing when a report is overconfident. It will phrase a partial check as a full verification unless the reporting rules force it to enumerate what was actually tested. The fix is process, not trust.
- Taste. Which of twelve character designs is right, whether a joke lands, when a feature should be cut — these are mine.
Where the human keeps the wheel
Three things I never delegate. First, anything irreversible that faces the public: submitting a build for App Store review always needs my explicit approval, even though bug fixes themselves can proceed automatically. Second, identity and privacy: my real name and home address never appear in anything public, and the agent is under a standing rule to keep it that way. Third, creative direction. The agent can generate a hundred variations; choosing the one that feels like my game is the job I actually enjoy.
Working this way hasn't turned one developer into a studio of fifty. It has turned one developer into maybe two and a half — with the extra capacity mostly spent not on making more, but on verifying better. For a solo operation, that trade has been worth it.
Indie game developer in Japan. I build games like Samurai 100 Slash Lite and Acid Rogue Shooting, and write about developing with AI agents. Portfolio: https://portfolio.wabiplant.workers.dev/
Top comments (0)