From idea to production on agents, with a human deciding at every step that matters
Agentic engineering is not code generation with a review at the end. It starts with an idea, turns it into an initiative with ROI, cuts it into epics with outcomes you can measure in flight, builds a working mock you can click, and only then enters the pipeline. Here are the six phases and who moves each one forward.
Most descriptions of "AI in engineering" start at the keyboard: a story in the backlog, an agent writes the code. That skips the part where most value is won or lost. By the time a story exists, somebody has already decided what to build, how much it is worth, and what "done" means. If those decisions are made badly, the fastest pipeline in the world ships the wrong thing faster.
So our model starts earlier. Six phases, and at each one a named person decides whether it moves forward.
01 · Idea
It starts with a sentence from anyone in the business. Not a ticket, not a spec. "Our ISV partners keep asking whether they can fund merchants on a Friday." The point of this phase is that ideas are cheap and should stay cheap until something has been learned about them.
02 · Initiative
The product lead takes the idea and, working with agents that know the product, the market and the numbers, turns it into an initiative with the business case attached: who it is for, what it changes, what it costs, what it returns, and over what period. The ROI is not a slide at the end; it is the first thing written, because it is the thing that decides whether anything else gets written.
The product lead reviews and reworks it. When they are satisfied, they move it forward. That is the approval: the person who owns the product moving the item in the backlog. No committee, no ceremony, one accountable person.
03 · Epics
An initiative that is worth doing is cut into epics: distinct chunks of value for the customer, each with an outcome that can be measured while the work is in flight, not after everything ships. This is the part most organizations skip and then wonder why they only find out at the end whether the investment worked. An epic with no measurable outcome is a task list, not a bet.
Again the product lead moves it forward. Again that is the gate.
04 · Working mock
This is the phase that changes the conversation between product and engineering. Before anyone commits to building the thing properly, agents produce a usable version of it, deployed to a temporary environment, with real automated tests, API-first contracts, and every engineering standard applied. It is real from the start, not a clickable drawing.
The team and the product lead then vet the acceptance criteria by using the feature. Not by reading a Given/When/Then and imagining it. By clicking through it, breaking it, finding the case nobody wrote down. Acceptance criteria that survive being used are a different quality of criteria than the ones that survive being read.
05 · The Iron Pipeline
Now the engineers take over, and they choose: start from the mock, or start from scratch with the mock as the specification. Either way the work runs through nine stages and three human gates, which the next essay walks through. Every merge deploys. Nothing is released until a person says so.
06 · Production
The code is already in production, dark, behind a feature toggle, deployed blue/green, API-versioned, with the evidence trail attached: who built it, who verified it, on which model, against which acceptance criteria. Release is a decision, not a deployment. Turn it on when the business is ready. Turn it off in seconds if it isn't. The outcome is reported against the epic it came from, which closes the loop to phase 03.
Who decides
Look at the six phases and notice where the people are. The product lead moves initiatives and epics forward. The team vets the mock by using it. Three typed gates sit inside the pipeline. A person releases. The agents do nearly all of the work; the decisions that matter are all human, and every one of them is recorded.
That is the whole idea. Agentic engineering is more than code generation. It is a lifecycle where the business case, the breakdown into value, the thing you can click, and the build itself are all produced by agents, and your people decide what moves forward.