Ask The Game, the Build Log

Better Code Through a Governance System

It's becoming more complicated because, well, it just is. The project started small, with a few files and some basic scripts, but as it grew, so did its complexity. Now I find myself looking at a codebase, wondering, "Where does this piece fit in again?"

I had a great pipeline up and running, but my development standards were scattered across AI conversations and prompts and stored only in my head, which was becoming chaotic.

Just a reminder, I'm not a developer by trade. It was time for some serious project management. So, I researched and here I am.

Reusing My New Architecture Prompts

In the blog post I Just Wanted Better Logs. Now I Have a Whole New Architecture, I created a couple of helpful prompts to review the entire file structure and logging system.

These prompts helped me, but since then, I made some changes and had this moment: "Did I remember to check everything?" You know that feeling, right? When I push code and then immediately get that sinking feeling that I forgot something important.

Based on my research, I decided to build something that would actually be useful. Here's what I created:

AGovernance Structure

First things first: I moved everything into a proper docs/ directory. Because, apparently, that's what senior developers do. Plus, I learned that GitHub has set standards for this, so I finally decided to follow them.

docs/
├── README.md                    # Your friendly navigation guide
└── development/
    ├── README.md               # The main development standards
    └── logging.md              # Our logging architecture

Clean, organized, and easily discoverable. Revolutionary for me; I didn't know this existed. It makes so much sense.

The Development Standards Checklist

I created a comprehensive checklist that covers everything I need to consider when wrapping up work on a new iteration.

We all know, and I'm sure I'm not alone in this, that documentation is gold. In vibe coding, it's not just for my benefit, but also for my AI companion. So, it's fundamental.

Plus, since things come up that I don't have complete control over, documenting them is a valuable exercise. And as a bonus, I've noticed that having an AI checklist helps me break my project less often. So, here's one of my checklists:

# Development Standards & Checklist

## 🔄 Post-Development Cleanup Checklist
When completing any significant work, ensure:

### Architecture Review
- [ ] Code is placed in the correct module (`src/askthegame/`)
- [ ] CLI scripts are in the `scripts/` directory
- [ ] Configs are externalized to `configs/`
- [ ] Tests mirror source structure in `tests/`

### Code Quality
- [ ] Follows logging architecture (structured, contextual)
- [ ] Type hints are present
- [ ] No hardcoded values
- [ ] Error handling is informative

### Cleanup
- [ ] Remove temporary/debug files
- [ ] Remove unused imports
- [ ] Update documentation if APIs change

## 🤖 AI Assistant Instructions
When working on this project, always:
1. Reference this checklist after major changes
2. Follow the project structure outlined in README.md
3. Adhere to logging standards from docs/development/logging.md

GitHub Integration That Truly Helps

And I linked this to my GitHub workflow. Now every pull request automatically shows a checklist that reminds me to check all the important points:

No more "oops, I forgot to run the little thing" moments.

It's Not Boring for Me

Governance might sound dull to you, but for me, I absolutely LOVE it. I always knew good governance doesn't slow you down. It speeds you up. I learned this even more when I worked at IBM.

How much time do I spend on:

Exactly.

The Benefits of Vibe Coding Are Real

Faster Development: When I know exactly where everything goes and what standards to follow, I spend less time thinking about structure and more time solving actual problems.

Better Code Quality: Those little checkboxes? AI catches the things I would otherwise need to prompt at 3 AM three days later.

Easier Collaboration: Whether working with new AI assistants, like I tried with Google Gemini CLI, everyone knows the rules now.

The Technical Side

I followed GitHub's documentation standards pretty closely. The docs/ directory is the standard place for this stuff, and I organized it by purpose:

The PR template automatically appears when I create pull requests, so I literally can't forget to check the important stuff. My AI is always a helpful friend, just as it should be.

And everything is version-controlled, so as my standards evolve (because they will, I'm learning), I have a clear history of what changed and why.

There's a lot I could add next, but for now, I have a better foundation.

This is just the beginning, honestly. AI said that I could add:

Ok. I'll need to ask ChatGPT on this. But for now? I have a solid foundation.

– Benoit Meunier