Agentic coding stopped being a demo category. Current tools can take a task, work across a codebase, run tests, and produce a change that merges. We use them daily in delivery work, including on legacy modernization projects where the codebase predates the developers. The capability is real.
What is also real: the gap between teams getting production value out of these tools and teams generating rework at machine speed. The difference is not which tool they bought. It is the structure around it.
What holds up
Verification designed before generation. The teams that succeed decide how they will know the output is correct before they generate it. Tests the agent must pass, behavior contracts extracted from the existing system, empirical comparison against the thing being replaced. Generation is cheap now; verification is the scarce resource, and the discipline of building the gate before running the pipeline is the single strongest predictor of whether agentic work ships.
Adversarial review by a different model. Having one AI generate code and another, from a different model family, review it catches a class of errors that self-review reliably misses. Models share blind spots within a family; correlated errors pass a same-model review at exactly the moments you most need them caught. An independent reviewer model, given an explicitly adversarial brief, changes the failure math. Humans stay in the loop, but they arrive at code that has already survived a hostile reading.
Small, inspectable increments. Agents are at their best on bounded tasks with a clear definition of done: one job, one endpoint, one migration. Teams that feed agents week-sized objectives get changes too large for any human to meaningfully review, which converts the review step into ceremony. Task size discipline is code review discipline, same as it ever was.
Rework loops instead of rework meetings. When verification fails, the finding goes back to the agent with the failure attached, automatically where possible. The teams that treat agent output as a draft in a loop, rather than a deliverable to argue about, get compounding speed from the same tools.
Humans own merges and architecture. The agent proposes; a person with context accepts. Every team we have seen sustain this over months keeps a human on the merge button, not as a formality but as the point where accountability lives. The agent has no skin in the outage.
What does not hold up
Autonomy across long horizons. Multi-day autonomous runs on open-ended objectives still drift: the agent makes a defensible-looking early decision, builds on it for hours, and delivers something coherent and wrong. The failure is expensive precisely because the output looks finished. Horizon length is a risk dial; the successful teams keep it short.
Vibe-coded internal tools becoming load-bearing. The utility someone generated in an afternoon works, gets adopted, and eighteen months later is critical infrastructure with no tests, no owner, and no design. Organizations that let generated code skip the intake bar that human code passes are minting the next decade's legacy problem at unprecedented volume. The bar for entering production should not depend on who or what wrote the code.
Metrics that reward generation. Measuring lines produced or tickets closed by the agent optimizes for the cheap half of the process. The costs show up later, in review debt and regression, where the metric cannot see them.
The uncomfortable symmetry
Here is the observation we find most useful when advising on this: every practice that makes agentic coding safe is a practice that was already good engineering. Tests as gates, independent review, small changes, clear ownership, verification before trust. Agents did not invent these needs; they raised the cost of ignoring them, because the volume of change went up by an order of magnitude while the supply of human judgment stayed flat.
Which means the readiness question for agentic coding is not "which tool?" It is "does our delivery process have the verification structure to absorb code at this rate?" For organizations with strong practices, agents are an accelerant. For organizations without them, agents accelerate exactly what was already happening, and what was already happening was the problem.
We build these pipelines, verification loops included, as part of AI implementation engagements, and the implementation framework page describes where agentic delivery fits in a production rollout. The honest sales pitch is unchanged: AI that ships, not AI that demos, and shipping is a verification problem.