I build with coding agents. Here's what I still do myself.
Coding agents now write most of the code in the tools I build. What's left for me isn't less work. It's the part that was always the job: deciding what the thing is, what done means, and whether it actually happened.
- AI
- Systems
- Product
Not long ago, a working internal tool meant a developer, a backlog and a wait. Now I describe it, a coding agent writes it, and I often have something running the same day. For someone who has spent a decade on the business side of delivery, that's a real shift.
The surprise wasn't how much the agent could do. It was how clearly it showed me which parts of the work were never about typing. Those parts are still mine. If anything, they got heavier.
Here's what I still do myself.
I name the states
An agent will build whatever shape you hand it. Ask for "a way to track requests" and you'll get a tidy list with a status column that says open and closed. It will look finished.
It won't know that a request can be waiting on a supplier, ordered but not yet back, or closed because the customer went elsewhere. Nobody told it, because those states live in how the team actually works, not in the request itself. (I wrote about this in From product questions to request lifecycles.)
So before anything gets built, I write down what the thing is: the states it moves through, who owns each step, and what has to be true to move on. That half page decides more about whether the tool works than anything the agent writes after it.
I write what done looks like
Agents are very good at building the wrong thing well. The code runs, the screen loads, and it answers a question nobody asked.
The fix is old-fashioned: acceptance criteria, written before the build. Given this, when that, then this. The habit that changed things for me was turning those into tests the agent has to pass, so done is something it can check rather than something it announces.
Writing them is slower than prompting. It's also the only part that tells me whether I got what I needed, rather than what I typed.
I make the decisions, and write them down
Every build throws up choices. Should this field be editable? What happens to a record when its source changes? Which system wins when two of them disagree?
Left alone, an agent picks an answer and moves on. It's usually a reasonable answer. It's also invisible: nobody chose it, so nobody owns it, and months later it shows up as a bug that is really a missing decision.
So I keep a decision log. Each open question gets a number, the options and a recommendation. The person who owns the outcome decides, often several at once, and every change points back to the decision that allowed it. The agent builds; people decide. The log is how both stay honest.
I draw the lines it can't cross
An agent with access will use it. That's the point, and it's the risk.
So the boundaries come first, written as plain rules. Tests run against made-up data, with no connection to anything real. A new connection reads before it writes. The first write goes to a single test record. Live changes stay switched off until someone has signed off.
None of this is clever. It's the same staged trust you'd give a new starter, written down so a machine can follow it.
I read what it did
Done from an agent is a claim, not a result.
It will tell you, confidently, that the change works. Sometimes it does. Sometimes the preview said one thing and the real run did another. Sometimes a field that should never change once it's set turns out to be editable, because nothing said otherwise.
So I review. Not every line of code, but the parts that matter: the change against the decision it came from, the test that proves it, and the result on a real screen. I treat the agent like a fast, capable colleague who has never once said "I'm not sure."
What I took from it
The work moved. Less of my week goes on waiting for a build; more of it goes on specifying and checking. That's not a new job. It's product ownership and business analysis with the delay taken out.
The parts the agent can't do are the parts that were always the job: deciding what the thing is, agreeing what done means, owning the choices and checking the result. Agents didn't make those optional. They made skipping them faster, and more expensive. (It's the same point as AI doesn't reward ingenuity. It rewards low variance., seen from the product side.)
If you're a product or ops person wondering whether to build with agents: yes. But spend the first hour on the half page, not the prompt.