How to Improve Developer Experience: DX for Teams That Ship With AI Agents

To improve developer experience (DX), you have to fix the system your developers and their AI agents work in together: the context agents get, the speed of verification, the review process, and the platform underneath.

Writing code is no longer the slow part. In the Stack Overflow 2026 Developer Survey, 66% of respondents say they use coding assistants or coding agents at work, and engineers at leading companies now run five to ten agents in parallel.

Yet developers are less happy than a year ago, and many organizations don't ship faster despite paying for all those tokens.

What Is Developer Experience When AI Agents Write Most of the Code?

Developer experience is everything that influences engineers when they build software. That includes tools, processes, documentation, team culture, and the quality of the codebase itself. Since the start of the Generative AI revolution, all of these areas have seen massive changes.

In October 2026, The Pragmatic Engineer summed up the state of the industry: practically nobody writes code by hand anymore. The most productive engineers he spoke with run several agents at once. Boris Cherny, who created Claude Code, keeps five terminal tabs of local agents plus five to ten more in the browser. Cockroach Labs cofounder Peter Mattis says his "cognitive overhead is about 5-10 agent sessions concurrently." According to data GitHub shared with The Pragmatic Engineer, agent-authored pull requests outnumbered human-authored ones on the platform in August 2026. On Linear, agents have created more issues than humans every month since July.

The tools reflect this. Cursor 3.0 rebuilt the product around an agent-first interface, Google's Antigravity 2.0 moved away from the IDE concept, and JetBrains launched Air, an environment built for running agents in parallel. According to Orosz, most mid-sized and larger tech companies have built their own agent harnesses. Stripe has Minions, Block has Goose, Shopify has River, and Ramp has Inspect.

The broader developer population is moving in the same direction, if more slowly. In the Stack Overflow 2026 survey (30,903 respondents), 26% already use AI agents or automated workflows at work, and among respondents who used a coding agent in the past year, 65.5% had used Claude Code and 58.7% GitHub Copilot.

So the developer's job has shifted from writing code to specifying, orchestrating and verifying it. Good DX in 2026 means making that new job easy. It also means caring about what Netlify cofounder Mathias Biilmann calls agent experience (AX): how easy your codebase, documentation and tooling are for an AI agent to use.

What's the Business Case for Developer Experience in 2026?

AI only pays off if your organization can absorb what it produces, and poor DX is what stops it. The 2025 DORA report, based on nearly 5,000 technology professionals, describes AI's primary role as "an amplifier, magnifying an organization's existing strengths and weaknesses." It found that AI adoption now correlates with higher delivery throughput but still correlates with lower delivery stability.

Agents generate far more code, but review, testing and integration don't scale at the same rate. The extra code piles up as review queues, larger pull requests and production incidents. Faros AI's telemetry from 22,000 developers across 4,000 teams (AI Engineering Report Q2 2026) shows the pattern: task throughput up 33.7%, but median review time up 5x, bugs per pull request up 28.7%, incidents per pull request roughly tripled, and deployments per week down 11.7%.

Developers feel the gap. In Atlassian's State of Developer Experience 2025 (3,500 developers and managers), 68% said AI saves them more than 10 hours a week, yet 50% said they lose 10 or more hours a week to organizational friction such as hunting for information and switching between tools. The time AI gives back gets eaten by the system around it.

Morale is moving the wrong way, too. In the Stack Overflow 2026 survey, 32.6% of developers say they're not happy at work (up 4 percentage points from 2025) and only 22.2% say they're happy. The top reasons work got harder had little to do with AI: unclear priorities or requirements (16.6%), inefficient processes (14.6%) and not enough time or staff (14.1%). Asked what made work easier, the most common single answer was "nothing" (21.1%), just ahead of access to the right tools (20.1%).

Finally, agents create a new kind of interruption. Dima Zaytsev, a software engineer at Linear, told The Pragmatic Engineer: "There's lots of context switching: there's always another agent that waits on your response." Interruptions were already expensive. Gloria Mark's research at UC Irvine found that interrupted work took 23 minutes and 15 seconds on average to resume. A developer juggling eight agents is constantly being interrupted.

