Developer Productivity Metrics

Over the years, I've collected a lot of material and thoughts about developer productivity: research papers, practitioner articles, cautionary tales, and lessons from my own experience. The topic keeps coming up because our industry keeps getting it wrong. I finally put it all together into one article. The article covers: • Why every simple metric (LOC, velocity, hours worked) fails for the same reasons, explained through the McNamara Fallacy, Goodhart's Law, and a lesser-known phenomenon called surrogation: people nonconsciously replace the goal with the metric, forgetting what the number was supposed to represent in the first place • Why modern frameworks like DORA and SPACE are genuine progress but are routinely misapplied: used for benchmarking and comparison when they were designed for self-improvement • Why the McKinsey developer productivity framework drew the strongest collective rebuttal from the engineering community in recent memory • Why software development is knowledge work, not manufacturing — and why that distinction matters more than any metric • Why AI studies on developer productivity contradict each other wildly, and none of them should be trusted yet • What (IMO) actually works: measuring developer experience (feedback loops, cognitive load, flow state), focusing on team outcomes rather than individual metrics, and thinking in systems rather than individuals The core argument: the real question is not "How productive are our developers?" It is "How do we create the conditions where developers can do their best work?" One requires a dashboard. The other requires leadership. Link to the full article in the first comment. #DeveloperProductivity #SoftwareDevelopment #SoftwareEngineering

📊 Goodhart’s law is why KPIs fail We all know the feeling: you buy a gym membership, the treadmill lights up, the apps track your steps… but somehow, the six-pack never arrives. That’s KPIs in a nutshell. On paper, everything looks active. In reality, not much is effective. Every CEO loves KPIs. They look great in board decks, they make dashboards light up like a Christmas tree, and they give leaders the comforting illusion of control. But here’s the problem: “When a measure becomes a target, it ceases to be a good measure.” That’s Goodhart’s Law, coined in 1975, and it’s still killing strategy today. 🎯 The KPI trap KPIs start out as useful indicators. But the moment they become targets, people game them. • Call centers optimize for call length → agents hang up quickly, not helpfully. • Sales teams optimize for pipeline size → suddenly you’ve got a pipeline full of fantasy deals. • Marketing optimizes for clicks → congratulations, you now have traffic from bots in Bulgaria. Leaders celebrate the numbers, but the outcomes? Not so much. 📊 Research reality • McKinsey found that only 23% of executives believe their KPIs are aligned with strategy. The other 77% are tracking noise, not progress. • Gallup’s global workplace survey shows that only 20% of employees feel their performance metrics are managed in a way that motivates them to do outstanding work. In other words, most KPIs disengage more than they inspire. • Harvard Business Review highlights that vanity metrics reduce performance because they distract leaders from execution. • A London School of Economics study found that when incentives and targets are misaligned, employees “optimize the metric” even if it damages overall outcomes. Classic Goodhart’s Law in action. • Deloitte research shows that companies that focus on “execution-linked metrics” (customer impact, speed, resilience) outperform those that over-index on internal KPIs by up to 60% in shareholder returns. The data is clear: measuring the wrong things is often worse than not measuring at all. Dashboards are like treadmills. They light up, make you feel productive, and give the illusion of progress. But unless leaders ensure the numbers actually translate to outcomes, you’re just running in place. 🛡️ Leadership’s responsibility The KPI problem isn’t technical, it’s leadership. • Leaders confuse measurement with management. • Leaders celebrate dashboards instead of outcomes. • Leaders treat KPIs like strategy, when they should be diagnostics. The CEO’s job isn’t to chase numbers, it’s to ensure numbers reflect reality. 📌 A leadership reflection Goodhart’s Law is alive in every company. Metrics aren’t bad; bad leadership of metrics is. Leaders don’t win by measuring more. They win by measuring what matters, then managing execution. Because at the end of the day, vanity KPIs make dashboards look pretty. But they don’t make companies perform. #Leadership #Strategy #Execution #DecisionMaking #Management

The "10,000 lines of code per day with AI" claim perfectly demonstrates how AI productivity metrics have become completely detached from software development reality. Measuring developer productivity by lines of code generated reveals fundamental misunderstanding of what creates business value in software development. Quality, maintainability, and problem-solving matter more than output volume. I've worked with teams that generate thousands of AI-assisted code lines daily while struggling with basic debugging, architecture decisions, and requirement gathering. High-volume code generation often creates more technical debt than business value. The most productive developers I know focus on solving complex problems efficiently rather than maximizing code output. They write less code that accomplishes more, not more code that accomplishes less. AI tools can accelerate certain coding tasks, but they can't replace systematic thinking, domain expertise, or architectural planning. These cognitive capabilities determine software quality and business impact. Organizations obsessing over AI-enhanced code generation metrics typically miss fundamental software development challenges: unclear requirements, poor process design, and inadequate quality assurance. Better approach: measure AI impact on delivered business value rather than intermediate outputs like code volume or development speed. Sometimes the most valuable code is the code you don't need to write. #SoftwareDevelopment #AI #ProductivityMetrics #TechManagement #CodeQuality

