I’ve spent enough years around engineering orgs to know that every wave of change brings the same executive question in new clothes:
“What’s the one metric?”
In the AI era, it shows up as lines of code, PR throughput, commit volume, or some variation of “are we going faster yet?” And just like before, the tempting answer is the wrong one.
What stood out to me is that AI doesn’t reduce the importance of developer experience. It raises the stakes.
If you’re rolling out AI across the SDLC, you’re not just adding a tool. You’re changing how developers think, review, validate, and trust what lands in production. The work shifts from primarily writing code to a more complex loop of prompting, evaluating, accepting, editing, and verifying. That’s a workflow change, a cognitive change, and a systems change.
So if I’m leading engineering today, I’m not asking, “Did we buy AI tools?”
I’m asking:
Where is friction actually being removed?
Where is cognitive load increasing?
What part of the workflow improved, and what part just got noisier?
Can developers trust the output enough to move faster without creating downstream drag?
That’s why I continue to believe developer experience is one of the most strategic lenses a leadership team can use right now.
A few ideas here really resonate with me.
First, measurement still needs to be multi-dimensional. The industry keeps trying to compress productivity into a single number because single numbers are easy to put on slides. But software delivery has never worked that way, and AI makes that even more obvious.
A useful model still has to look across multiple dimensions: satisfaction, performance, activity, collaboration, and flow. Not because frameworks are fashionable, but because any one metric in isolation gets gamed, misunderstood, or both.
AI-generated code makes this painfully clear. If a machine can produce hundreds of lines in seconds, then code volume becomes even less meaningful than it already was. The question isn’t whether more code exists. The question is whether better outcomes happen with less friction.
Second, surveys matter more than a lot of technical leaders want to admit.
I know some people still flinch at anything subjective. But if you care about end-to-end workflow friction, tool handoff pain, trust in generated output, or whether engineers feel interrupted versus in flow, system telemetry alone won’t save you.
I’ve seen this firsthand for years: the hard problems in engineering productivity are rarely visible from one dashboard. You need both forms of evidence:
what the systems say and what the developers say.
That combination is the closest thing we have to a complete picture.
Third, you have to translate DevEx into business language.
This is where many well-intentioned engineering leaders lose the room. Executives do not wake up caring about cycle time because cycle time is beautiful. They care about market speed, capital efficiency, capacity, risk, and whether the organization can absorb change without collapsing into chaos.
So if I’m trying to get support for a DevEx initiative, I’m not stopping at “developers are frustrated” or “builds are slow.”
I’m connecting the dots to:
- recovered engineering capacity
- reduced cloud spend
- faster path from idea to customer value
- lower delivery risk
- better ROI on AI investments
That’s the story. The metrics support it, but they are not the story by themselves.
Another point I strongly agree with: metrics should be treated like a product.
That’s a subtle idea, but an important one.
Too many organizations build metric systems the way they build internal admin tooling: dump a bunch of numbers into dashboards and assume the job is done. But if metrics are a product, then they need customers, use cases, adoption, iteration, and eventually deprecation.
A metric that doesn’t answer a decision is just decoration.
A dashboard without context is usually a blame surface.
And a productivity metric handed to managers without training is often an incentive bug waiting to happen.
The other strategic takeaway for me is around prioritization.
Once you actually start measuring friction, you uncover more problems than you can possibly fix. That’s normal. The real challenge isn’t finding pain; it’s deciding what deserves coordinated investment.
This is where product thinking helps again. Reach, impact, confidence, and effort are far more useful than chasing whatever complaint is loudest or whatever bottleneck feels emotionally important this quarter.
I’ve made this mistake before, and I’ve watched plenty of teams make it too: they go after the biggest visible problem without accounting for organizational feasibility. Six months later, they realize they picked a fight they couldn’t win.
In practice, the best DevEx programs balance two truths:
Some problems are local and should be fixed by teams closest to the work.
Some problems are systemic and need top-down sponsorship to move at all.
That distinction matters a lot. You can absolutely get momentum from grassroots improvements, but the big structural wins usually require executive air cover.
And that brings me to the part I think matters most right now.
AI rollout is not mainly a tooling exercise. It’s a change-management exercise wrapped in a productivity narrative.
If leadership wants ROI from AI, they need more than licenses and announcements. They need a disciplined way to identify friction, measure outcomes, build trust, and communicate value across different audiences.
That’s developer experience work.
Not as a side project. Not as developer happiness theater. As core operational strategy.
My view is simple: in the AI era, the companies that win won’t be the ones that generate the most code.
They’ll be the ones that create the most trustworthy, low-friction, high-leverage environment for developers to turn ideas into outcomes.
That’s what DevEx is really about. And if anything, it just became more important than ever.