You can pay for tokens and see more code, more incidents and slower deployments. It takes some finessing to turn AI spend into faster delivery.

Is Developer Experience a Competitive Advantage?

Yes, and the gap between teams with good and bad DX is widening because AI magnifies it. DORA found that 90% of organizations have adopted at least one internal platform, and that teams with high-quality platforms are the ones getting real value from AI. Teams with fast pipelines, clean architecture and well-documented systems get far more out of the same agents than teams without them.

Onboarding is one visible example. DX (the developer intelligence company) found that the median time for a new hire to reach their 10th pull request fell from 91 days without AI to 49 days with daily AI use. That speed-up depends on agents having something to work with: readable code, written conventions and documentation that answers questions before they're asked.

Migrations are another. Work that teams postponed for years now takes weeks when the codebase and test suite support it. Anthropic's team moved the Bun runtime from Zig to Rust in 11 days, against an estimated 1.5 engineering years. In early 2025, Airbnb migrated nearly 3,500 React component test files from Enzyme to React Testing Library in six weeks instead of an estimated 1.5 years. In both cases, strong existing tests were what made the speed safe.

Platform investment compounds as well. Ramp built Inspect, a background coding agent that runs in sandboxed cloud environments with access to the company's tooling. It now produces roughly 30% of merged frontend and backend pull requests, with adoption that was voluntary rather than mandated. Spotify's Backstage, the internal developer portal it open-sourced, has been adopted by more than 3,000 companies. The pattern is the same: whoever makes the paved road easiest to use for humans and agents gets the compounding returns.

What Does It Take to Create Great Developer Experience?

Great developer experience still rests on four pillars: flow, fast feedback, low cognitive load, and purpose. Agents have changed what each of them means in practice.

How Do You Protect Developer Flow When Engineers Supervise Many Agents?

Flow used to mean hours of uninterrupted coding. Today, an engineer's attention is split across several agent sessions, each of which needs a decision at unpredictable moments. Protecting flow now means designing for fewer, better-timed interruptions.

That starts with the old basics: fewer meetings, async communication and focus blocks. Then add agent-specific habits. Give agents tasks that are well scoped enough to run to completion without constant check-ins. Batch reviews instead of responding to every agent the moment it pauses. Be honest about limits, too. Peter Mattis's ceiling of five to ten concurrent sessions comes from one of the most productive engineers in the industry. Most people will hit diminishing returns sooner, and expecting everyone to run ten agents is a fast route to burnout.

Why Do Verification Loops Matter More Than Ever?

When agents write the code, a team moves only as fast as it can tell whether that code works. Fast feedback used to be a nice-to-have. In 2026, slow feedback is usually the bottleneck.

Developers already verify by default. In the Stack Overflow 2026 survey, 76.5% run AI-generated answers locally before using them and only 9.6% use them as-is. The most costly AI mistake respondents named was plausible but wrong code (69.3%), followed by hard-to-review generated code (54.2%).

So invest in test suites that run in minutes, preview environments for every change, and checks that agents must pass before a human ever looks at the work. Jarred Sumner, creator of Bun, put it this way: "The AI writes pretty much all the code, but we have the AI write pretty much all the tests as well. [...] You need to have a way to trust your code, and tests are probably the best way to."

How Do You Reduce Cognitive Load With Better Context?

Cognitive load used to come mostly from complex tools and infrastructure. In 2026, the biggest source is missing context, for both people and agents.

The Stack Overflow 2026 Knowledge chapter shows how bad it is. 75% of respondents spend five or more hours a week looking for the information they need to do their work. Roughly 79% at least sometimes discover important context only after they've started or finished a task. And 60.9% say the context they need lives in people's heads. An agent can't ask the senior engineer who remembers why the payment service retries three times. If it isn't written down, the agent guesses, and that's how you get plausible but wrong code.

Reducing cognitive load now means simpler tools, smart defaults and abstracted infrastructure, plus written decisions, documented conventions and context files that agents read automatically.

Why Do Purpose and Autonomy Still Matter?

Nothing kills motivation faster than not knowing why you're building something, and AI hasn't changed that. If anything, it has raised the stakes. When producing code is cheap, deciding what to build becomes the scarce skill.

