Open a GitHub org dashboard and the first thing most engineering leaders look at is a wall of green squares — a contribution graph, a weekly commit total, a “lines changed” column next to each engineer’s name. It’s an easy habit: the numbers are already there, free, updated in real time, and they look like performance data. They aren’t. Every commit count productivity metric built on raw Git history — commits per engineer, lines-of-code delta, streaks, pull-request counts — is measuring workflow convention, not output, and the mechanics of Git make that failure mode structural rather than incidental. This piece walks through exactly how commit history gets distorted, then covers the two research programs — DORA’s four keys and the SPACE framework — that measure something real instead.

The GitHub Contribution Graph Is Not a Performance Review
The contribution graph exists as a habit-formation nudge, not an evaluation instrument — GitHub built it to encourage daily activity, the same design intent behind a fitness-app streak. Reading it as a performance signal borrows its visual authority (a dense grid of data looks rigorous) without any of the validation a real metric needs: nobody has shown that commit-day density correlates with delivered value, and — as the next section shows — the count behind each square is trivially movable by decisions that have nothing to do with the work.
This matters because the temptation is specific and common: an engineering leader with a stack-ranked team and thin visibility into what everyone actually shipped reaches for the number that’s already computed. Git’s own object model makes that number available at zero cost — git log --author, a contribution graph, a “commits this sprint” report in whatever dashboard tool sits on top of the repo. Available and free is not the same as valid. The rest of this article is about the gap between those two things, and what to measure across that gap instead.
Four Mechanical Distortions That Break Commit-Based Metrics
Four ordinary, defensible engineering decisions — none of them made with metrics in mind — each independently move a team’s raw commit numbers without changing anything about what was built, tested, or shipped.
1. Squash-Merge Collapses History by Policy, Not by Work
A feature branch with 40 work-in-progress commits — typo fixes, “wip,” “actually fix the test this time” — becomes exactly one commit on main the moment a team’s default pull-request merge strategy is “squash and merge” rather than “create a merge commit.” Both git merge --squash and its hosted equivalent (GitHub’s squash-and-merge option) fold an arbitrary number of source commits into a single new commit with a single new tree; the 39 intermediate commits still exist as loose objects for a while, then become eligible for garbage collection once nothing references them ([primary/spec] git-merge — the --squash option; [vendor] GitHub Docs, “About pull request merges”).
Flip that one repository setting from “merge commit” to “squash and merge” and every engineer’s commits-on-main count drops by an order of magnitude overnight — not because anyone shipped less, but because the counting unit changed. Flip it back, or let one team keep long-lived merge commits while another squashes everything, and you’re comparing two organizations’ Git-hygiene policy, not their throughput. The number moved. The work didn’t.

2. Rename Detection Is a Heuristic Guess, Not Stored Metadata
Git does not store the fact that a file was renamed. There is no rename record in a commit, a tree, or anywhere in the object model — a rename is two independent facts (this path stopped existing, that path started existing with similar content) that tools infer after the fact by comparing blobs. git diff and git log detect renames and copies with the -M/-C flags, which score similarity as a percentage of matching content against a configurable threshold; git blame, tracing a rename in the opposite direction (which past commit introduced this line), applies its own detection tuned to a minimum count of moved characters rather than a percentage ([primary/spec] git-diff — rename/copy detection (-M, -C); [primary/spec] git-blame).
The practical consequence: move a 2,000-line file to a new path with no content changes, and whether that registers as “0 lines changed” or “2,000 lines added, 2,000 removed” depends on which command produced the report and whether the move happened to cross that command’s particular similarity threshold. Two tools measuring the identical event can disagree with each other, because neither is reading a fact — both are running a heuristic over content and hoping it lands on the same side of a cutoff. A “lines changed” leaderboard built on that foundation is not measuring code volume; it’s measuring how a similarity scorer happened to round.

3. Monorepo vs. Polyrepo Changes the Denominator
“Commits per engineer” implicitly assumes a commit is a comparable unit of work — and repository topology alone breaks that assumption. In a monorepo, one coordinated change to a shared library plus its ten downstream call sites can land as a single commit touching hundreds of files. Split across ten polyrepos, the identical engineering work becomes ten commits, ten pull requests, and ten separate review threads. Nothing about the work changed; the denominator did.
This is exactly why “everyone runs monorepos on Git” is itself a myth worth retiring before trusting a cross-org comparison. Microsoft’s Windows source tree — roughly 3.5 million files and 270 GB, per the company’s February 2017 announcement, since materially reworked — is a genuine Git monorepo, which is why it forced GVFS, then Scalar, into existence ([vendor] Microsoft Azure DevOps Blog, “Announcing GVFS”). Google’s Piper, by contrast, is not Git at all — a Perforce-lineage system backed by Google’s internal Colossus filesystem, by the engineers’ own account ([academic] Potvin & Levenberg, “Why Google Stores Billions of Lines of Code in a Single Repository,” CACM 59(7), 2016). Meta’s monorepo runs on Sapling, a Mercurial-derived system, also not Git ([vendor] Meta Engineering, “Sapling,” Nov 2022). Put a Windows-scale monorepo team’s “commits per engineer” next to a polyrepo shop’s and you’re not comparing productivity — you’re comparing repository topology, which a metrics dashboard cannot see and will not adjust for.