The best-performing software engineering teams measure both output and outcomes. Measuring only one often means underperforming in the other. While debates persist about which is more important, our research shows that measuring both is critical. Otherwise, you risk landing in Quadrant 2 (building the wrong things quickly) or Quadrant 3 (building the right things slowly and eventually getting outperformed by a competitor). As an organization grows and matures, this becomes even more critical. You can't rely on intuition, politics, or relationships—you need to stop "winging it" and start making data-driven decisions. How do you measure outcomes? Outcomes are the business results that come from building the right things. These can be measured using product feature prioritization frameworks. How do you measure output? Measuring output is challenging because traditional methods don’t accurately measure this: 1. Lines of Code: Encourages verbose or redundant code. 2. Number of Commits/PRs: Leads to artificially small commits or pull requests. 3. Story Points: Subjective and not comparable across teams; may inflate task estimates. 4. Surveys: Great for understanding team satisfaction but not for measuring output or productivity. 5. DORA Metrics: Measure DevOps performance, not productivity. Deployment sizes vary within & across teams, and these metrics can be easily gamed when used as productivity measures. Measuring how often you’re deploying is meaningless from a productivity perspective unless you’re also measuring _what_ is being deployed. We propose a different way of measuring software engineering output. Using an algorithmic model developed from research conducted at Stanford, we quantitatively assess software engineering productivity by evaluating the impact of commits on the software's functionality (ie. we measure output delivered). We connect to Git and quantify the impact of the source code in every commit. The algorithmic model generates a language-agnostic metric for evaluating & benchmarking individual developers, teams, and entire organizations. We're publishing several research papers on this, with the first pre-print released in September. Please leave a comment if you’d like to read it. Interested in leveraging this for your organization? Message me to learn more. #softwareengineering  #softwaredevelopment #devops

I’ve noticed that many teams still measure productivity by hours spent rather than results delivered. The reality is that time alone is a poor indicator of impact. What matters is clarity on priorities, disciplined focus, and purposeful execution. The Parkinson’s Law shows us that work expands to fill the time allotted. If we don’t structure our work around outcomes, it often expands unnecessarily, creating busyness rather than progress. In my experience, setting clear timelines, defining expected outcomes, and being deliberate about where effort is applied drives focus, accountability, and meaningful results, which is far more than simply logging hours. For leaders and teams alike, the shift from counting hours to valuing clarity and intent is essential. Productivity isn’t about how much time you spend; it’s about how deliberately you use it to move the needle. #Productivity #Discipline #StrategicThinking #Leadership #ProductivityShift

Efficiency metrics can look impressive. But numbers don’t always tell the truth. I’ve seen teams look efficient on paper, but run on fumes behind the scenes. The real test isn’t the dashboard. It’s whether your team still has fuel in the tank. Here’s how false efficiency shows up: 1. Busy Isn’t Productive ➞ Activity looks good but progress stalls.   ➞ Motion alone never creates real momentum.  2. Burnout Hides Behind Output ➞ High numbers can mask exhaustion.   ➞ Energy fades long before metrics do.  3. Rework Is Invisible Waste ➞ Speed without clarity doubles the load.   ➞ Mistakes drain more time than planning.  4. Long-Term Work Gets Cut ➞ Short wins show up, strategy disappears.   ➞ Future results are sacrificed for speed.  5. Metrics Miss Morale ➞ Dashboards can’t measure trust or energy.   ➞ Low morale drags execution every time.  6. Heroics Don’t Scale ➞ Teams built on saviors aren’t sustainable.   ➞ Metrics rise while people burn out.  7. Silence Is a Red Flag ➞ Engagement fades before turnover spikes.   ➞ Quiet rooms signal hidden inefficiency.  8. Over-Optimization Backfires ➞ Pushing harder leaves no room for change.   ➞ Efficiency kills adaptability when overdone.  9. Weak Links Spread Fast ➞ One overloaded role slows the chain.   ➞ Bottlenecks multiply when work piles up.  10. Leaders Set the Signal ➞ Numbers-only leaders miss the picture.   ➞ Strong leaders check both metrics and people.  Efficiency isn’t the only goal. Sustainable performance key. 👉 What’s a focus area for your team’s growth? 📌 Tell me below! ✅ Follow Jaison Thomas for more leadership clarity.