Titus Winters, lead author of Software Engineering at Google, described it to The Pragmatic Engineer as intelligence ("how to do it") versus wisdom ("what to do"): "When intelligence becomes commonplace, wisdom and charisma become much more important." Give developers a clear product vision, direct contact with users, and real ownership of outcomes. Engineers who understand the domain and the customer direct agents far better than engineers who are handed tickets.

What Metrics Should You Track to Improve Developer Experience?

Track delivery outcomes, developer sentiment and AI-specific signals together, and stop treating code volume as progress. When agents can generate thousands of lines in an afternoon, lines of code and pull request counts measure your token budget more than your productivity.

The DORA metrics remain the best-known baseline, but they've evolved. DORA now tracks five metrics in two groups. Throughput covers change lead time, deployment frequency and failed deployment recovery time. Instability covers change failure rate and deployment rework rate. The 2025 report also dropped the familiar elite, high, medium and low performance tiers in favor of seven team profiles, from "foundational challenges" to "harmonious high-achievers."

On top of DORA, frameworks such as the DX Core 4 combine speed, effectiveness, quality and business impact, so one number can't be gamed in isolation. A practical metric set for 2026 looks like this:

The figures in the caveats come from the Faros AI Engineering Report Q2 2026 and DX's Q2 2026 State of AI Impact report (500+ engineering organizations). In that DX report, median throughput rose 37% while the Developer Experience Index slipped from 67 to 65, a good illustration of why you need more than one lens.

Don't skip the human side. JetBrains' 2025 State of Developer Ecosystem found that 66% of developers don't believe current metrics reflect their true contributions. Regular, specific surveys and one-on-ones remain the fastest way to find friction no dashboard shows. The key is to connect the layers: show how faster test suites (technical) reduce review fatigue (human) and shorten time to market (business).

How Can Organizations Improve Developer Experience?

Start with the friction that blocks both developers and agents: unclear priorities, scattered context, slow verification and an overloaded review process. Tools come after that.

A good first step is to set a clear AI stance. DORA lists a "clear and communicated AI stance" as the first of seven capabilities that increase AI's benefits, alongside healthy data ecosystems, AI-accessible internal data, strong version control practices, working in small batches, user-centric focus and quality internal platforms. Many organizations haven't done this: in the Stack Overflow 2026 survey, 29.7% describe AI use at their company as "mostly optional, left to individuals."

Then consolidate. 40.5% of developers use three to five different AI tools in a typical week, on top of their existing stack. Port's 2025 State of Internal Developer Portals found that 75% of respondents lose six to 15 hours a week to tool sprawl. List every tool your developers touch, look for overlaps and pick a supported default for agents, the same way you would for CI or observability.

How Should Code Review Work When AI Agents Write the Code?

Code review has to change, because the old model of one human reading every line doesn't survive a five- or tenfold increase in code. One engineer at a mid-sized startup told The Pragmatic Engineer: "Everyone is playing the theater of doing reviews." Under pressure, people stamp everything "LGTM."

Pretending otherwise is the worst option. Instead, decide deliberately where human attention goes. Keep pull requests small, which DORA lists as an AI capability in its own right. Let automated checks and AI review handle style, obvious bugs and test coverage, and reserve human review for architecture, security-sensitive code and anything touching money or personal data. Automate approvals for low-risk changes, and document which categories those are.

This is a judgment call with real trade-offs. In regulated sectors like HealthTech and FinTech, "agent-only review" may simply not be an option for parts of the system, and that's fine. The goal is to make human review count where it matters.

What Are Internal Developer Platforms and Agent Harnesses?

An internal developer platform (IDP) is a self-service layer that lets engineers create environments, deploy and monitor services without filing tickets. An agent harness is the same idea for AI: the infrastructure that gives coding agents sandboxed environments, access to internal tools and data, permissions, and guardrails.

The two are converging. Ramp's Inspect, Stripe's Minions and Shopify's River all run agents on company infrastructure, often triggered straight from Slack ("@Claude build this" at Anthropic, "@Codex, implement this" at OpenAI). The Pragmatic Engineer expects most developers at tech companies to run agents in the cloud rather than on their laptops, and agentic infrastructure is becoming a discipline of its own.

