My AI Workflow: Replacing Manual Management

Stop treating AI as a chatbot and start treating it as a living system. I've spent the last few months moving away from "permission prompts"—where you ask the AI if it can do something or wait for it to ask you for permission—and instead built a library of 134 standing rules. Essentially, I've offloaded the "management" layer of my development process to the LLM agent itself.

The "Management" Loop

The core of my current AI workflow isn't just about generating code; it's a recursive cycle. I use AI to write the initial code, then use a separate AI instance to review that code. I then have the system review that critique against the live branch, test the resulting corrections, and—this is the critical part—record every failure as a permanent rule for the next session.

By doing this, I've essentially automated the role of a lead dev or project manager. Instead of me babysitting every line, the system learns from its own mistakes. I'm not just prompting; I'm building a knowledge base of "what not to do" that persists across my projects.

Killing the Manual Code Review

I’ve reached a point where I believe human code review is often a waste of resources. My eyes get tired, and I miss things. Instead, I've implemented a system of adversarial reviews. I let two different AI models tear apart a targeted change from opposing angles. If they both sign off on it, the probability of a bug is lower than if I had spent twenty minutes squinting at a diff.

This shift allows me to focus on high-level system design and final validation rather than the "middle-work" of syntax checking. For example, as a backend developer, I have historically been terrible at frontend work. I used to spend hours fighting with a single CSS rectangle. Now, I describe the desired behavior using backend distributed systems logic, and the AI translates that into complex GSAP orchestrations and animations. I don't need to master the framework to achieve a professional result; I just need to be able to verify that the end product works.

Moving from Scratch to Deployment

For anyone looking to implement a similar AI workflow, here is the mental model I use for deployment:

1. Define the Architecture: I speak in terms of systems and data flow, not specific functions.
2. Adversarial Generation: Use one model to build and another to critique.
3. Verification: Run the code against real-world test cases.
4. Rule Documentation: If a bug appears, I don't just fix it—I write a standing rule in my system prompt to ensure that specific error never happens again.

This approach has allowed me to ship projects across three entirely different tech stacks without needing to be an expert in any of them. It's a deep dive into prompt engineering where the goal isn't a "perfect prompt," but a perfect system of constraints. When you stop acting as the bottleneck for every decision, the speed of deployment increases exponentially.