The Signal
Most engineering teams now have access to an AI coding harness: Claude Code, Codex, Cursor or something like them. Most of them use it the same way. A developer opens a session, describes what they want in a sentence or two, and iterates until the output looks right. The industry has a name for this, vibe coding, and for a prototype it works well.
The pattern breaks when the work matters. The first draft arrives quickly, then the time goes to review, rework and the questions nobody asked before the code was written. The tool sped up one step of delivery and left the rest unchanged.
Why It Matters
A short prompt leaves the open decisions to the agent, which makes them silently. Every unstated decision about who the user is, what happens on failure and what is out of scope becomes a guess, and every guess becomes code someone has to review.
Software teams have always paid more to fix a misunderstanding late than early. Agents shorten the time it takes a misunderstanding to become a finished-looking pull request. A human developer who is unsure usually asks a question; an agent that is unsure usually keeps going.
The result is a familiar pattern: code is produced faster, but delivery barely moves, because the bottleneck shifts to review and rework. The output is also inconsistent. Two engineers prompting for the same feature get two different interpretations, and quality depends on who wrote the prompt.
A mature AI-enabled SDLC moves that effort left. It spends more time defining the work before any code exists, so that every agent doing the work builds against the same clear target. Few teams get there in one step.
The Operating Model
Teams tend to mature through four stages. Each one makes the next possible.
Ad hoc prompting. Individuals prompt with a sentence or two. It is fast for prototypes, but output varies by person and nothing carries over between sessions.
Shared context. The repository holds instructions every agent reads: conventions, architecture, how to build and test. Tickets carry acceptance criteria. Output becomes more consistent across people.
Spec-driven work. Work starts from an objective, personas, user stories and refined requirements, approved as a spec. Ambiguity is resolved before code is written.
An agent team with gates. Specialized agents own stages of the SDLC, each with its own skills and a check it must pass. People set objectives, answer questions and approve at the gates.
The rest of this section describes the fourth stage.
At this stage, work moves through a pipeline. Each stage has an owner, a defined output, and a check that must pass before the next stage starts. Some owners are people; most are agents with one responsibility, a limited set of tools, and skills that encode how the team does that job.
The first half of the pipeline produces the spec. The second half builds against it.

The top row turns an objective into an approved spec; the bottom row builds against it, and gaps found during the build flow back into the spec.
Objective. A person states the outcome, who it is for, how success will be judged, the constraints, and what is out of scope. This is the one stage an agent cannot own, because it is a business decision.
Personas and context. A product agent identifies which personas the objective serves: their situation, what they are trying to get done, and what they will not tolerate. Personas live in a maintained document the whole team reuses, so most features draw on existing ones. When the work reaches a new audience, an agent drafts the new persona and a person who knows those users confirms it.
User stories. The product agent writes stories for each persona, each with acceptance criteria. Failure cases get stories too: what the user sees when the network drops, the input is wrong, or they lack permission.
Requirements refinement. A refinement agent turns the stories into testable requirements, using a structured syntax such as EARS ("When <trigger>, the system shall <response>"). Its main job is finding what is missing or contradictory. It returns open questions to a person, and the stage closes once they are answered.
The spec. Requirements, interface contracts and test scenarios are written into the living spec for the area of the product they touch, and a person approves them. Specs are kept per area and updated with every change, so every agent working in that area reads the current rules.
Build, test and review. A test agent writes scenarios from the requirements before implementation starts. An implementation agent builds against the spec, loading only the skills for the area it touches. A review agent that did not write the code checks it against the acceptance criteria, behind automated checks such as type checks, linting and the test suite. A person approves the merge.
Feedback. When the build finds a gap, the gap goes back into the spec in the same change. A requirement patched only in code is invisible to the next agent that reads the spec.
This structure produces three properties.
Consistency. Every agent in a role loads the same skills, so every session applies the same team standard.
Quality. The reviewer is independent of the writer and judges the work against written acceptance criteria.
Efficiency. Ambiguity is resolved once, upstream. Test writing and implementation can run in parallel because both work from the same requirements.
People spend their time setting objectives, answering the questions agents raise, and approving at the gates.
The Counterargument and Failure Modes
The strongest objection is that this is waterfall with extra steps. It can be. The difference has to be scale: a spec for one story takes minutes, and the pipeline runs once per change. If the upstream stages take longer than the rework they prevent, the model is being misapplied.
The common ways it fails:
Spec theater. Every change gets the full pipeline, including one-line fixes. The paperwork grows, nobody reads it, and the gates become rubber stamps.
Invented users. An agent can produce convincing personas with no basis in real customers. If nobody who knows the users reviews them, the whole pipeline builds confidently toward the wrong person.
Spec drift. The code changes and the spec does not. Within a few weeks the spec is wrong, and agents that trust it build on a false picture. A stale spec is worse than none.
Over-specification. A spec that dictates implementation details removes the room for a better solution and turns the implementation agent into a transcriber.
Correlated review. A reviewer running on the same model as the writer may share its blind spots. Separate roles can still share the same judgment. A different model, or a human for high-risk changes, reduces this.
Question fatigue. A refinement agent tuned to ask about everything stalls the work. Its questions should be limited to decisions that change behavior.
Skipping stages. An agent team added before the team has shared context or specs produces more unreviewed code, faster. Each stage depends on the one before it.
Agent sprawl. Splitting every responsibility into its own agent adds coordination overhead and token cost. Add an agent when a role clearly needs one.
When not to use this model. Exploratory spikes, throwaway prototypes and UI experiments where the team learns by building. Vibe coding suits finding out what to build; the spec-driven pipeline suits building it. The model also assumes a working test suite and CI. Without them, there is nothing for the agents to be checked against, and the pipeline produces well-documented guesses.
How Much Upstream Work a Change Needs
The amount of upstream work should match how ambiguous the change is and how costly it would be to get wrong.
Change | Upstream work |
|---|---|
A spike or prototype that will be thrown away | Prompt directly. It never merges. |
A change whose shape is already clear, such as a bug fix with known expected behavior | A ticket with acceptance criteria. The build, test and review steps still run. |
A rough idea, or new behavior | Full refinement: the objective, the personas it serves, user stories and requirements, written into the spec before the build starts. |
A second decision is how to split the work between agents. A responsibility earns its own agent when it needs different tools or permissions, when it must judge work it did not produce, or when it runs on its own schedule. Everything else is a skill that an existing agent loads when the work calls for it.
The Executive Question
Which of the four stages describes how your team works today? One quick test: when an AI agent on your team meets an ambiguous requirement, does it ask, or does it guess and keep going? And if it guesses, would anyone know before the pull request arrives?
