At QCon San Francisco 2025, Dr. Nicole Forsgren delivered a keynote focusing on the paradoxical impact of Artificial Intelligence (AI) on software development workflows. While AI has drastically accelerated code generation and prototyping, its speed only exposes and amplifies existing bottlenecks in deployment and organizational processes.
The core issue is that code can be written in minutes, but in large organizations, deployment can still take months. This systemic friction prevents companies from realizing the value of their faster development cycles, forcing a necessary strategic shift from optimizing productivity to optimizing Developer Experience (DevEx).
Friction is defined as the non-productive administrative and coordination delays that interrupt a developer’s work. Common sources of friction include:
- Delayed onboarding for new hires.
- Lingering pull requests and code reviews.
- Manual coordination across multiple teams and tools for deployment.
- Waiting for approvals and system access.
Studies estimate that roughly 31% of a developer’s time is lost to this non-productive friction. Moreover, this lost time costs industries hundreds of billions in lost GDP each year, underscoring that reducing friction is no longer just about convenience; it is a matter of competitive survival and talent retention.
Forsgren argues that improving “productivity” is the wrong goal; the focus should instead be on DevEx, which ensures developers are working in a sustainable, high-leverage way and is measured across three core areas:
- Fast Feedback Loops: How quickly a developer can go from question to answer (e.g., search results, code review, test run).
- Flow State: The ability to focus and engage in deep work.
- Manageable Cognitive Load: The limited mental capacity dedicated to focusing on complex problems, which should not be consumed by fighting complex processes or noisy test suites.
AI fundamentally changes the flow state, shifting it to a rapid cycle of prompting, reviewing, and rewriting code, rather than long periods of deep, uninterrupted coding [cite: transcript]. This shift makes the subsequent steps, testing and deployment, the most crucial bottlenecks.
To drive improvement, organizations should rely on established metrics and systematic strategies:
- DORA Metrics: Use the four DORA metrics (deployment frequency, change lead time, change failure rate, and Mean Time To Recover – MTTR) to benchmark and track performance reliably. High-performing organizations deploy rapidly, minimize failure rates (often below 15%), and go live in under an hour.
- Building the Business Case: Successful transformation requires strategies to convince leadership:
- Visibility and Accountability: Make friction points visible to executives (e.g., stack-ranking error rates by team owner) to create an immediate priority.
- Simple Data with Clear Action: Provide dashboards that move beyond aggregated data to simple, actionable insights (e.g., “Build times increased 20% in this specific repo”).
- Tying Improvements to Business Outcomes: Focus on documented savings and increased developer satisfaction, translating improvements into millions in documented savings, as seen in case studies at Block and Amazon.
While AI solves the coding bottleneck, it introduces new measurement and workflow challenges:
- New Metrics: Teams may need to track metrics like prompt response time and trust calibration (the degree to which developers trust AI-generated code).
- Cognitive Overload: AI tools can increase tool proliferation. Improvement efforts must focus on integrating and simplifying the current toolchain rather than simply introducing more options.
- Human Insight: System data tells you what is happening, but human interviews and surveys are still vital to understanding why friction occurs.
The recommended strategy for change is a seven-step process that emphasizes starting small: Talk to people to find immediate pain points, secure a quick win that is visible and benefits multiple teams, then collect data, set a strategy, and scale the change. The crucial mistake to avoid is treating improvement as a one-off project; instead, it requires small, compound changes engineered into the system over time, providing a concrete roadmap for lasting change.
