Everyone wants the upside of AI-assisted development — faster delivery, fewer bottlenecks, happier engineers.
But DORA’s 2025 State of AI-Assisted Software Development tells a harder truth: AI isn’t a shortcut. It’s a stress test. It magnifies your strengths and multiplies your weaknesses.
Nearly 90% of engineering teams now use AI. Yet only a fraction sees real performance gains. The difference isn’t which tool you buy — it’s how you lead.
Below are nine practical lessons from the DORA research to help you harness AI as a force multiplier — not a chaos machine.
1. Treat AI as an Amplifier, Not a Silver Bullet
AI doesn’t fix broken systems; it exposes them faster. Before investing in more AI tools, invest in your processes, architecture, and leadership practices.
Why is that
AI coding assistants mirror your repos, patterns, and prompts. If your architecture is messy, tests are missing, or standards are inconsistent, AI will reproduce and scale those flaws.
AI generates, but you still decide what it ships. If your culture defaults to “we’ll fix it later,” skips reviews, neglects tests, and documents poorly, AI will only speed up the mess.
I cover this in a free chapter of my book “Why AI Works for Them but Not for You”.
DORA 2025 says: AI improves throughput but also increases instability where underlying systems are weak.
2. Invest in a Strong Internal Platform
A unified, high-quality internal platform enhances the developer experience, reduces friction, and makes AI more useful rather than chaotic.
Why is that
Platform teams standardize inputs, accelerate delivery pipelines, and reduce cognitive load. This consistency provides AI with reliable scaffolds to generate from, rather than a patchwork of ad hoc tools.
Automated reviews, testing, and deployments enable the AI–human feedback cycle to run at high speed without burnout. Guardrails — policy-as-code, security scanning, automated rollbacks — allow teams to experiment with AI safely.
My experience
At my full-time job, I lead platform engineering (DevOps, backend, frontend). We follow Team Topologies principles, mainly to serve product engineering teams as a multiplier.
A few examples of how we amplify AI impact:
Good quality Design System so AI can use UI components as LEGO bricks and build prototypes quickly
OpenAPI docs, so AI can use them as a payload example when generating API clients
Prompts/specs for Logging Standards, REST standards, or Testing standards, so AI can generate code that is aligned to those
Templates, e.g., for micro frontend, so engineers can use AI to quickly design, hide behind a feature flag, and push a new app to production, usually in less than 1 week
DORA 2025 says: 90% of orgs now have platform engineering; only those with quality platforms unlock great AI value.
Supplemental read: AI Thrives on Clear Context and Tight Constraints
3. Use Value Stream Management (VSM) to Turn Local Gains into Real Outcomes
Without a systems view, AI creates “local pockets of productivity” that don’t translate into customer impact. Value Stream Management (VSM) solves this by making the entire flow of work visible—from idea to customer outcome—so leaders can see where value is added, delayed, or lost.
VSM in simple terms
Think of software delivery as an end-to-end stream.
Map every step from customer need → prioritization → coding → testing → deployment → product impact.
Measure delays, handoffs, and waste.
Act to shorten the loop from “we think” to “we know.”
Why it works in the AI era
AI boosts local throughput—more commits, more code—but without VSM you risk drowning downstream teams in unreviewed work or rework.
Product-level feedback loops: AI-generated code is judged on business outcomes, not just volume.
Product Operating Model: engineers shift from “task takers” to “value stewards” (read more about Product Operating Model here).
Force multiplier: Orgs practicing VSM achieve significantly higher performance from the same AI investments.
Signals your VSM is healthy
Business outcomes and technical metrics are reviewed together (DORA metrics + product KPIs).
Teams discuss flow efficiency and customer impact during retros, not just ticket burn-down.
Decisions about AI use (what to automate, where to deploy) are made with visibility of downstream effects.
DORA 2025 says: the biggest impact of AI is on individuals’ effectiveness. Those are your early adopters, very likely 10x engineers (I covered it here). However, even if one of your teams can deploy multiple times a week, if the VSM includes a monolithic system that is deployed only once a month, your optimization will be local.
To truly leverage AI for organizational performance, identify the biggest bottlenecks in the entire process.
4. Locate Your Team in One of the Seven Profiles
Knowing your DORA metrics tells you what’s happening. The seven profiles tell you why.
Linking delivery performance with human factors like burnout, friction, and engagement. Without this, leaders treat symptoms instead of causes.
Why now:
AI amplifies your current state. If you’re “Constrained by Process,” AI will just spin the treadmill faster. If you’re “Harmonious,” AI elevates your edge.
Knowing your profile tells you where to shore up before adding AI fuel.
Use it as a diagnostic, not a label. Being “Legacy Bottleneck” or “Constrained by Process” isn’t a verdict—it’s a starting point. The goal is to progress from high-friction clusters toward Pragmatic or Harmonious states, not overnight but via continuous improvement.
5. Build Fast Feedback Loops and Loosely Coupled Architectures
DORA consistently shows fast feedback loops + loosely coupled systems as the single most reliable predictor of high performance. When AI accelerates code generation, your ability to evaluate, test, and deploy at the same speed becomes the bottleneck.
This was one of my experiences when building in full AI Agentic mode: Tests and Static Analysis Are Your Lifeline - basically, the better your tests (unit, lint, regular build process), the more autonomous the AI agent is, as the most bugs are caught during a single AI session, without reaching out to you.
Key reasons fast feedback + decoupling matter in the AI era
Nyquist principle: Faster systems require faster control loops — you, the operator, are the bottleneck.
Loosely coupled architecture = parallel work: Teams can develop, test, and deploy independently without massive coordination overhead.
Immediate signal on quality: Automated tests, CI/CD, telemetry flag AI-generated defects early.
Shorter recovery times: Smaller, more frequent releases plus decoupled services mean rollback is easier.
Psychological safety: Developers experiment without fear of massive breakage because the blast radius is limited and the signal is quick.
DORA 2025 says:
Quoted in the report: Adidas’ AI pilot showed 20–30% productivity gains and 50% more “Happy Time” only for teams with decoupled architectures and rapid feedback loops. Teams locked into tightly coupled ERP systems saw almost no AI benefits.
6. Customize AI Tools to Reduce Cognitive Load
The DORA report and UC Berkeley study show a clear split:
Mechanical tasks (boilerplate, package installs, repetitive code) → AI boosts speed and accuracy.
Interpretive tasks (understanding cryptic code, architecture decisions, debugging edge cases) → AI can increase cognitive load if it keeps surfacing suggestions at the wrong time.
This happens because AI adds context-switching costs: your brain must evaluate each suggestion while simultaneously solving a hard problem. Left unchecked, this slows developers down, erodes comprehension, and undermines trust in AI.
Key reasons customization helps:
Reduce “always-on” noise: Turning off inline suggestions for complex tasks allows developers to focus, while enabling them for rote tasks lets AI shine.
Align AI with your process: Repo-level configuration files, prompt templates, and linked documentation help AI assistants adhere to your organization’s coding standards and patterns.
Support operator-style workflows: You can decide when to “pull” AI (on-demand) vs. when to let it “push” suggestions automatically.
Preserve comprehension: Developers can intentionally choose when to let AI autocomplete vs. when to reason things out themselves, improving long-term understanding and code quality.
My experience:
When building Leader’s Metrics in full agentic mode, I realized I need multiple personas (PM AI Agent, Software Engineer AI Agent) and a few types of processes (prototyping, bug fixing, refactoring, regular implementation). This reduced friction and improved focus.
You can read about example customization in Prototyping with AI Agents (pt.1).
7. Aim for Speed and Stability — and Measure It Relentlessly
The best teams—Pragmatic Performers + Harmonious High-Achievers—hit high velocity and high reliability simultaneously. Nearly 40% of the DORA sample achieves this today.
The lesson for leaders: stop accepting “fast but sloppy” or “stable but slow.” High throughput with low instability is an achievable benchmark if you design for it.
How to do it:
Small, safe batches (microservices, feature flags, progressive delivery).
Strong evals + telemetry to close the loop between code committed and impact observed.
Shorten lead time + recovery time.
Align engineering work to customer outcomes, not just technical velocity.
I covered practical aspects of these, here: Continuous Deployment in Practice.
What does high throughput with low instability mean? Focus on Core DORA metrics and track them continuously:
As per research, these metrics have a strong correlation with organizational performance.
8. Scale Trust and Autonomy Gradually — Use the Autonomy Slider
High AI adoption and productivity gains coexist with healthy skepticism. 70% trust AI output, but 30% remain skeptical. Successful teams scale autonomy in deliberate stages, backed by strong evals and risk-aware guardrails.
Andrey Karpathy’s “autonomy slider” frames AI like a self-driving car: lane assist first, autopilot later. Your own notes about risk classes and reversibility take this a step further — tying autonomy to the actual risk of each change.
Autonomy Slider + Risk Classes
Here are the risk classes I introduced in my book From Engineers to Operators:
Operator Rule: Autonomy only increases when Gates <10 min and Rollback <1 min are real in practice.
This makes adoption visible: not just whether AI is used, but how deeply it’s trusted.
Why gradual autonomy works:
Containment: Small, low-risk tasks limit blast radius and accelerate feedback loops, letting you refine evals before moving up.
Trust building: Developers see AI behaving correctly at RC-0/RC-1, which earns the credibility to move to RC-2/RC-3.
Stability by design: Matching autonomy level to risk class aligns with DORA’s core finding: speed without stability is sabotage.
Reversibility & safety nets: Feature flags, automated rollbacks, and gates make autonomy reversible; this is how you scale without eroding trust.
Metrics to watch (DORA + your own resilience lens):
Time to Restore Service (MTTR): Stay <1 day, ideally <1 hour.
Reversibility by Default: % of features behind flags.
Incident Contributor Rate: % of incidents linked to AI-generated diffs.
Change Failure Rate: Track for each risk class as autonomy increases.
A spike in High Autonomy without matching gains in resilience metrics is a warning light — time to slow down and reinforce your evals.
9. Bonus Point — Explore Agent Mode to Stay Ahead
One stat that caught my attention in DORA 2025: 61% of respondents never interact with Agent Mode.
Agent Mode is still nuanced, but it’s also one of the biggest frontiers of AI adoption in engineering. It’s not enough to buy access to ChatGPT, Copilot, or Cursor — we need to explore opportunities more aggressively.
If you want to explore this area further, check my stories, where I built a full-fledged application in 100% Agentic mode (at the time of writing, almost 200k LoC were generated by AI; I wrote probably less than 1k).
You can read about my experiences here:
However, the best approach is to try it yourself — with Claude Code, Copilot Agent Mode, or ChatGPT Codex — and measure the results against your DORA metrics.
Closing Thoughts
DORA 2025 gives engineering leaders a roadmap. AI isn’t a bolt-on tool — it’s a catalyst for redesigning how you work.
Start by knowing your team’s profile, tightening your feedback loops, investing in your platform, and managing the human side of engineering (burnout, friction, training). Done right, AI won’t just speed up your teams — it will make them better.
AI isn’t coming to replace engineering leaders. It’s coming to reveal them.