4. Commit Granularity Is Personal Habit, Not Signal
The last distortion needs no policy at all — just two engineers with different habits. One commits every few minutes as a personal checkpoint, treating Git as an undo buffer; the other stages an entire feature and commits once, right before opening a pull request, often after an interactive rebase (git rebase -i) that squashes and reorders everything into a clean narrative. Both are legitimate, common workflows. Neither produces a commit count that means anything next to the other’s. A “conventional commits” shop that requires one semantic commit per logical change will also, by construction, produce different counts than a shop with no such convention — again, a style choice showing up as a productivity number.
The Rule Underneath All Four
Look at what the four distortions have in common: each is a policy or habit a team already controls — merge strategy, rename-detection tooling, repository topology, individual commit cadence — and each can move a Git-internal count up or down while the delivered outcome stays exactly the same. That’s the tell. If a policy change can move the number without moving the outcome, it was never measuring the outcome.
| Bad metric | Why it breaks |
|---|---|
| Commits per engineer | Squash-merge policy, rebase/fixup habits, and personal commit cadence each change the count with zero change in delivered work |
| Lines of code changed (diff size) | Rename/move detection is a similarity heuristic (git diff -M/-C), not a stored fact — an identical file move can register as thousands of “changed” lines or none, depending on the tool and its threshold |
| GitHub contribution-graph “streaks” | Counts commit-days, not decisions shipped — a day spent debugging a hard production issue with no commit reads as blank; a day of boilerplate reads as full |
| Pull requests opened or merged | Monorepo-vs-polyrepo structure changes what “one PR” represents — a single coordinated change is one PR in a monorepo, ten in a polyrepo, for identical work |
| Cross-team or cross-org commit-count comparisons | Compounds all of the above with differing repo topology, merge policy, and individual habit — the comparison measures workflow convention, not throughput |
DORA’s Four Keys: A Deployment-Pipeline Framework, Not Commit Mining
The corrective most engineering leaders reach for next is DORA — the research program behind Accelerate (Nicole Forsgren, Jez Humble, and Gene Kim, 2018), built on an annual State of DevOps survey spanning tens of thousands of respondents across thousands of organizations. DORA’s four keys are deployment frequency, lead time for changes, change failure rate, and time to restore service — and it is worth being precise about what they actually measure, because the most common mistake is treating DORA as “counting Git history more cleverly.” It is not. DORA is a deployment-pipeline framework, not commit mining, and only one of the four keys touches a commit timestamp at all ([academic/primary] Forsgren, Humble & Kim, Accelerate (2018); Google Cloud, DORA research program).
Lead time for changes is the one key with any Git involvement — it’s the elapsed time between a commit landing and that same code successfully running in production, using a commit timestamp as one endpoint of a two-point measurement, not a count of commits in between. The other three never open git log. Deployment frequency comes from CI/CD release records. Change failure rate comes from tracking which deployments required a hotfix, rollback, or incident response. Time to restore service comes from incident-tracking timestamps: when an outage was declared, when it was resolved. All four keys are anchored to events with external, verifiable meaning — a deployment happened, an incident happened, a fixed amount of wall-clock time elapsed between two of them — which is exactly the property commit counts lack.
The 2024 State of DevOps findings put numbers on the gap: elite performers deploy on demand, with lead time for changes under a day and a change failure rate near 5%, while low performers take one to six months to get a change into production. The research’s headline finding cuts against the intuitive tradeoff — speed and stability move together across teams rather than trading off against each other, meaning the fastest performers are also among the most reliable, not despite moving fast but as part of the same underlying capability.

