Shared result
Stage 5: Operational AI
AI has spread beyond the IDE into CI/CD, code review automation, infrastructure as code, on-call and security scanning, and beyond engineering into product and design.
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
Scale and product flow, because engineering stops being the slowest stage. The stage ends with factory infrastructure.
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.
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.
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 6 · Next
Lights-on Factory
Needs
Isolated per-task environments the platform provisions on demand.
Agents writing about half or more of the merged code.
Stage 7
Dark Factory
Needs
Validation on end-to-end scenarios the agents can’t see.
Delegation boundaries written down per class of work.
People writing specs, agents implementing, and validation deciding what ships.
Your next three moves
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.
Pull product into the build loop
Once engineering stops being the slowest stage, the spec becomes the constraint. Product and engineering need specs detailed enough for agents to build from.
Tier autonomy by class of change
Documentation can auto-merge after validation, application code gets one human approver, migrations need two approvals. Enforce the tiers in CI rather than in a checklist.
What to instrument
At this rung, start with:
- Time spent in each stage of the value stream, including product and spec work.
- Human attention per delivered outcome.