I delivered a playable version of Glyphverse Zero as a solo developer in about a weekend using AI-first development, excluding marketing and distribution integrations. It is an indie incremental idle sci-fi game that turns camera input into ASCII glyphs and connects that visual system to an upgrade economy.
1. Define ownership before generating features
My AGENTS.md defines the stack, architectural boundaries, product constraints, and required checks. React owns screen-space UI, PixiJS owns camera rendering and world-space effects, and Zustand holds shared state. It also specifies camera-free play and support for portrait and landscape layouts.
“Do not add screen-space menus or application controls to PixiJS. Do not move the camera shader or high-frequency world rendering into React.”
Project source: AGENTS.md — Architecture Boundary
Review early changes against those rules: are menus creeping into the renderer? Is a resource balance duplicated in UI state? Early mistakes become patterns that later features repeat.
Anti-pattern: asking for “clean architecture” without defining which layer owns rendering, UI, and gameplay state.
Takeaway: make architectural rules specific enough to review a diff against them.
2. Add abstractions when requirements justify them
Distribution added login, cloud saves, and ads to the project. I introduced a platform interface to keep SDK calls separate from gameplay. The game requests an operation; the platform implementation handles the host service.
That boundary became useful when there was a real integration to support. Designing a framework for hypothetical platforms beforehand would have added work before the requirements were clear.
Takeaway: introduce an abstraction when it solves a concrete problem in the game’s architecture.
3. Give the agent the tools to test the full game
Give the agent browser and device permissions, a repeatable test environment, and explicit checks for each change. Ask it to build testing tools too: a game result setter reaches specific states quickly, while speed controls make full progression runs practical.

setTimeScale: (timeScale) => {
if (import.meta.env.DEV && DEV_TIME_SCALES.includes(timeScale))
set({ timeScale });
},src/store/game-store.ts — speed changes are restricted to development mode.Require a complete run through the UI from a clean save, without injecting resources. For example, buying upgrades as they become affordable tests whether the economy actually allows progression. My browser runner completed a run in about two minutes, giving an estimated minimum gameplay time of around 41 minutes at normal speed for the tested strategy.
Account for each speed segment and check timing-sensitive behavior at normal speed. Include failure cases, such as interrupted camera access or a dismissed rewarded ad. Human playtesting remains essential for judging how the game feels.
Takeaway: have the agent play the full game, test failures, and estimate gameplay time from measured runs.
4. Preserve the rules behind the code
Document business rules and their exceptions so later features do not undo earlier decisions. Spending resources must not erase the highest narrative milestone, and tutorials must not interrupt artefact capture. These details are easy to lose when documentation covers only the expected flow.
Use documentation to explain intent and regression tests to preserve behavior. A README can be enough for a small game; larger projects need focused gameplay documentation linked from the agent guide.
Takeaway: every intentional behavior change should leave the next agent enough evidence to preserve it.
I still noticed documentation drift and occasional changes that departed from behavior specified in AGENTS.md. Written instructions alone do not enforce a design; AI-first development needs a feedback loop that catches those gaps before the next feature builds on them.