Agentic AI adoption for software engineering teams
Agentic Software Engineering
A sustainable, progressive and measurable path to agentic AI in software engineering.
By Abhiroop Bhatnagar, agentic AI researcher
- Copy-pasteCode copied between a chat app and the IDE
- AutocompleteIn-editor suggestions as you type
- 1 human : 1 agentOne engineer steering one agent, human in the loop
- 1 human : many agentsOne engineer orchestrating many agents and sub-agents
- Event-driven agentsA software factory that humans build and manage
Problem statement
Achieve AI adoption Level 5 in a sustainable, progressive and measurable manner
Sustainable
No disruption to client-facing services or to the long-term health of engineering.
Progressive
Stage by stage, with each stage ready before the next one starts.
Measurable
Tracked against DORA and VPAC baselines, month on month.
Pain points
What’s getting in the way today
Uneven adoption
A big gap between top and median engineers, and top engineers’ skills are hard to teach.
Eroding ownership
Looser access to agents reduces attention to detail and ownership, so bugs rise.
No visibility
Hard to track adoption across the team or set benchmarks for progress.
Shifting bottlenecks
Code generation speeds up, and code review becomes the new bottleneck.
Delivery risk
Unclear if new tools will disrupt client services or long-term engineering health.
No playbook
No stage-based plan for adoption; it’s experimental and gut-driven.
No fast track
No clear way to accelerate the move to AI-native engineering.
Too much noise
Skills, prompts, context, MCP, guardrails, sandboxes, evals, all while running the business.
Search for a solution
How the framework was built
Engineering practice
- Frontier AI labs
- AI-native startups
- How big tech practices are evolving
Theory
- Agile theory and principles
- Software engineering management methodologies
- The nature of information
Technology
- Deep research on agentic AI capabilities
- Its fundamental limitations
Outcome: four pillars of agentic AI adoption
Research outcome
Four pillars of agentic AI adoption
Tools
The agents, IDEs and platforms engineers use, from chatbots to cloud agents.
Tools by stageSkills
Engineering judgement, plus agentic skills such as context, steering, verification and evals.
Skills by stageProcesses
How work flows from plan to production: Agile, adapted for agents.
Agile with AgentsInfra
The delivery pipeline (CI/CD, deployment, observability), measured by DORA.
Grade your pipelineMost teams start with tools. A sustainable adoption starts with infra.
Adoption progression
Reverse the order of adoption
How teams experiment today
Bottlenecks are discovered after the tools roll out.
Sustainable and scalable
Each layer is ready before the next one lands.
Infra and process set the ceiling for what skills and tools can deliver, so they come first.
Two ways teams adopt AI
Org-based vs individual adoption
Org-based: sustainable
Every stage moves through infra, processes, skills and tools, in that order.
Individual: tool-led
Engineers bounce between skills and tools; infra and process never catch up.
Why progressive adoption
Benefits of progressive adoption
No disruption
Sustainable, trackable adoption with no disruption to existing services.
Hype-proof tool choices
Structured, stage-based evaluation of tools, independent of the hype.
Readiness gates
Readiness is evaluated at every stage before tools are rolled out.
Predictable process change
Gradual evolution of process for the whole team, with no sudden surprises.
Planned investment
Time and capital planned upfront.
Infra ahead of demand
Infra planned upfront, not bottlenecks discovered after the fact.
Growth benchmarks
Progress and performance benchmarks that encourage individual growth.
Rides every new model
Steady adoption that still captures the benefits of each new model release.
Progressive adoption
The progression matrix
Org-based adoption moves one row at a time, across all four pillars, starting with infra. Select a pillar heading to see it in detail.
| Adoption stage | Infra | Processes | Skills | Tools |
|---|---|---|---|---|
| 1Copy-paste | DORA stage 1 | Agile | Role-appropriate engineering judgement and knowledge | Chatbot subscriptions |
| 2Autocomplete | DORA stage 2 | Agile | Role-appropriate engineering judgement and knowledge | IDE autocomplete assistants |
| 31 : 1 | DORA stage 3 | Agile with Agents | + Context, steering, sandboxing, verification | CLI coding agents |
| 41 : many | DORA stage 4 | Agile with Agents | + Harness design, multi-agent workflows, evals | Multi-agent orchestration |
| 5Event-driven | DORA stage 5 | Agile with Agents | + Cloud sandboxing, trigger design, spec verification | Cloud and background agents |
Infra: measure delivery with DORA
Measured from the CI/CD pipeline, code repository, monitoring and project tracker.
Lead Time for Changes
Time from a code commit to running in production.
Deployment Frequency
How often you ship to production.
Change Failure Rate
Share of deployments that need a fix, hotfix or rollback.
Failed Deployment Recovery Time
How long it takes to restore service after a bad deployment.
Rework Rate
Share of deployments that were unplanned fixes.
Grade your DORA stage
Pick the band each metric falls in today. Your DORA stage is your lowest stage across all five metrics, because a system is only as fast as its slowest component (the Theory of Constraints).
DORA stage caps your AI adoption
Agents speed up code generation, but a team can only sustain the adoption stage its delivery pipeline can absorb.
Is your pipeline ready for agents?
The metric in the not-ready column is the bottleneck to fix before moving to the next adoption stage.
| Metric | Ready for agents | Not ready |
|---|---|---|
| Lead time (LT) | Short: agentic code ships quickly | Long: agentic code piles up before deployment, leading to infrequent big-bang releases |
| Deployment frequency (DF) | High: agentic code ships quickly | Low: agentic code piles up waiting to ship |
| Change failure rate (CFR) | Low: agentic code can be pushed reliably | High: agentic code can’t be pushed reliably; bugs and issues keep increasing |
| Failed deployment recovery time (FDRT) | Short: agentic code can be fixed quickly | Long: it can’t be fixed or rolled back quickly, so outages, customer reports and degraded SLAs follow |
| Rework rate (RR) | Low: agentic code can be deployed reliably | High: agentic code needs more rework |
What breaks with agents
Agile today
- Scrum
- Sprint schedule, planning, effort estimation, retros, backlog
- Kanban
- Board, tracking, WIP
- Gitflow
- Long-lived feature branches
- Peer code reviews
- Line-by-line
Sprints stop making sense
Agents work in tokens, not time, so time-boxing weeks fails while work can run in parallel.
Line-by-line review doesn’t scale
Reviewing every line of agent-generated code is unsustainable.
Long-lived branches multiply
They drift from main and each other; more agents means more branches, and they become unmaintainable.
Estimates become unreliable
Effort estimation turns inaccurate.
Cognitive debt grows
Agent-produced code outpaces human understanding.
Agile with Agents
No fixed sprints
A continuous stream of work tracked on Kanban.
WIP kept in check
Work in progress deliberately limited.
VPAC retros
Periodic retros with one aim: raise VPAC metrics sustainably.
Trunk-based development
Everyone integrates on main, with no long-lived branches.
20% AI experimentation
Results shared in regular AI learning sessions.
MOURs
Short AI-generated quizzes that track cognitive debt.
Onboarding agents
Self-learning agents for codebases and systems.
Adversarial verification
Automated adversarial verifications and reviews.
Customer feedback loops
Fast, high-signal loops with each user and customer segment.
Review effort follows criticality
The review level is set automatically per change. Try a change below to see which level it gets.
Blast radius
How much of the codebase, features or user base the change touches.
Reversibility
How easily the change can be undone.
Automatic
Low criticality: automated, layered verifications.
High-level review
A human reviews the change at the design level.
Line-by-line
High criticality: manual self-review and approval, plus manual peer review and approval.
MOURs keep cognitive debt visible
What
My Own Understanding Reviews: periodic quizzes about the codebase, architecture, product behaviour and more.
Why
To track the cognitive debt building up in the team as agents write more of the code.
How
Auto-generated by AI, with a colleague as an optional proctor. A tool for self-evaluation and self-awareness, also used to judge onboarding agents’ progress.
How deep
Depth follows criticality: less critical areas are quizzed at a high level, more critical areas line by line.
Principles for process design
Small batches
Trunk-based deployments
Main is always green
Frequent deployments
Automated verifications
Layered and directed
Flag-based releases
Loosely coupled architecture
Automated risk assessments
Risk-based review levels
Automatic, high-level, line-by-line
Built around human bottlenecks
Understanding, judgement, verification
Skills needed at each stage
| Stage | Skills added |
|---|---|
| 1 – 2Copy-paste, autocomplete | Role-appropriate engineering judgement and knowledge |
| 31 : 1 | + Context and memory management, agentic steering, skill design, sandboxing, prompt engineering, model selection and optimisation, automated verifications, reversibility checks and risk assessments |
| 41 : many | + Harness design, multi-agent workflows, adversarial verifications, token monitoring and optimisation, evals |
| 5Event-driven | + Cloud-based sandboxing, trigger design, automated spec verifications |
Tools to adopt at each stage
Tools are evaluated per stage, independent of the hype, and rolled out only once infra, processes and skills are ready.
- 1
Copy-paste
- ChatGPT, Claude, Gemini, Grok
- Or any chatbot subscription
- 2
Autocomplete
- Gemini Code Assist
- GitHub Copilot
- Tabnine
- 3
1 : 1
- Claude Code
- Codex CLI
- Antigravity
- OpenCode
- 4
1 : many
- Stage 3 tools, plus:
- Herdr
- HumanLayer
- Factory.ai
- 5
Event-driven
- Factory.ai, Devin, Amp
- Cursor Cloud Agents
- Or a self-hosted harness with cloud sandboxes
Tool names are examples at the time of writing. The stage each tool serves matters more than the brand.
Metrics
Measuring success with VPAC
Value Added
Building the right thing: solving the right problem with the correct solution.
Productivity
Achieving that value with the optimal amount of resources.
Agility
Being able to respond to change.
Culture Health
Trusting colleagues, being accountable for output and owning the outcome.
Measuring value added
Average incremental value added to the business in a chosen period.
Outcome-based
Value added to the business
Output-based
PRs, number of features shipped
Measuring productivity
Resources spent are measured by the PM team with Finance. The CFO audits the methodology.
Measuring agility
Time to integrate a customer signal into the product.
Upper limit: your DORA stage
Feedback can only be incorporated as fast as changes roll out, which is what DORA measures.
Before agents
DORA metrics were bottlenecked by human developer capacity.
After agents
With the right infra and process, the feedback cycle can become much faster.
Measuring culture health
Trust
Being able to trust your colleagues
Accountability
Taking accountability for your output
Ownership
Taking ownership of the outcome
How it’s measured
- Periodic surveys and questionnaires
- eNPS (employee Net Promoter Score)
- Methodology drawn from Accelerate and DevOps research