What Is Coding Velocity, and How Do You Measure It Without Gaming It?
Direct answer: Coding velocity is how quickly a team turns an idea into working software that users actually have, not how fast people type or how many lines they write. Measure it at the team level with delivery metrics like DORA's change lead time and deployment frequency, always paired with stability metrics like change fail rate. Never turn a single velocity number into a target, because people will hit the number and miss the point.
"Velocity" gets thrown around in every engineering planning meeting, and it means something different to each person in the room. To a Scrum team it's story points per sprint. To a founder it's "why isn't this shipped yet". To an engineer with an AI assistant it's how fast code appears on the screen. This post separates those ideas, shows what's actually worth measuring, and covers what AI tools did to the picture. My earlier post on how AI coding tools changed our engineering velocity covers our own experience; this one is the measurement side.
What is coding velocity?#
Coding velocity is the rate at which a team delivers working, valuable changes to production. Three words in that definition do the heavy lifting:
- Team, not individual. Software is a group activity; measuring individuals mostly measures who picked the easy tickets.
- Working. A change that ships and gets rolled back added zero velocity and some negative morale.
- Production. Code on a branch or waiting in review isn't delivered.
Three things people mean by velocity#
| Term | What it counts | Good for | Bad for |
|---|---|---|---|
| Sprint velocity | Story points completed per sprint | A team forecasting its own next sprint | Comparing teams, or judging performance; points inflate the moment they're watched |
| Coding speed | Lines, commits, PRs, AI suggestions accepted | Almost nothing on its own | Rewards volume, which is the opposite of good engineering |
| Delivery velocity | Lead time, deployment frequency, with failure and rework rates | Seeing whether the system that ships software is getting better | Single-number targets, cross-team league tables |
When someone searches "coding velocity", they usually want the third one, and they usually get sold the second.
How to measure it: DORA metrics#
The most widely used framework comes from DORA (DevOps Research and Assessment), now part of Google Cloud. DORA's current guide lists five software delivery metrics in two groups:
| Group | Metric | Question it answers |
|---|---|---|
| Throughput | Change lead time | How long from commit to running in production? |
| Throughput | Deployment frequency | How often do we ship? |
| Throughput | Failed deployment recovery time | When a deploy breaks something, how fast do we recover? |
| Instability | Change fail rate | What share of deploys cause a failure? |
| Instability | Deployment rework rate | How many deploys are unplanned fixes for earlier ones? |
The pairing is the point. Speed metrics without instability metrics reward shipping broken code quickly. DORA's own guidance warns against "having one metric to rule them all" and recommends several metrics "with some healthy tension between them."
For the human side, the SPACE framework (Forsgren, Storey and colleagues, 2021) adds satisfaction, collaboration and flow. A team that ships fast while burning out is borrowing velocity from next quarter.
How to measure velocity without gaming it#
Goodhart's law applies to engineering more brutally than anywhere: once a measure becomes a target, it stops being a good measure. DORA's guide lists "setting metrics as a goal" as a pitfall in its own right. Practical rules:
- Measure the system, not people. Lead time is a property of your pipeline, review habits and architecture. Use it to find bottlenecks, never to rank engineers.
- Watch trends, not thresholds. "Lead time went from 4 days to 9 days this quarter" starts a useful conversation. "Lead time must be under 2 days" starts a gaming exercise.
- Don't compare teams. DORA warns that comparing "vastly different applications" misleads. A payments service and a marketing site shouldn't deploy at the same rate.
- Treat test coverage as a guardrail, not a score. Coverage tells you what's definitely untested. A coverage target produces tests that execute code without checking anything.
- Ignore activity metrics. Commits, lines changed and PR counts measure motion.
What AI changed about coding velocity#
AI tools made code production much faster and left the rest of delivery about where it was. That's the short version, and the research is more mixed than the marketing.
- In the 2025 Stack Overflow Developer Survey, 84% of respondents said they use or plan to use AI tools, but more developers distrusted the accuracy of AI output (46%) than trusted it (33%).
- METR's randomised study of 16 experienced open-source developers in early 2025 found they took 19% longer with AI tools on their own mature codebases, while estimating afterwards that AI had made them 20% faster. METR is careful to say the result is specific to that setting.
The lesson for measurement: if you only measure how fast code gets written, AI will look like a miracle. If you measure lead time and change fail rate, you'll see whether review, testing and deployment kept up. In most teams the bottleneck simply moves to review. That's why "AI suggestions accepted" is a vanity metric and lead time paired with rework rate is not.
What actually improves velocity#
The gains usually come from boring places:
- Smaller changes. Small PRs get reviewed faster, fail less and roll back easily.
- Fast, trusted CI. If the pipeline takes 40 minutes or flakes, every other improvement is capped.
- Review as a priority. A PR waiting a day for review is a day of lead time, every time.
- Clear business rules. Most rework comes from misunderstood requirements, not bad code. I've argued that in business logic first.
- Deciding what not to build. The fastest feature is the one you didn't need (more on that).
If you're in the middle of a large rewrite, velocity and quality pull hardest against each other. I wrote a separate guide on keeping code quality high during a major rewrite.
Frequently asked questions#
What is the difference between coding velocity and sprint velocity?#
Sprint velocity counts story points a Scrum team completes per sprint and is only useful for that team's own planning. Coding or delivery velocity is how fast working changes reach production, measured with metrics like lead time and deployment frequency.
What are the DORA metrics?#
DORA's current guide lists five: change lead time, deployment frequency and failed deployment recovery time (throughput), and change fail rate and deployment rework rate (instability).
Does AI increase coding velocity?#
It speeds up writing code, but the evidence on delivery is mixed. METR found experienced developers 19% slower with early-2025 AI tools on mature codebases. Measure lead time and rework to see the real effect on your team.
Should test coverage be a velocity target?#
No. Use coverage as a guardrail to find untested code. A coverage target encourages tests that execute code without checking behaviour.
Should I measure individual developer velocity?#
No. Delivery speed is mostly a property of the system: pipeline, review habits and architecture. Ranking individuals encourages gaming and hides the real bottlenecks.
Key takeaways#
- Coding velocity is how fast a team delivers working changes to production, not how fast code gets written.
- Measure it with DORA's five metrics: change lead time, deployment frequency and failed deployment recovery time, balanced by change fail rate and deployment rework rate.
- Measure teams and trends; never rank individuals or set single-number targets.
- AI sped up writing code, but research shows mixed effects on delivery. Measure lead time and rework, not suggestions accepted.
- The biggest gains come from small changes, fast CI, prompt reviews and clear requirements.
Sources#
- DORA: software delivery performance metrics
- Forsgren et al.: The SPACE of Developer Productivity (ACM Queue, 2021)
- METR: Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity
- Stack Overflow: 2025 Developer Survey results
Trying to speed up a team without breaking things? Let's talk.