An AI Agent Workflow for Software Engineers That Actually Holds Up
A practical, repeatable workflow for building software with an AI agent: specify, delegate, verify, record. The loop I actually run every day, with the parts that keep it from turning into slop.
A lot of advice about working with AI agents stops at "just ask it to build the thing." That works for a demo and falls apart on a real codebase. Here is the workflow I actually run, day in and day out, on production systems.
It has four moves: specify, delegate, verify, record. None of them is glamorous. Together they are what separates agentic development from generating slop.
1. Specify before you delegate
The agent is only as good as the intent you hand it. Vague in, vague out. So the first move is not typing a prompt, it is getting clear on what you want.
For anything beyond a trivial change, I write the intent down: the outcome, the constraints, the parts that are non-negotiable. In a repo I keep a CLAUDE.md that tells the agent how this project works, what conventions to follow, and what not to touch. That file does more for output quality than any clever prompt, because it makes my standing intent permanent instead of repeating it every session.
2. Delegate the whole task, not the keystrokes
Once the intent is clear, hand the agent the task, not a line. "Add rate limiting to the payments endpoint and update the tests" is a task. Let it read the codebase, make the change across files, and run the suite. Resist the urge to micromanage the implementation. You set the destination; it drives.
This is where the speed comes from. The cost of writing the code drops to near zero. Your attention moves up a level.
3. Verify like you do not trust it
This is the step people skip, and it is the one that matters most. AI-generated code can pass every test and still be wrong. So verification is not a formality.
I read the diff. I run the tests. For infrastructure, I check the actual deployed behavior, not just that the command exited zero. When I moved a site to a private S3 origin recently, the agent's change was correct except for one thing it could not have known without checking: the new origin did not serve directory index files, so every subpage would have broken. I caught it because I verified the live behavior, not the build log. Trust the agent to do the work. Do not trust it to be right.
4. Record what you decided
The last move is the one that compounds. When you make a real decision, write down why. I use short architecture decision records for the project and a journal for my own process. It sounds like overhead. It is the opposite: it turns each session into something the next session, and the next agent, can build on instead of relearning.
Why the loop holds
Specify, delegate, verify, record. The first and third steps are where your judgment lives, and they are exactly the steps an agent cannot do for you. That is the point. The workflow does not replace your engineering; it moves it to where it is worth the most, deciding what to build and confirming it is right, and hands the typing to the machine.
If you want the full version of this, I wrote AgentSpek, a book on building this way, free to read here. See also what agent mode actually is and AI-Assisted Development for how I apply it day to day.