Measuring developer productivity is easier than ever. That's exactly the problem. We have tools that track commits, pull requests, code review time, ticket velocity, deployment frequency. The data is abundant, accessible, and almost completely misleading. It looks like management, feels like insight, and optimizes for exactly the wrong things. This is success theater. Measures like DORA can tell us where to look, not how productive we are or what the problem is. Every major dev-focused metric worth its salt is about diagnostics in context, not a measuring stick. High commit counts tell you nothing about whether the code matters. Fast ticket closure tells you nothing about whether you're solving real problems. Deployment frequency tells you nothing about business impact. Worse, these metrics create perverse incentives. Engineers game them. They split commits, inflate ticket counts, ship features nobody uses. You get impressive dashboards and declining outcomes while promoting those who game the system. The alternative is harder: Have actual conversations. Ask what's keeping people busy, what they've completed, and what's different about the business because of their work. These three questions, (inputs, outputs, outcomes), give you more useful and actionable diagnostic information in 15 minutes than a quarter of analysis on PR frequency or ticket open times. The details matter, but they're in the conversation, not the metrics. If you're spending more time analyzing productivity data than talking to your team about their work, you've automated your way into irrelevance and blocked the path to improvement.

YOU. ARE. MEASURING. PRODUCTIVITY. WRONG. A founder told me he tracks "hours logged" for his engineering team. He said it with a straight face too. Like he was proud of it. Hours logged tells you one thing... How long someone had their laptop open. It tells you nothing about whether the code was good, whether the problem mattered, or whether anything moved forward. But here's what drives me absolutely bat shit crazy. Some version of this is how most companies measure productivity. Hours tracked. Tickets closed. Lines of code. Tasks completed. All activity metrics. All measuring motion, not progress. Motion feels productive. That's what makes it dangerous. I watched one founder blow this up entirely. She stopped measuring individual output and started measuring team results against company goals. "How many tickets did Sarah close" became "did the onboarding team improve activation rate this month." "How many hours did engineering log" became "did we ship the three features customers said they'd pay for." Subtle shift. Massive difference. Activity metrics incentivize busywork. Output metrics incentivize the right work. Her team hated it at first. The engineers used to prove their value through commit counts. Without that crutch, they had to prove it through impact... which meant actually understanding what the company needed. Two people thrived. One got exposed as someone who'd been generating impressive activity while contributing almost nothing to actual goals. All three outcomes were useful information. Here's the filter I use now: If you can't draw a straight line from what you're measuring to a customer or revenue outcome, you're not measuring productivity. You're measuring theater.

For decades, engineering teams have been measured by lines of code, commit counts, and PRs merged—but does more code actually mean more productivity? 🚀 Some of the best developers write LESS code, not more. 🚀 The fastest-moving teams focus on outcomes, not just output. 🚀 High commit counts can mean inefficiency, not impact. Recent research from DORA, GitHub, and real-world case studies from IT Revolution debunk the myth that developer activity = developer productivity. Here’s why: 🔹 DORA Research: After studying thousands of engineering teams, DORA (DevOps Research & Assessment) found that the best teams optimize for four key engineering performance metrics: ✅ Deployment Frequency → How often do we ship value to users? ✅ Lead Time for Changes → How fast can an idea go from code to production? ✅ Change Failure Rate → Are we improving quality, or just shipping fast? ✅ MTTR (Mean Time to Restore) → Can we recover quickly when things go wrong? → Notice what’s missing? Not a single metric is based on lines of code, commits, or individual developer output. 🔹 GitHub’s Data: GitHub found that developers working remotely during 2020 pushed more code than ever—but many felt less productive. Why? Longer workdays masked inefficiencies. More commits ≠ meaningful work; some were just fighting bad tooling or slow reviews. Teams that automated workflows (CI/CD, code reviews) merged PRs faster and felt more productive. 🔹 IT Revolution case studies: High-performing engineering orgs measure outcomes, not just outputs. The best teams: Shift from tracking commit counts → to measuring customer value. Use DORA metrics to improve DevOps flow, not micromanage engineers. View engineering productivity as a team effort, not an individual scoreboard. If you want a high-performing engineering org, don’t just push developers to write more code. Instead, ask: ✅ Are we shipping value faster? ✅ Are we reducing friction in our workflows? ✅ Are our developers able to focus on meaningful work? 🚨 The takeaway? Great engineering teams don’t write the most code—they deliver the most impact. 📢 What’s the worst “productivity metric” you’ve ever seen? Drop a comment below 👇 #DeveloperProductivity #SoftwareDevelopment #DORA #GitHub #EngineeringLeadership

Your software development team feels overloaded and struggles to deliver. Leadership wants an easy solution, they're considering measuring productivity by lines of code or commit counts. But here's the problem: Counting lines of code is like judging a chef by how many ingredients they throw in a pot. More ingredients don't always mean a tastier meal. And counting commits? That's like rating a soccer player by how many times they kick the ball and not by whether they score goals. If you use these flawed metrics: • You'll encourage unnecessary complexity • You'll waste valuable time on meaningless work • Your best developers might become frustrated and leave The real fix is simple: Measure success by clear, meaningful results. • Are customers happy? • Is your team delivering quality products? • Can they handle the workload without burnout? Focusing on outcomes, not arbitrary numbers, helps your team thrive. Shift your metrics.