Nine stages, and how
you know which one
you're in
Every stage below is a way of working, not a tool purchase. A short assessment places your team on the ladder; the full model sits behind it when you want the deep read. Honest answers make this useful. Optimistic ones make it decoration.
The ladder orders the other two things written up here. The Agentic PDLC is how a person works well in the loop. It earns its keep around stages five and six, where the spec is the artifact and a human steers every cycle. Loop & Harness Engineering is what you build when you'd rather be on the loop than in it: stages eight and nine, where the system does the judging and you watch the judging. The PDLC came first because that's the rung you climb first.
Nineteen questions at most, and two of them are gates that skip whatever doesn't apply to this team. All at one altitude: one team, one stream. Pick the closest answer, or say none fits. Each answer places part of the work on the ladder; the band your answers agree on is where the team sits.
These questions are for someone close to the work. Reading the org from the exec floor? The coherence check is the same axis at your altitude, measured from the scoreboard instead of memory.
Reading for:
- product what arrives
- process who shapes the ask
- process what settles scope
- process the wait
- delivery ship cadence
- engineering who writes the code
- engineering where the model learns
- engineering output consistency
- engineering correction load
- quality the gate to production
- quality who reviews
- engineering what runs unattended
- engineering agent handoffs
- engineering human checkpoints
- the system what tunes the pipelines
- design how design lands
- go-to-market how work reaches GTM
- product what planning commits
- the system what improves quality
-
Work moves through requirements, design, build, and test as sequential handoffs. The plan is fixed at the point of least knowledge and defended from there.
Measure: Cycle time measured in months
-
Work is sliced into increments that reach production on a cadence. What you learn inside the loop changes what gets built next.
Measure: Deployment frequency · share of work shipped in under two weeks
-
The editor proposes the next lines. Engineers type less and read more, but still own the structure of every change.
Measure: Suggestion acceptance rate · time to a first working draft
-
Changes start as a stated intent rather than a keystroke. The craft shifts from writing code to describing the change and judging the diff.
Measure: Share of merged diffs machine-drafted · review time per pull request
-
The knowledge a model needs is stored, versioned, and loaded on purpose. Prompts get shorter and output gets consistent across people.
Measure: Variance in output quality between engineers · rework rate on generated changes
-
Engineer and model work out the specification together, then generate against it. Discovery collapses from weeks to hours because the spec is the thing you argue about and the thing you build from.
Measure: Time from problem statement to merged change · discovery as a share of cycle time
-
An agent takes a bounded unit of work from ticket to pull request unattended. Humans set the boundary and judge the result rather than driving each step.
Measure: Share of merged pull requests opened by agents · escape rate on agent-authored changes
-
Specialized agents for spec, build, test, review, and compliance hand work to each other under an explicit protocol. Engineers design the pipeline instead of running the steps.
Measure: Throughput per engineer · share of workflows completing without intervention
-
The system improves from its own results. Review comments, escaped defects, and production telemetry change how future work gets generated without anyone rewriting a prompt.
Measure: Quality trend at flat headcount · rate of improvement per unit of work
Phase-gated delivery
Work moves through requirements, design, build, and test as sequential handoffs. The plan is fixed at the point of least knowledge and defended from there.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Pressure is building to move up
What keeps teams here
Governance that rewards plan adherence over shipped outcomes, and funding that releases against phase completion rather than working software.
The move to stage 2
Cut work into thin slices that each reach production. Replace phase sign-off with a demo of something running.
Iterative delivery
Work is sliced into increments that reach production on a cadence. What you learn inside the loop changes what gets built next.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Pressure is building to move up
What keeps teams here
Iteration theatre: ceremonies that run on schedule while releases don't. Requests still arriving as prescribed solutions, so the loop learns nothing.
The move to stage 3
Put an assistant in the editor for everyone. Start measuring how much of a merged diff was drafted by a machine.
Assisted authoring
The editor proposes the next lines. Engineers type less and read more, but still own the structure of every change.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Pressure is building to move up
What keeps teams here
Treating the tool as autocomplete and nothing more. No shared conventions in the repo, so every suggestion fights the codebase it lands in.
The move to stage 4
Move authorship out of the tab key and into a conversation. Ask for the change, then review the diff.
Prompt-driven development
Changes start as a stated intent rather than a keystroke. The craft shifts from writing code to describing the change and judging the diff.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Pressure is building to move up
What keeps teams here
One-shot prompting with no supporting context, so quality is luck. Reviewers rubber-stamping generated diffs because reading them is harder than writing them was.
The move to stage 5
Make context durable. Commit the rules, patterns, and schemas the model needs into the repository where they're reviewed like code.
Context engineering
The knowledge a model needs is stored, versioned, and loaded on purpose. Prompts get shorter and output gets consistent across people.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Pressure is building to move up
What keeps teams here
Context rot: stale rules nobody prunes, and context that describes the codebase somebody wishes existed rather than the one in production.
The move to stage 6
Bring the model upstream of the code. Turn a problem statement into a reviewed specification before generation starts.
Spec-driven development
Engineer and model work out the specification together, then generate against it. Discovery collapses from weeks to hours because the spec is the thing you argue about and the thing you build from.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Pressure is building to move up
What keeps teams here
Stakeholders who hand over solutions instead of problems. A culture that treats the spec as a document to file rather than the decision to fight about.
The move to stage 7
Let one scoped, reversible class of work run end to end without supervision. Choose the place where the blast radius is smallest.
Delegated execution
An agent takes a bounded unit of work from ticket to pull request unattended. Humans set the boundary and judge the result rather than driving each step.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Pressure is building to move up
What keeps teams here
Autonomy without guardrails on blast radius, secrets, and protected data. Or the opposite: approval gates so heavy the agent saves nobody any time.
The move to stage 8
Chain the specialists. Give each handoff a contract, and put the human checkpoint where the risk actually concentrates.
Multi-agent orchestration
Specialized agents for spec, build, test, review, and compliance hand work to each other under an explicit protocol. Engineers design the pipeline instead of running the steps.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Pressure is building to move up
What keeps teams here
Orchestration sprawl, with chains nobody owns. Handoffs that drop context, so the work degrades a little at every hop.
The move to stage 9
Close the loop. Feed review outcomes, defect data, and production telemetry back into the chains that produced them.
Compounding systems
The system improves from its own results. Review comments, escaped defects, and production telemetry change how future work gets generated without anyone rewriting a prompt.
Nothing checked, or too few entry signals. If the stage below this one still describes the team better, work there first.
01 · Entering
The first signs you're operating this way
02 · Established
The stage is how the org actually runs
03 · Cresting
Past the edge of the map
What keeps teams here
Learning loops without evaluation, so the system drifts and nobody notices. Feedback that encodes reviewer taste instead of outcome quality.
Where it goes from here
There's no fixed next rung here. Keep the evaluations honest, keep the loop fed, and let the compounding do the work.