Shared result
Stage 2: Wide Individual Adoption
Most engineers have access and use AI at least sometimes, but 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.
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
Coordination. The stage ends with shared standards, structured education, and a pilot team that redesigns its workflow first.
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.
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.
What holds you here
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.
Typical next move
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.
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 3 · Next
Structured Adoption
Needs
Shared AI configuration as the default, with standards enforced in linters, hooks and CI.
Most engineers working agentically, with an agent taking on whole tasks.
Stage 4
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.
Your next three moves
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.
Run enablement as a structured programme
Hands-on, on real backlog work, spread over several weeks so habits settle. Teach the failure modes first: hallucination, context pollution, overloaded tool sets.
Let one team redesign its workflow first
Enablement has happened; the workflow hasn’t changed yet. Have one small, mixed team rebuild how it plans, delegates and reviews around agents before the rest follow.
What to instrument
At this rung, start with:
- Lead time, change failure rate and time to restore against the baseline.
- PR size, the earliest sign that batches are growing.