Intro
We are all still figuring this out. Every developer I talk to seems to have a slightly different ritual when it comes to working with AI coding agents. Some treat the AI like a junior intern, others like a stack overflow search bar on steroids.
I’ve spent the last few months refining my own process. It is certainly not the "best" workflow out there, and it might even seem a little heavy-handed to those who prefer to just fire off a prompt and hope for the best. But I’ve found that by front-loading the effort and treating the AI as a collaborator rather than just a code generator, I save myself a massive amount of debugging time later.
Here is the 16-step workflow I use to go from a vague idea to shipped feature.
Phase 1: Alignment and Interrogation
The biggest mistake I used to make was jumping straight to code. Now, I spend a significant amount of time just talking.
1. The Spark
It starts with a feature idea. It might be messy or incomplete, but it’s there.
2. The "Ask" Mode
I open a context with a custom "Ask" persona. This isn't configured to write code; it’s configured to be a critical thinker. I bounce the idea, details, and constraints back and forth.
3. The Sanity Check
I explicitly ask the AI: “Do you understand the idea and the requirements?” It’s a simple step, but it forces the model to synthesize the conversation
4. The Reverse Interrogation
This is the most important step in the beginning. I ask the AI: “What questions do you have? Do you see any logical gaps or edge cases?” I don’t proceed until the AI has poked holes in my logic.
Phase 2: The Specification (The Contract)
Once we "feel" aligned, I don't ask it to code. I ask it to write.
5. The "Doc Writer" Mode
I switch to a different custom persona focused solely on technical documentation.
6. Drafting the Spec
I instruct the writer to create a feature specification based on our previous chat. I enforce a declarative style (describing what should happen, not just how). The spec must include:
* The current state (and the state after changes).
* Goals and desired outcomes.
* Security concerns.
* Relevant code locations
7. Fact Checking
I open a new context and ask the agent to fact check the assumptions made in the spec using web search and documentation (e.g. Context7)
8. The Peer Review
I open a new context with a different "smart" model (often a different LLM entirely). I feed it the spec and ask it to review and improve it.
9. Human Review
I scan through the polished spec. If something feels off or unclear, I loop back to the AI to fix the text. I never move to code until the words are right.
Phase 3: The Implementation (and The Break)
Now that we have a solid "contract" of what needs to be built, the coding is actually the easiest part.
10. The Handoff
I open a new context and give the spec to a smart coding agent. I tell it: “Implement this specification.”
11. Touch Grass
This is where the workflow pays off. Because the spec is detailed, I don’t need to hover. I go read Hacker News, grab a coffee, or actually step outside. I let the machine do the heavy lifting.
Phase 4: The Loop and The Polish
12. The QA Loop:
When I come back, I test the implementation. It’s rarely perfect on the first shot. I enter a feedback loop, pointing out bugs or UI issues, and the agent iterates.
13. The AI Code Review
Once it seems to work, I’m still not done. I open a fresh context with another smart AI. I feed it the original specification and the current git changes (the `diff`). I ask it to review the code specifically against the spec, looking for:
* Logical consistency.
* Security vulnerabilities.
* Performance bottlenecks.
* Project structure consistency.
14. Refinement
I have the agent implement the recommended improvements from the review.
15. Final Human Review
I do one last pass of QA and code review myself.
16. Ship It
When I’m happy, I commit the code. Crucially, I also commit the specification file. It serves as documentation for the future. Then, I push and ship.
Why this works for me
Is 15 steps overkill? Maybe. I know plenty of developers who can move much faster than this.
However, I’ve learned that I am prone to getting lost in the weeds if I don't have a clear plan. This workflow essentially forces me to slow down. By treating the AI as a partner that needs clear instructions rather than a magic wand, I find I spend less time untangling confused code later on.
It’s definitely a bit process-heavy, and I’m sure I’ll tweak it again next month. But for now, this structure gives me the confidence to ship features without constantly worrying that I missed something obvious. Plus, the coffee breaks are a nice bonus.