| Key | What it measures | Where the data comes from | NOT measured by |
|---|---|---|---|
| Deployment frequency | How often code reaches production | CI/CD deployment and release logs | Commit count |
| Lead time for changes | Elapsed time from a commit landing to that code running in production | One commit timestamp + one deploy timestamp, from the pipeline | The number of commits in between |
| Change failure rate | Share of production deployments that require a hotfix, rollback, or incident response | Incident and rollback tracking tied to each deployment | Lines of code changed |
| Time to restore service | How long it takes to recover from a production failure | Incident-tracking timestamps — declared to resolved | Git history at all |
SPACE: The Multidimensional Counterweight
Where DORA measures the pipeline, the SPACE framework (Nicole Forsgren, Margaret-Anne Storey, and colleagues from Microsoft Research, GitHub, and the University of Victoria, ACM Queue 19(1), 2021) addresses the individual- and team-level question DORA doesn’t try to answer, and it does so by naming the trap this whole article is about directly. SPACE’s five dimensions are Satisfaction and well-being, Performance, Activity, Communication and collaboration, and Efficiency and flow. Commits, pull requests, and code reviews land squarely in the Activity dimension — and the paper’s own authors warn that Activity, read alone and without the other four dimensions for context, produces misleading conclusions about who is doing valuable work ([academic] Forsgren et al., “The SPACE of Developer Productivity,” ACM Queue 19(1), 2021).
The mechanism is intuitive once stated: an engineer committing constantly might be thrashing — small, uncertain edits, false starts, exploratory churn — while an engineer who ships one well-scoped commit that quietly fixes the quarter’s worst production issue looks, on an Activity-only dashboard, like the less productive one. SPACE’s point isn’t “track more numbers.” It’s that no single dimension, and especially not Activity, should ever stand in as a proxy for “productivity” on its own.
| SPACE dimension | What it captures | Example indicator |
|---|---|---|
| Satisfaction & well-being | How fulfilled and un-burned-out developers feel | Survey-based satisfaction and retention signals |
| Performance | The outcome of the work, not the activity that produced it | Reliability, quality, customer-facing impact |
| Activity | Count of actions taken | Commits, pull requests, code reviews — the dimension raw commit-counting mistakes for the whole picture |
| Communication & collaboration | How well work and knowledge move between people | Documentation discoverability, review turnaround time |
| Efficiency & flow | Ability to complete work with minimal interruption | Handoff count, wait time, context-switch frequency |
What a “Good Day” Actually Looks Like
Microsoft’s internal research puts a human face on the same finding. In “Today Was a Good Day: The Daily Life of Software Developers” (Meyer, Barr, Bird, and Zimmermann, IEEE Transactions on Software Engineering, 2019), the authors combined a 5,971-response survey with diary and sensor data from Microsoft engineers to ask what actually predicted a self-reported “good day.” The answer wasn’t commit volume or raw activity. It was completing meaningful, planned work and having fewer interruptions — meetings, context switches, unplanned firefighting ([academic] Meyer, Barr, Bird & Zimmermann, “Today Was a Good Day,” IEEE TSE, 2019).
That finding cuts directly against the contribution-graph model of productivity. A day spent reading unfamiliar code, designing a change carefully before touching it, or tracking down a hard production bug can produce zero commits and still be the most valuable day of someone’s sprint — while a day of low-judgment, high-volume commits can be the busy kind of unproductive. A metric that can’t tell those two days apart isn’t a lesser version of the right metric; it’s measuring the wrong thing entirely.