Before you build, be realistic. Not every company needs a custom harness, and buying is often the better choice for anything commoditized. Platforms also fail when nobody uses them. Spotify reports 99% voluntary adoption of Backstage internally, but Humanitec notes that other organizations report an average adoption rate of around 10%. A platform is a product, with developers and agents as its users. Build for the paved road, keep escape hatches, and measure adoption.

How Do You Make a Codebase Easy for AI Agents to Work In?

Make the implicit explicit. Agents do their best work in codebases with clear structure, written conventions and fast, reliable tests, the same things that help a new human hire.

The cheapest place to start is a context file. AGENTS.md, an open format now stewarded by the Linux Foundation's Agentic AI Foundation, gives coding agents project-specific instructions on how to build, test and follow your conventions, and tools like Claude Code read similar files automatically.

Next, give agents access to internal knowledge. Documentation, architecture decision records and ticket history can be exposed through integrations such as the Model Context Protocol (MCP), with access controls that match the sensitivity of the data.

Old engineering habits help, too. Engineer and educator Matt Pocock found that agents produce better code when told to build a "tracer bullet," an end-to-end golden path first, an idea from The Pragmatic Programmer. Decades-old practices such as unit tests, upfront architecture and design patterns help agents as much as people.

Context needs an owner. As Stack Overflow's Chief Product and Technology Officer Jody Bailey puts it in the 2026 survey, "AI is forcing software organizations to document the judgment they previously relied on people to supply."

What Team Culture Supports Developer Experience With AI?

A blameless culture matters more when much of the code comes from agents. When something breaks, ask "what in our system let this through?" rather than "who approved this?" Blameless postmortems that look at specs, tests, review rules and agent permissions lead to fixes that stick.

Take developers' worries seriously, too. In the Stack Overflow 2026 survey, 17.1% of respondents say they avoid AI at work out of concern over losing job skills or training an AI to replace them. Junior hiring has also slowed across the industry, which raises a long-term question every engineering leader should answer: where will your future senior engineers come from? Pairing juniors with seniors on agent-driven work, and having them explain and review what agents produce, is one way to keep skills growing.

How Do You Build the Right Infrastructure for Agentic Development?

Agents run on infrastructure, and that infrastructure now shapes DX as much as laptops and IDEs once did.

Start with environments. Reproducible, containerized environments matter even more now, because agents need to spin them up on demand, so setup has to be a single command that a script can run. Sandboxing limits what an agent with too many permissions can break.

CI capacity comes next. Agent-generated changes multiply CI load. The Pragmatic Engineer reports a growing CPU shortage among cloud providers, with some customers reserving capacity months in advance. If your builds already queue, plan capacity before you scale agent usage.

Observability matters more, too. Monitoring tells you something broke, and observability tells you why. When nobody wrote the code by hand, production traces are often the fastest way to understand what it does.

Finally, plan for cost. Token spend is now a real engineering budget line. Gartner predicts that AI coding costs will exceed the average developer's salary by 2028. In the Stack Overflow 2026 survey, 38.1% of respondents say their organization already sets limits on AI usage or spending. Uber kept costs flat while token usage grew by running open models and routing tasks to cheaper models where possible, according to The Pragmatic Engineer. Treat cost as part of DX: hard caps that cut off an agent mid-task frustrate developers, while smart routing saves money quietly.

How Do You Implement Better DX?

Listen first, fix the obvious things fast, then work through the rest systematically. The process is the same as before AI; the questions you ask are different.

Listen First, Fix Second

Your developers already know what's broken. Run short anonymous surveys with specific questions: "Where do your agents get stuck most often?", "What do you wait for most in a typical day?", "What context do you keep having to explain, to people or to agents?" Follow up with one-on-ones, because surveys give you data and conversations give you context.

Then get baseline numbers: review time, test suite duration, deployment frequency, onboarding time and token spend per engineer. You can't show improvement without a starting point.

Focus on Quick Wins

Quick wins build trust. Write the first AGENTS.md for your most active repositories. Cut the slowest test suite in half with caching or parallelization. Set up preview environments so reviewers can click through changes instead of reading diffs. Each of these takes days, and developers feel the difference the same week. Share the results publicly; "We cut review wait time by a day" gets attention.

