# My approach to implementing AI workflow

I experimented with creating an app completely hands off using the codex and opencode harnesses with GPT5 luna, DeepSeek Flash V4, Big Pickle and Nemotron 3 Ultra models.

As a software engineer, it felt uncanny and uncomfortable but I did minimal code review and asked it fix its own bugs, just to see how well the models can perform without human input.

I looked up popular methods online on how different engineers are using AI to ship code and found that the industry is very divided in terms of how much they trust the AI to write code. Some believe that the models are trained on garbage code from the internet and cannot implement anything better than us while some are giving full authority over the apps they create.

I wanted to see this for myself. So, I decided to go with a simple use case but something that still implements common system design patterns like real-time updates and caching strategies.

**Here is my app idea:** Game Leaders is a web app that tracks board game scores and creates a global leaderboard for that game. It implements SSE (Server Sent Events) to show scores of your opponents in real time and also implements cache aside strategy with Redis for an audience that only views the leaderboard (does not participate in the game)

**And here is my approach:**

*   I created a repo locally and added Jason Ku’s AGENTS.md (minus the git worktree snippet, as I was only planing to use a single agent for this)
    
*   I started with writing minimal REQUIREMENTS.md file and then spun up a codex session with gpt5 luna.
    
*   Switched to plan mode and initiated Matt Pocock’s `/grill-with-docs` skill that interrogated me about my idea and created a PRD
    
*   Switched to build mode and used the `/implement` skill to implement the code. Tested the implementation locally and pushed it to remote via Kun Chen’s no-mistakes-axi
    
*   Reviewed and merged the PR on Github From here, I either ask it to fix bugs using `/implement` or add new features using `/grill-with-docs` and repeat the cycle until it does what needs to be done.
    

**My Reflection:**

*   AGENTS.md (or CLAUDE.md) is super important to setup before you begin your AI integration. Mine was a hobby project running locally and hence Jason’s AGENTS.md was enough but if you have a larger codebase, a team with established engineering standards and rules, it becomes vital to include those aspects in the file as well.
    
*   The `/grill-with-docs` is an amazing tool. It asked just the right amount of asking questions to create a shared understanding of the app’s features and constraints. It also gives you a nice PRD to read before you hit implement.
    
*   Thoroughly Impressed by the speed at which it generates code, self assesses with TDD (specified in AGENTS.md) and keeps fixing it unless all the failing tests turn green.
    
*   The no-mistakes-axi is another beast that re-iterates the testing and review process with it’s own set of rules, fixes any inconsistencies and then pushes a beautiful PR with all the changes and commits for you to review.
    
*   The cognitive debt is real. Even though it only implements exactly what you asked, I did not have the capacity to review so much code in such a short time. When I did review, it felt like deja-vu, familiar and unfamiliar at the same time.
    

**My Takeaways:**

AI in its current state is just a stochastic parrot and cannot be trusted to make decisions. It can however, follow the instructions extremely well.

Automate the boring stuff: Many projects have the same cookie cutter patterns like authentication, string manipulation, database indexing, etc. combined with a little human judgement, these problems are mostly solved in the industry. Hence, are very good candidates for AI to implement with well defined instructions.

This way I reduce the cognitive load, use AI as a tool that takes the repetitive work off my plate and allows me to focus on the solving core problem myself.

Here is the link to my repo: [https://github.com/karan-parekh/game-leaders](https://github.com/karan-parekh/game-leaders)

(This blog post is completely hand written)

**References:**

Jason Ku’s ANGETS.md: [https://github.com/jasonku09/agents-md-snippets](https://github.com/jasonku09/agents-md-snippets)  
Matt Pocock’s skills repo: [https://github.com/mattpocock/skills](https://github.com/mattpocock/skills)  
Kun Chen’s no-mistakes-axi: https://github.com/kunchenguid/no-mistakes