The AI Coding Agent Problem: Commit Counts Get Even Less Meaningful
Everything above predates AI coding agents, and all of it gets worse once they’re in the loop. An agent can generate several commits and hundreds of lines for a change a senior engineer would have solved with a five-line diff and ten minutes of judgment — the artifact count goes up while the amount of actual decision-making an organization should be paying for goes down. Our DORA Metrics for AI Coding Agents piece covers how teams are already seeing deployment-frequency and lead-time numbers get gamed by agent-assisted commit volume, and the fix is the same one this article is making generally: measure the pipeline outcome, not the artifact count.
The judgment work doesn’t disappear in an AI-assisted pipeline — it moves. Human PR review of AI-generated changes becomes a larger share of an engineer’s real output even as their personal commit count may fall, because verifying a plausible-but-wrong diff is real engineering work that a commit graph cannot see at all. A structured code-review rubric and a clearly documented agentic development loop are what keep a fast, AI-assisted pipeline honest, and a quality harness built to catch AI code slop does the same job DORA’s change-failure-rate key does for a human-only team — it converts “this PR feels fine” into something verifiable, instead of trusting how much code got produced.
Measure Outcomes With External Verifiable Meaning
Every distortion in this article shares one shape. Squash-merge policy, rename-detection heuristics, monorepo-versus-polyrepo topology, and individual commit cadence are all decisions a team already controls internally — and each one can move a Git-internal count up or down without changing what shipped, whether it worked, or how fast a customer-facing problem got fixed. DORA’s four keys resist that failure mode structurally: three of the four never touch Git at all, and the fourth uses a commit timestamp as one edge of an externally verifiable event — code running in production — rather than a count of Git objects. SPACE resists it by refusing to let Activity stand in for the whole picture, and Microsoft’s own internal research backs that refusal with data from thousands of real workdays.
The rule generalizes past Git entirely: measure outcomes with external, verifiable meaning — a deployment happened, an incident happened, a customer noticed something changed — not artifacts sitting in your system of record. Anything counted purely because your tooling already counts it for free is a candidate for exactly this failure mode, on any team, in any stack. If a policy change can move the number without moving the outcome, it was never measuring the outcome.
❓ Frequently Asked Questions
Is commit count ever a useful signal for engineering leaders? As a rough operational check — is a repository or team active at all — sure, in the same way a heartbeat check confirms a service is up. As a productivity or performance signal for ranking individuals or teams, no: squash-merge policy, rename heuristics, monorepo-versus-polyrepo structure, and personal commit habits each move the raw number independent of delivered work, so the count reflects convention more than output.
What is DORA, and where do the four keys come from? DORA (DevOps Research and Assessment) is the research program behind Nicole Forsgren, Jez Humble, and Gene Kim’s book Accelerate (2018), built on an annual State of DevOps survey run across thousands of organizations. Its four keys — deployment frequency, lead time for changes, change failure rate, and time to restore service — are deployment-pipeline metrics, not a way of scoring Git history.
Does squash-merge actually lose commit history? The individual commits become unreachable from any branch once the squashed commit replaces them on main, and Git eventually garbage-collects unreachable objects — but the change itself isn’t lost, since the squashed commit still carries the combined diff. What’s lost is the fine-grained commit-by-commit record, which is exactly why “commits per engineer” swings so hard when a team’s default merge strategy changes.
Is SPACE meant to replace DORA? No — they answer different questions. DORA measures the deployment pipeline’s speed and stability at the team or organization level. SPACE is a broader lens for individual and team developer experience, explicitly built to stop Activity metrics like commit count from being mistaken for the whole picture. Many organizations that adopt DORA for pipeline health also use SPACE’s other four dimensions to keep individual-level activity data honest.
How do AI coding agents change this problem? They make it worse in the same direction it already leaned. An agent can produce more commits and more changed lines for work that requires less human judgment than a smaller, hand-written diff — inflating exactly the artifact counts this article argues against, while the real engineering effort shifts toward reviewing and verifying AI-generated changes rather than authoring them from scratch.
What is the “Today Was a Good Day” study, specifically? It’s Meyer, Barr, Bird, and Zimmermann’s 2019 IEEE Transactions on Software Engineering study, combining a 5,971-response Microsoft-internal survey with diary and sensor data to find out what predicted a developer’s self-reported good day. The answer was completing meaningful, planned work with fewer interruptions — not commit volume or raw activity.
📚 Further Reading
- DORA Metrics for AI Coding Agents: Stop the Gaming — what happens to deployment frequency and lead time once an AI agent is committing code, and how to keep the pipeline metrics honest.
- Human PR Review of AI Agents: The Judgment Ratchet and A Code Review Rubric for AI-Generated Pull Requests — where the real judgment work moves once commit volume stops meaning what it used to.
- Prevent AI Code Slop: A Quality Harness Guide and The Agentic Development Loop, Explained for Engineers — building the verification layer that replaces “how much code got produced” with something actually measurable.
📚 Recommended Resources
Disclosure: some links below are Amazon affiliate links. If you buy through them, I earn a small commission — at no extra cost to you — which helps keep this site running.
Accelerate: The Science of Lean Software and DevOps
Nicole Forsgren, Jez Humble & Gene Kim · Book · ~$30 on Amazon
The primary source for everything in this article’s DORA section. Forsgren, Humble, and Kim lay out the four keys and the research behind them — 23,000+ respondents across 2,000+ organizations — including the finding this piece leans on hardest: speed and stability move together, they don’t trade off. If you only add one book to your team’s reading list after this article, make it this one.
Continuous Delivery
Jez Humble & David Farley · Book · ~$45 on Amazon
The mechanism-level companion to Accelerate: the pipeline discipline — automated, repeatable, low-risk releases — that DORA’s metrics measure the effects of. Read this if the “deployment frequency” and “change failure rate” keys make you realize your release process, not your commit habits, is the real bottleneck.
Software Engineering at Google
Titus Winters, Tom Manshreck & Hyrum Wright · Book · ~$45 on Amazon
Google’s own account of engineering practice at monorepo scale — a useful counterweight to any commit-count comparison, since Google’s Piper isn’t Git and its scale of collaboration was never going to be measured by a contribution graph. Also free in full as HTML at abseil.io/resources/swe-book under CC BY-NC-ND 4.0 — worth reading either way, before deciding whether the print copy earns a shelf spot.