Make Systematic Improvements

After discovery, you'll have a long list. Don't try to fix everything at once. Use an impact-versus-effort matrix, but weigh impact by how often developers hit the problem. A high-effort fix for daily friction usually beats an easy fix for something nobody cares about. Dedicate real people and time, set deadlines, and report progress so it doesn't look like another initiative that will fade in two months.

Don't Overcorrect Into Bureaucracy

The goal is a small-team feel at large-team scale. Create paved roads instead of walls: make the recommended agent setup, deployment path and review flow the easiest option, and keep escape hatches for teams with good reasons to diverge. Write down why each standard exists, along with what it says. As Katelyn Lesse, Head of Engineering for Claude Platform at Anthropic, notes, even at one of the most AI-heavy companies "we still have two-pizza teams." Agents have changed how those teams work, but teams that own their software are still the unit that ships.

What Are the Most Common DX Improvement Challenges?

The biggest challenges are leadership alignment, code quality, skepticism and scale. Buying another tool solves none of them.

How Do You Get Leadership Buy-In for DX Investment?

Leaders and developers often see different realities. In Atlassian's 2025 report, 63% of developers said leaders don't understand their pain points, up from 44% the year before. AI usage dashboards make it easy to assume productivity is rising when delivery data says otherwise.

So translate friction into business terms. Don't lead with "our CI pipeline needs modernization." Lead with "our agents produce changes in hours, but they wait three days for review and our deployment frequency has dropped." Show where AI spend is stuck in the system, and frame DX as the way to get the return on it.

How Do You Keep Code Quality Up When Agents Write Most of the Code?

Quality is the obvious risk. CodeRabbit's analysis of 470 pull requests found that AI-generated pull requests contained about 1.7 times more issues than human-written ones. In Sonar's State of Code survey, 96% of developers said they don't fully trust that AI-generated code is functionally correct, yet only 48% always verify it before committing.

Faster output with weaker checks piles up technical debt faster than most teams can pay it down. The answer is the verification investment described above: tests as a non-negotiable gate, small changes, and human review focused on the riskiest parts of the system.

How Do You Win Over Skeptical Developers?

Developers have seen many "revolutionary" tools make their lives worse, and the evidence on AI productivity is mixed. A 2025 METR study found that experienced open-source developers were 19% slower with AI tools while believing they were 20% faster. METR's 2026 follow-up concluded that developers are probably faster now, but that its data was only weak evidence of how much, partly because many developers refused to work without AI at all.

Respect that uncertainty. Involve developers in designing the new workflow from day one, be transparent about trade-offs, and let early adopters show their peers what works. Peer influence usually works better than mandates, and few organizations have gone the mandate route anyway: only 10.2% of Stack Overflow 2026 respondents say their organization measures AI use as part of performance evaluations.

How Do You Scale DX Across Growing Teams?

When teams grow, informal systems break. The senior engineer who knew everything can't keep up, and with agents, undocumented knowledge breaks even sooner because agents can't absorb it from hallway conversations. Formalize what needs formalizing before it hurts: runbooks, decision records, platform defaults, context files. They help agents today and the people who join next year.

Is Developer Experience a Strategic Investment in the Age of AI Agents?

Yes. In 2026, developer experience decides whether AI agents make your company faster or just busier. Every improvement to priorities, written context, verification or your platform pays off twice: once for your engineers, and again for every agent they direct. Friction scales the same way. Teams that skip this work get more code and more incidents, pay higher token bills, and wear out the engineers they rely on.

You don't need a big-bang transformation to get there. Pick the friction that hurts most, fix it, measure the result and repeat, while keeping judgment, ownership and team culture at the center. As the 2024 DORA report put it after a decade of research, software development success hinges on "fostering a supportive culture, prioritizing user needs, and focusing on developer experience." Agents have made that finding harder to ignore.

At Monterail, we build software with agentic workflows every day. If your team has adopted coding agents but the gains aren't showing up in delivery, or you're planning a product and want a partner that already works this way, let's talk about where to start.