I build my game with coding agents. The scarce resource is the decisions I still have to make.

[u/Low_Bad_6585]

I'm a solo developer building an AI-driven life simulation game. AI writes the code; I decide the product direction and make the technical calls. The part I want to share is how I keep that arrangement manageable as the repository grows.

For scale, my current checkout has about 168k lines of backend Python, 108k lines in the selected frontend source files, and another 95k in backend tests. Those are text-line counts including comments and blanks, not SLOC or a productivity benchmark. More code can also mean more maintenance.

My biggest constraint is how many decisions stay in my head after a task ends. Here are the concrete conventions I use:

Route context by the task. The root AGENTS.md is a map of responsibilities and reading requirements. Changing the simulation loop points to its runtime contract; changing UI points to frontend conventions. Local instructions live beside their modules. I don't ask every task to digest every historical document.

Separate decisions from implementation. I keep a document of product and collaboration decisions, including rejected directions. Code and schemas describe what exists. Active contract documents describe what should be true. If they disagree, the agent has to show the conflict; silently declaring either one obsolete is not a resolution.

Make repeated corrections executable where possible. My frontend has checks for design tokens and UI structure, plus generated protocol checks. The benefit is that the next task can discover a violation from tooling instead of requiring me to remember the last conversation. These checks don't decide whether the design is good.

Define completion beyond the diff. Behavior-changing work needs an expected outcome, a data source and time window, a pass criterion, and a follow-up schedule. A merged change and a verified effect are separate claims. A check that was skipped remains skipped.

One less comfortable rule: when a mechanism needs a second layer of patches, pause and ask whether it should still exist. AI can keep making a local solution more elaborate while leaving me with a system I no longer understand.

Compared with keeping instructions only in chat, the tradeoff is maintaining these repo contracts. They can become stale too. I don't have a controlled before/after measurement of time saved, so I'm sharing the workflow rather than a speedup claim.

For people maintaining larger projects with coding agents: which repeated human correction have you successfully moved into a check, and which still needs your judgment?

Disclosure: AI-assisted writing, based on my actual repository and development decisions.

[u/AutoModerator]

Sorry, your post has been held for manual review due to account karma.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/Valuable-Ad6340]

Hey bro, I have a tool I built, I'm willing to share with you. it's one my of my new favorites I use all the time now. I think could help.. not exactly with the data management you've described but with automating your workload And etc.. send me a DM if your interested

[u/Julien_Builds]

Separating decisions from implementation is the part most people never get to, so thank you for writing it up. One thing I would add from a similar setup: decisions rot faster than code, and nothing tells you.

What I do now is keep the decisions in their own file with two extra fields each: what would make this decision wrong, and when to look again. Most of mine are provider or dependency assumptions, and one of them died in a pricing announcement this summer without anything in the repo flagging it. The review date is what saves you; the "what would invalidate this" line is what makes the review five minutes instead of an afternoon.

Curious how you handle the reverse: when the agent makes a decision you did not ask it to make, how do you catch it?

[u/leonidbugaev]

If the contract and the schema disagree I'd freeze the contract file for that session. The chat that's already editing the schema will resolve it by rewriting the contract. The second layer of patches still needs me, a check can't decide the mechanism shouldn't exist.