Process
Agents made code cheap. Getting the design right is still the hard part. Here, agents work every stage from requirements to code, and every stage passes an adversarial review before the next one starts.
Where agent-assisted coding stops
An agent working in the editor, with a human prompting it and reviewing what comes back, is agent-assisted coding. It is table stakes, and it makes implementation faster without touching requirements or design.
Where software goes wrong
Most of what goes wrong in software starts before code exists, in requirements and design. Review that starts at the code finds those problems only after everyone has built against them, when a fix means rework instead of a revision.
Agent-directed engineering
Agent-directed engineering treats implementation as one stage of several. Raw requirements become concrete business requirements. Those become a high-level design, the design becomes frozen contracts between services, the contracts become a low-level design for each service, and the low-level designs become infrastructure and code. Each stage is a gate: an adversarial review runs in fresh context, and a human makes the decision. The agents carry the volume, and the design judgment stays with the architect.
A few structural facts hold across every stage. Nothing is reviewed by its own author. Cross-service contracts are frozen before implementation begins, so every service builds against the same agreement. Commits pass enforced gates before they land.
Not a waterfall
Gates before code can sound like a return to big design up front. The difference is that the gates run for every increment, not once per project. A platform typically begins as a proof of concept and grows in phases, and each phase goes back through the same process. What production shows about the running system becomes input to the next round of requirements.
What it has produced
Three production systems have come through this process: a billing and token service, an entitlements service, and a container platform migration. Each went through development and staging the usual way and was fully functional on its first release to production. Every release since has passed the same gates.
No release has needed a hotfix to correct an error. Staging turns up mostly usability questions, matters of taste that only settle once people can use the software.
By the time code exists, the design has already survived several rounds of adversarial review. That is the difference between agent-assisted coding and agent-directed engineering.