Shared result
Stage 3: Structured Adoption
Standards exist and are enforced through tooling, linting and CI. Education has run as a structured programme, and most developers have moved from autocomplete to agentic work.
Your rung is the highest one where every capability below it is in place. It describes one team on one codebase; other teams in your organisation may sit on different rungs.
Active constraint
Review, because output now arrives faster than senior engineers can carefully read it. The stage ends when review has been redesigned and the test suite is trusted.
Discovery
How you recognise it
- No formal adoption yet.
- Engineers experiment individually, on personal accounts.
- Leadership is aware of it without acting on it.
What holds you here
Organisational permission. The stage ends when leadership sees enough to fund a pilot.
Typical next move
Get a funded pilot
Stage 0 ends when leadership sees enough to fund a formal pilot. Make the case with a scoped team, a time box and the evidence you will bring back.
How you recognise it
- A pilot group, usually 5–10% of engineers, has formal access.
- The most motivated engineers learn quickly.
- The rest of the organisation has no reliable signal about whether any of it is working.
What holds you here
The missing signal. The stage ends when the pilot produces credible evidence on adoption, satisfaction and output.
Typical next move
Make the pilot produce evidence
Take a baseline before the pilot starts, then report adoption, satisfaction and output against it. Without that signal the rest of the organisation cannot tell whether it is working.
How you recognise it
- Most engineers have access and use AI at least sometimes.
- Everyone uses it their own way, with different tools, prompts and conventions on the same codebase.
- Output rises, quality varies, and the dashboards look good — which is why the plateau stays invisible from the top.
What holds you here
Coordination. The stage ends with shared standards, structured education, and a pilot team that redesigns its workflow first.
Typical next move
Decide tools and guardrails before expanding
Pick the agent harness, the security model, the context standard and the review process, then encode the standards in linters, hooks and CI policy so they apply to every change.
Discipline
How you recognise it
- Standards are enforced through tooling, linting and CI, and most developers have moved from autocomplete to agentic work.
- Output arrives faster than senior engineers can carefully read it, so reviewers skim, trust the tests, or trust the author.
- Test coverage rises while the team’s actual confidence in the code falls.
How you recognise it
- Several agents per developer is normal, running in sandboxed environments.
- Context files grow past the point where the model can make good use of them.
- Developers approve pull requests they could not have written themselves.
- An agent can hold the developer’s credentials, the team’s data and network access at the same time — the lethal trifecta.
What holds you here
Context quality, security and ownership. The stage ends with scoped agent permissions and clear ownership rules.
Typical next move
Break the lethal trifecta
Scope credentials to the task, keep production secrets out of reach and restrict network egress, so no agent combines private data, untrusted content and a way to send data out.
How you recognise it
- AI runs beyond the IDE: CI/CD, code review automation, infrastructure as code, on-call and security scanning.
- Engineering stops being the slowest stage, and the product becomes the bottleneck.
- Specifications detailed enough for human-speed work do not carry enough information for agents.
What holds you here
Scale and product flow, because engineering stops being the slowest stage. The stage ends with factory infrastructure.
Typical next move
Build the agent platform as a product
Give teams context, tools, environments, permissions and validation as self-service, so every agent task runs in its own isolated environment. This is the factory infrastructure Stage 5 ends with.
Factory
How you recognise it
- Agents produce most of the code, and humans focus on review and approval.
- Agents cannot reliably check their own work, so the validation pipeline sets the pace for everything.
What holds you here
Validation at machine speed, because agents cannot reliably check their own work, so the validation pipeline sets the pace for everything.
Typical next move
Build validation agents can’t game
Agents cannot reliably check their own work. Keep end-to-end scenarios outside the codebase the agents can see, and never let the agent that wrote the code decide whether it is acceptable.
How you recognise it
- Humans specify, and agents implement.
- Validation carries most of the weight that code review used to carry.
What holds you here
The frontier. Too few teams have reached this stage yet to say what they hit next.
Typical next move
Build validation agents can’t game
Agents cannot reliably check their own work. Keep end-to-end scenarios outside the codebase the agents can see, and never let the agent that wrote the code decide whether it is acceptable.
Frontier
How you recognise it
- Unknown so far. Practices are still forming, and few teams are here.
What holds you here
Unknown. We haven’t seen any teams go past the dark factory yet.
Typical next move
A placeholder, not a prediction
Stage 7 itself may turn out to be temporary, so we keep 8+ on the map as a placeholder rather than a prediction.
Route up
Stage 4 · Next
Agentic Team
Needs
Review rules for AI-generated code, enforced in tooling.
Fast CI the team trusts, with behaviour tests that catch regressions.
Agents running in containers or sandboxes, not on the engineer’s machine as the engineer.
A short, structured context file in every repo.
Several agents per engineer, running in parallel.
Stage 5
Operational AI
Needs
Scoped, short-lived credentials, no production secrets and restricted egress for every agent.
An explicit rule that names an owner for every change.
Context files, ADRs and schemas maintained like production code.
Agents across the delivery pipeline: CI/CD, infrastructure as code, security scanning, on-call and review.
Stage 6
Lights-on Factory
Needs
Isolated per-task environments the platform provisions on demand.
Agents writing about half or more of the merged code.
Your next three moves
Redesign review for AI-generated code
Write down how AI-generated code is reviewed differently, and enforce it in tooling: PR size limits, required checks, and an author who has read every diff they ship.
Fix foundations before features
Point AI at test coverage and the build before feature work, until the suite catches behaviour regressions reliably.
Turn CI into a real-time feedback loop
Make the pipeline fast and trustworthy enough that agents run it before they push. An agent without a check it can run cannot tell when it is wrong.
What to instrument
At this rung, start with:
- Time waiting for review, where the extra code queues first.
- PR size and deployment rework rate.
- Work outside normal hours.