I've spent 12 years building engineering teams. I've watched companies pour millions into "developer productivity" initiatives that did absolutely nothing. I've also seen a single $200/month tool change transform a team's output overnight.
The difference? Knowing what actually matters versus chasing metrics that look good in a slide deck.
Here's the uncomfortable truth: most of what your organization measures about developer productivity is wrong. Not slightly off. Fundamentally broken. And the industry is finally starting to figure this out.
In 2023, McKinsey published their infamous "Yes, you can measure software developer productivity" paper. The backlash was immediate and brutal. Kent Beck, Gergely Orosz, and dozens of respected engineering leaders tore it apart within days.
Why? Because McKinsey tried to reduce developer productivity to a single score. They treated software engineers like factory workers on an assembly line. Count the widgets, measure the output, rank the performers.
That approach fails for one simple reason: software development is creative knowledge work. The most impactful thing a developer does in a week might be a 15-minute conversation that prevents three months of wasted effort. Good luck capturing that in a dashboard.
But the opposite extreme is equally wrong. "You can't measure developer productivity" is a cop-out. You absolutely can. You just have to measure the right things, at the right level, for the right reasons.[1]
After years of trial and error, I've landed on a framework I call the Three Layer Model. Every meaningful productivity signal falls into one of three layers:
Figure 1. The proposed productivity model considers the delivery system, daily experience and business impact.
This is what your CI/CD pipeline and version control can tell you. It's not about individual developers. It's about how fast your system moves code from "idea" to "running in production."
The signals that matter here:
Deployment frequency: How often you ship to production. Daily beats weekly. Weekly beats monthly. If you're deploying less than once a week, something is structurally wrong.
Change lead time: Measure from a change being committed to version control until it is deployed in production. Track the distribution for the application or service and investigate slow stages.
Change failure rate: What percentage of deployments cause an incident? Under 5% is excellent. Over 15% means your testing and review process needs work.
Failed deployment recovery time: When a deployment requires immediate intervention, measure how long recovery takes. Keep its definition specific to failed deployments.
Deployment rework rate: Measure the share of deployments that are unplanned work following an incident.
These are DORA's five software delivery performance metrics. Apply them to an application or service, interpret them together and use changes over time to investigate the delivery process.[2]
This is where most organizations completely drop the ball. They look at Layer 1 numbers, see they're bad, and immediately jump to "we need more engineers" or "we need better tools." They skip the critical question: what is the daily experience of the developers actually doing the work?
The signals that matter here:
Build time: How long does your local build take? I've seen teams where a full rebuild takes 45 minutes. Those developers context-switch during builds, and every context switch costs 15-25 minutes of recovery time. At one company, we cut build times from 12 minutes to 90 seconds. PR throughput went up 34% in the first month.
CI time: How long from push to green check? If your CI takes 40 minutes, developers stack PRs and context-switch. Aim for under 10 minutes for the critical path.
Environment setup time: How long does it take a new developer to go from cloning the repo to running the app locally? If the answer is "a day or more," you're losing productivity from every single engineer, every single day. The complexity they fight during setup is the same complexity they fight during development.
Cognitive load: How many systems, services, and tools does a developer need to understand to make a typical change? If shipping a feature requires touching four services, two databases, a message queue, and a CDN configuration, you have a cognitive load problem.
Documentation quality: Can a developer find the answer to "how do I do X" in under 5 minutes? Not "does documentation exist" but "is it accurate, current, and findable?"
The best way to measure developer experience is to ask developers directly. Run a quarterly DX survey. Keep it short (10 questions max). Track trends over time. The SPACE framework from Microsoft Research gives you a solid starting point.[3]
This is the layer that actually matters to the business, and it's the one that's hardest to attribute to individual productivity changes. But it's essential for justifying investment.[4]
Feature lead time: How long from "product decides to build X" to "users are using X"? This captures the full lifecycle, including design, planning, and cross-team coordination, not just coding time.
Developer cost per feature: What's the fully loaded cost of shipping a typical feature? This isn't about making developers cheaper. It's about removing waste so their expensive time goes to valuable work.
Innovation rate: What percentage of engineering time goes to new capabilities versus maintenance, bug fixes, and keeping the lights on? I've seen teams where 80% of engineering time goes to maintenance. That's a productivity crisis, even if the DORA metrics look fine.
Customer impact velocity: How quickly can you respond to customer feedback with a shipped change? This is the ultimate measure of engineering agility.
# The Contrarian Take: Individual Metrics Are Poison
Here's where I disagree with about 70% of engineering leadership: I don't believe in individual developer productivity metrics. Not story points per sprint. Not PRs merged. Not commits. Not lines of code. None of it.
The moment you measure individuals, you create incentives that destroy team performance. The developer who spends two hours helping a teammate debug a gnarly race condition doesn't show up in any individual metric. The developer who writes a critical design doc that saves the team from a bad architectural decision gets zero credit.
Worse, individual metrics actively encourage gaming. I've watched developers split one logical PR into five small ones to juice their "PRs merged" number. I've seen engineers avoid reviewing others' code because it doesn't count toward their own output.
The one exception: self-reflection tools. Developers should have access to their own data to identify patterns. "I notice I'm most productive on Tuesdays and Wednesdays" is useful self-knowledge. Your manager tracking that data is surveillance.
# The Stealable Framework: The Productivity Stack Audit
Here's something you can run next Monday. I call it the Productivity Stack Audit. It takes about two weeks and gives you a clear picture of where your team's productivity is actually being lost.
Waiting: Waiting for builds, CI, reviews, deployments, answers
Coordinating: Meetings, Slack threads, status updates, finding information
Fixing: Debugging, incident response, fixing flaky tests, dealing with bad tooling
Most teams discover that developers spend less than 40% of their time in the "Building" category. The goal is to get that above 60%.
Day 3-5: Toolchain Timing
Measure every step of your delivery pipeline:
Local build time (cold start and incremental)
Test suite runtime (unit, integration, e2e)
CI pipeline duration (push to green)
PR review turnaround time
Deployment time (merge to production)
Environment provisioning time
Write each number on a whiteboard. Circle anything over your team's threshold. For most teams, good thresholds are: local build under 2 minutes, CI under 10 minutes, review turnaround under 4 hours, deployment under 30 minutes.
Day 6-7: Identify the Top 3
From your time diaries and toolchain measurements, identify the three biggest productivity drains. Be specific. Not "meetings are too long" but "the Monday planning meeting runs 90 minutes and only 20 minutes is relevant to any given developer."
Day 8-9: Solution Design
For each of the top 3, design a concrete intervention:
If build times are the problem, invest in build caching (Turborepo, Nx, or similar)
If meetings are the problem, cut them. Default to 25-minute meetings. Make attendance optional for anyone not directly needed.
If review turnaround is the problem, set an SLA (4 hours for normal PRs, 1 hour for urgent) and create review rotation schedules
If cognitive load is the problem, invest in internal documentation and developer portals (Backstage, Port, or equivalent)
Day 10: Commit and Measure
Pick one intervention. Ship it within two weeks. Measure the before and after. Use that data to justify the next investment.
The entire process costs you about 10% of the team's time for two weeks. In every case I've seen, the first intervention pays for itself within a month.
Figure 2. Use the audit to choose one intervention and check its effect.
I'm not going to pretend tools don't matter. They matter enormously. But the specific tools matter far less than whether you've eliminated key friction points. That said, here's what I see working well in 2026:
Build & CI:
Turborepo or Nx for monorepo build orchestration
Remote caching (Vercel Remote Cache, Nx Cloud, or self-hosted)
GitHub Actions or BuildKite for CI (avoid Jenkins unless you enjoy suffering)
Developer Environment:
Dev containers or Gitpod/Codespaces for standardized environments
Docker Compose for local service orchestration
Mise or asdf for runtime version management
Observability into Productivity:
LinearB, Jellyfish, or Pluralsight Flow for system-level metrics
Sleuth for deployment tracking
Internal DX surveys (you don't need a tool for this; Google Forms works fine)
AI-Assisted Development:
GitHub Copilot or Cursor for inline code assistance
ChatGPT/Claude for design reviews, documentation drafting, and debugging
AI-powered code review tools (but keep human reviewers in the loop)
The AI tools are worth special mention. In 2026, a developer without AI assistance is like a developer without an IDE. The productivity gap is real and growing. Our team saw a 25-30% reduction in time spent on boilerplate code after adopting Copilot. But the gains are concentrated in specific tasks (boilerplate, tests, documentation). For complex architectural work, AI is a thinking partner, not a replacement.
Three trends will define developer productivity in the next year:
1. Platform Engineering Goes Mainstream
Internal Developer Platforms (IDPs) are moving from "nice to have" to "table stakes." The best teams are building golden paths that make the right way the easy way. This is the single highest-ROI investment most organizations can make.
2. AI Shifts the Bottleneck
As AI handles more routine coding, the bottleneck shifts to code review, testing, and system design. Teams that don't adjust their processes for this shift will actually see productivity decrease despite using AI tools. More code generated means more code to review, test, and maintain.
3. Developer Experience Gets a Seat at the Table
DX teams, platform teams, developer advocacy, whatever you call it, the function of "making developers more productive" is becoming a first-class organizational priority. I'm seeing DX lead roles open at companies that didn't even have the concept two years ago.
Developer productivity isn't a number. It's a system. You improve it by reducing friction, eliminating waste, and giving smart people the time and space to do their best work.
The teams that figure this out ship more, ship faster, and keep their best engineers. The teams that don't will keep wondering why throwing more headcount at the problem never seems to help.
Which developer productivity metrics should a team start with?
Start with service-level delivery measures and a short developer-experience survey. Use the combination to locate waiting, rework or other friction. Choose measures that help the team improve its work and interpret changes against its own baseline.
What is the difference between DORA and SPACE?
DORA focuses on software delivery performance at the application or service level. SPACE considers several dimensions of developer productivity. They can inform different parts of an assessment and should be interpreted in the context of the work being measured.
Should productivity metrics be used to rank individual developers?
The article recommends evaluating teams, systems and outcomes. Counts of commits or pull requests omit collaboration, design and other work. Discuss the purpose and interpretation of a measure before using it in decisions about people.
How can a team run a productivity audit?
Use the proposed two-week audit to observe work categories, time the toolchain and identify a few concrete sources of friction. Pick one intervention, record a baseline and check what changes after implementing it.
Your PR data reveals team bottlenecks invisible in standups. Here's how to measure TTFR, review distribution, and cycle time with the REVIEW framework.
Small frictions cost more than big blockers. 47 micro-frictions consume 96 minutes per engineer per day. Here's the TAX Return framework for finding and eliminating the developer productivity tax.
Set up continuous code quality monitoring with CI gates, trend metrics and alerts. Establish a baseline, define thresholds and review changes with your team.
Engineers spend 38% of their time on repetitive, automatable work. Here's a toil audit process that identifies where time disappears and a framework for systematic elimination with measurable ROI.
Developer experience is a systems design problem, not a culture problem. Platform engineering reduces cognitive load from 12 concepts to 3 for common tasks. Here's the LOAD assessment framework.
The 10x developer myth is actively harmful to engineering teams. After tracking individual metrics vs team output, I found that the highest performers often had negative correlations with team throughput.