How I Build with AI Coding Agents as a Solo Developer
I run three products and four games on my own. That wouldn't be possible without AI coding agents doing a large share of the implementation. But "let the AI write it" isn't a workflow. Most of what makes it work is the structure I've put around the agents.
This post describes that structure, using real examples from my repos.
The agents I use are Codex and Claude Code.
1. An AGENTS.md in the repo
AGENTS.md is a file at the root of a repo that coding agents read before they start. Five of my seven projects have one, and they're where project knowledge lives, so I don't repeat it in every prompt. They range from 13 lines (Feedbackly) to 124 (Ash & Oath), and they've grown one rule at a time, usually right after an agent got something wrong.
Some real rules, and the reason each exists:
- "This is NOT the Next.js you know." Next.js changes faster than models are trained, so agents are told to read the docs bundled in
node_modulesbefore writing code. This one rule removed a whole category of plausible-looking but outdated code. - An SEO checklist for every commit. In ReadSprint and InvoiceAgent, every change must keep canonical URLs, sitemaps, structured data and redirects correct, and the agent's final message must include a short SEO audit. Search traffic is how these products grow, and one accidental
noindexcan undo months of it. - "Do not invent metrics." When an agent writes SEO content, it must use real Search Console data. If it can't get access, it says so instead of producing a "data-led" plan from nothing.
- Brand rules. ReadSprint's file points at its brand guide: keep the logo, typography and orange, and check both themes and mobile layouts.
- Scope limits. Ash & Oath's says "Generate new NPCs only when the user explicitly requests them." Agents are eager, and some work costs real money (in this case, 3D asset generation credits), so it needs explicit permission.
Depending on what I'm building, I also write down the process I want an agent to follow. Ash & Oath's file has a whole section on generating new art:
- New assets need my approval. Paid generation runs need "explicit user approval of the exact request, references and cost/quantity" before anything is generated.
- New assets must meet the existing standard. Every new asset "must match the current approved art style and quality of comparable assets", checked at the actual gameplay camera and lighting, not just as concept art.
- Agents can't sign off their own work. AI reviews are advisory. Publishing an asset needs a named human approval.
2. Skills for workflows I repeat
Some tasks happen again and again, with many steps. For those I write a skill: a document describing the workflow, which the agent follows whenever a request matches.
Two examples:
- SEO content, driven by Search Console (ReadSprint, InvoiceAgent and Feedbackly). Before writing any SEO content, the agent opens Search Console, checks it's in the right account, compares the latest 28 days with the previous 28, separates brand from non-brand queries, reviews indexing, and only then picks what to write. It saves a dated review of the evidence in
docs/. The skill is strict about honesty: "never describe ten visible rows as a complete inventory", and "do not infer conversion success from clicks." - Convert the next Motive case to 3D. One prompt, "Convert the next case to 3D", makes the agent find the next unconverted case, resume any half-finished work from a register file, follow the production process and update the register with evidence.
The common thread is that a skill turns my judgement into a procedure the agent can repeat. I decide once how a job should be done, and every later run follows it.
3. A strict definition of done
The most common way agents fail isn't writing bad code. It's stopping early and calling it finished. So my instructions spell out what "done" means:
- From the Motive skill: "A plan, blockout or substituted GLB alone is not completion."
- From Ash & Oath's release process: "Local packages alone do not complete a release." A release includes uploading, updating the download manifest, checking the live links and cleaning up old builds.
- From Motive: "Do not mark missing reviews or device checks as passed."
- From Ash & Oath: assets must be checked in gameplay before a chapter is described as complete.
Writing "done" down this explicitly felt excessive at first. It's now the most valuable part of each file.
4. Scripts that check the work
Instructions don't help if nobody can check them. So each project has scripts an agent can run to check its own work:
- Ash & Oath has 87
verify:*scripts, covering performance, model loading, whether characters' feet stay planted, crafting rules, item data and more. - Motive runs
npm run seo:auditafter every change, and the agent must treat failures as blockers. - Piko's devlog check lists commits that haven't been logged yet (more on that).
Scripts turn "make sure X still works" from a hope into a step. When an agent says the work is done, I can ask which checks it ran.
5. Evidence goes in the repo
Agents don't remember previous sessions, so anything worth keeping is written down: dated audits, release records with file sizes and checksums, review notes and asset-generation prompts. Months later, I (or the next agent) can see what was decided and why.
What I still do myself
Agents do most of the implementation, but some parts of the job stay with me:
- Product direction and art direction. Agents build what I decide, but what each product does and how each game looks are always my calls.
- Reviewing the work. I read the diffs, test the result myself in the app, and run the verification scripts. No single check is enough on its own.
- Guarding visual consistency. This is the biggest challenge, in the products and the games alike. Keeping a brand or a game's art style consistent is where agents drift most, which is why brand guides, style guides and approval steps show up in my AGENTS.md files.
- Focusing on vision and quality. I'm a lot faster with agents, but the bigger change is where my time goes. Instead of spending hours digging through code, I can focus on the vision and quality of each product and game.
If you're starting out
- Write an
AGENTS.md, and add a rule every time you correct the same mistake twice. - Turn repeated multi-step tasks into skills.
- Define "done" explicitly, especially the steps after the code.
- Give agents scripts to verify their own work.
- Keep a written record in the repo, because nobody remembers otherwise.
The agents do most of the typing. Deciding what to build, how good is good enough, and when something is really finished is still my job.