AI shortened the time it takes to build a feature, but not the time it takes to decide what to build or to learn whether it worked. The Three Clocks framework shows where your bottleneck moved.

Product velocity is the speed at which a team turns ideas into validated outcomes, not the speed at which it ships code. AI has shortened build time for many teams, but not the time it takes to decide what to build or to learn whether it worked. Measure all three, the Decision, Build and Validation Clocks, or a faster build clock will look like progress when it isn't.

Key takeaways

  • More output is not more progress. On teams with high AI adoption, developers merged 98% more pull requests, but review time rose 91% and the gains disappeared at company level (Faros AI, 2025).
  • Even the build speed-up is uneven. One controlled study found a 55.8% faster task with AI; another found experienced developers 19% slower on their own repositories while believing they were 20% faster (METR, 2025).
  • Delivery metrics stop at production. DORA's change lead time runs from commit to deploy (DORA). It says nothing about deciding or validating.
  • Most shipped work doesn't pay off. About one-third of ideas tested at Microsoft improved the metric they targeted (Kohavi et al., 2009), and 80% of features in the average product are rarely or never used (Pendo, 2019).
  • Spend build savings on the slow clocks: more discovery before committing, and a firm outcome check after launch.

What is the product velocity illusion?

Product teams are shipping more than ever. Pull request counts are up and sprint charts point up and to the right. Yet many teams have the same nagging question: if we are building this much faster, why doesn't it feel like we are moving faster?

That gap has a name. Faros AI called it the AI productivity paradox after analysing telemetry from more than 10,000 developers across 1,255 teams: developers on high-adoption teams completed 21% more tasks and merged 98% more pull requests, yet any link between AI adoption and performance disappeared at company level (Faros AI, 2025).

The product velocity illusion is the product-management version of the same effect. AI made one part of the product cycle faster. It left the other two where they were. Because the fast part is the most visible one (commits, PRs, shipped features), it is easy to mistake "we're building faster" for "we're moving faster." Those are different claims, and conflating them quietly damages roadmaps.

Perception makes it worse. 52% of developers say AI tools have had a positive effect on their productivity (Stack Overflow, 2025), and more than 80% of DORA's 2025 respondents believe AI increased theirs (Google Cloud, 2025). But in METR's 2025 randomised trial, 16 experienced open-source developers expected AI to speed them up by 24%, took 19% longer with it, and afterwards still believed it had sped them up by 20% (METR, 2025). If people misjudge their own build speed, a dashboard of build activity is an even weaker guide to overall progress. The wider 2026 picture of what got cheap and what didn't is in building got cheap: the 2026 data.

Why did the velocity metric stop telling the truth?

Most product teams still report velocity as one number: story points per sprint, features shipped per quarter, or cycle time from ticket to deploy. For a decade that was a reasonable proxy, because build time was the dominant cost. If build took most of the time between "we have an idea" and "the idea is live", a metric that tracked build tracked most of what mattered.

That ratio has shifted. On a team using AI-assisted development well, build time for a well-specified feature can shrink to a small share of the cycle. But the time spent deciding whether the feature was worth building, and finding out whether it worked, hasn't compressed. Those phases are gated by things AI doesn't touch: stakeholder alignment, customers' availability for research, and the days of real usage you need before a signal is trustworthy.

Engineering metrics were never meant to cover those phases. DORA, Google Cloud's software delivery research programme, now tracks five metrics: change lead time, deployment frequency, failed deployment recovery time, change fail rate and deployment rework rate. Change lead time is measured from commit to deployment in production (DORA). DORA itself warns against "one metric to rule them all" and against turning metrics into targets, citing Goodhart's law.

So a single velocity number now describes the fastest-moving part of the cycle and stays silent on the rest. Teams look productive on the dashboard and stuck in the market. That is why "we shipped 40% more features this quarter" and "activation hasn't moved in two quarters" can sit in the same board deck without anyone connecting them.

What are the Three Clocks of product velocity?

The fix isn't a better velocity metric. It is to retire the single number and replace it with three, because an idea passes through three distinct clocks on its way to creating value, and they run at very different speeds.

1. The Decision Clock

The time from "we noticed a problem or opportunity" to "we committed to building a specific solution." It includes framing the problem, weighing it against everything else competing for the roadmap, and getting the people who need to agree to actually agree.

AI can summarise research and draft the options memo. It cannot make the trade-off for you, and it cannot make a VP of Sales and a Head of Engineering converge faster than they are willing to. The bottleneck here was never information retrieval. It was alignment.

2. The Build Clock

The time from commitment to the feature being live. This is the clock AI has changed most, though less evenly than vendor demos suggest:

  • In a 2023 controlled experiment, developers with an AI pair programmer implemented an HTTP server 55.8% faster than a control group (Peng et al., 2023).
  • In METR's follow-up with 57 developers and more than 800 tasks, the estimated effect was still a slowdown for returning developers (-18%, confidence interval -38% to +9%) and roughly neutral for new ones (-4%, -15% to +9%). METR cautions that the true speed-up could be higher, because some developers and tasks dropped out of the study design (METR, 2026).
  • DORA's 2024 report associated rising AI adoption with an estimated 1.5% drop in delivery throughput and a 7.2% drop in delivery stability (Google Cloud, 2024). In 2025 the throughput relationship turned positive, but stability was still negatively affected (Google Cloud, 2025).

The pattern: typing code got faster; reviewing, integrating and stabilising it did not keep pace. Faros found pull request review time up 91% on high-adoption teams, with human approval as the new bottleneck. If you manage engineers through this, measure outcomes, not lines of code. The trap is treating the Build Clock as a stand-in for the whole cycle. It is one gear in a three-gear system, and speeding one gear doesn't speed the chain.

3. The Validation Clock

The time from "the feature is live" to "we know, with reasonable confidence, whether it worked." It is gated by how many users must touch the feature before there is a signal, how long a behaviour change takes to show (a pricing change may show its real effect at the next renewal, not the next login), and whether the team actually closes the loop instead of moving on.

AI hasn't compressed this clock, and in some organisations it has made it worse: faster shipping stacks up more unvalidated features in production, each one adding noise to the next measurement. The base rate is sobering. At Microsoft, only about one-third of ideas improved the metric they were designed to improve; about one-third hurt it and one-third made no difference (Kohavi et al., 2009).

Clock Starts Ends Gated by Effect of AI so far
Decision Problem or opportunity noticed Committed bet with a success metric Alignment, evidence, trade-offs Faster research and drafts; alignment unchanged
Build Bet committed Feature live in production Coding, review, integration, stability Often faster to write; review and stability lag
Validation Feature live Outcome known (worked, flat or hurt) Usage volume, behaviour lag, follow-through Largely unchanged; more unvalidated launches

Why is the illusion expensive, not just misleading?

A team that only tracks the Build Clock keeps making one costly mistake: pulling forward work that is cheap to build but hasn't cleared the Decision Clock, because "we can just try it, it's fast now." That instinct feels like agility. In practice the fastest-shipping teams are often the ones burying their Validation Clock deepest: more surface area shipped per quarter, with the same number of people available to check whether any of it moved a metric.

This is the mechanism behind a well-documented usage pattern. Pendo's analysis of anonymised usage data found that 80% of features in the average software product are rarely or never used, while 12% of features generate 80% of daily usage volume (Pendo, 2019). Cheaper building doesn't fix that. It can make it worse, by making it easier to ship past the point where you have earned the right to build. We unpack the Pendo figure and its limits in why 80% of features are rarely or never used.

How do you measure product velocity with the Three Clocks?

You don't need new tooling to start. You need three timestamps per bet and a quarterly review.

  1. Define what counts as a bet. Any roadmap item big enough to have a success metric. Small fixes stay out.
  2. Record three dates for each bet: when the problem was first logged, when the team committed (with a written success metric), and when the outcome was judged worked, flat or hurt.
  3. Take deploy dates from your delivery data. If you already track DORA metrics, the Build Clock is roughly commitment to deploy, which includes change lead time.
  4. Report medians, not averages. One stalled bet shouldn't hide nine fast ones, or the other way round.
  5. Report idea-to-validated-outcome time next to "features shipped", along with the share of shipped bets that reached a verdict.
  6. Review quarterly. If the Build Clock shrinks while the other two stay flat, your bottleneck has moved and your process hasn't caught up.

Three Clocks quarterly report (copy this)

Metric This quarter Last quarter
Bets committed
Median Decision Clock (days)
Median Build Clock (days)
Median Validation Clock (days)
Median idea-to-validated-outcome (days)
Shipped bets with a verdict (%)
Verdicts: worked / flat / hurt

For the decision side, a product decision log gives you the commitment date and the success metric in one place.

What does this look like with real numbers? A worked example

Illustrative example. Say a 7-person product team commits to 8 bets in a quarter. The medians come out like this:

  • Decision Clock: 21 days (problem logged to committed bet)
  • Build Clock: 4 days (down from 15 days a year earlier, after adopting AI coding tools)
  • Validation Clock: 45 days, but only 3 of the 8 shipped bets reached a verdict at all

Idea-to-validated-outcome is 70 days, of which build is under 6%. A year ago, with the same decision and validation times, it was 81 days. The team "built nearly four times faster" and moved about 14% faster end to end, and five bets this quarter have no verdict, so nobody knows whether they helped.

The fix is not a faster build. Cutting the Validation Clock from 45 to 30 days by defining the metric and check date before launch, and getting all 8 bets to a verdict, would do more for real product velocity than any further coding speed-up.

How do you run the Three Clocks in practice?

The framework only earns its keep if it changes what gets measured and discussed in planning. Three moves make that concrete.

Report all three clocks, not one. Next to "features shipped", track median Decision Clock time (idea to committed bet) and median Validation Clock time (ship to verified outcome) for the quarter. If the Build Clock keeps shrinking while the other two stay flat, that's not a productivity win to celebrate. It's a signal that your bottleneck has moved.

Spend the Build Clock savings on the Decision Clock, deliberately. If a feature that used to take three weeks to build now takes three days, don't just ship earlier. Use the time to run a real discovery pass: a handful of customer conversations, a small prototype test, a pre-mortem with the team, before committing to the full build. The point of faster building isn't shipping sooner. It's affording more validation before you commit, for the same total cycle time. Learning velocity covers how to speed up that loop.

Make Validation Clock completion a release gate, not a follow-up task. The easiest way for the Validation Clock to balloon is to treat "check if it worked" as optional clean-up that competes with the next sprint's build work and usually loses. Define the metric and the date you will check it before the feature ships, and put that check on the roadmap with the same visibility as the build ticket. A bet that never gets its outcome checked isn't information. It is just more shipped surface area with an unknown return.

What mistakes do teams make when measuring product velocity?

  • Celebrating PR counts. More merged PRs with 91% longer reviews is a queue, not progress.
  • Using DORA metrics as product metrics. They measure delivery health. Keep them, but don't let them answer "are we building the right things?"
  • Turning the clocks into targets. DORA's Goodhart's-law warning applies here too. A team pushed to shrink the Decision Clock will skip discovery.
  • Counting launches as outcomes. A feature is not done when it ships; it is done when you know whether it worked.
  • Ignoring flat results. At Microsoft about a third of ideas were flat. Flat is an answer: stop investing, or remove the feature.

The Three Clocks fit best for teams shipping product bets with measurable outcomes. For pure maintenance, infrastructure or compliance work, delivery metrics may be enough on their own. And if your team is drowning in unvalidated launches, the warning signs in stop the feature factory will look familiar.

Where Specky fits

Specky keeps the slow clocks visible. Each decision goes into the Decision Log with the customer evidence behind it, PRDs carry inline citations to that evidence, and after launch Specky checks whether the bet worked against the metric you set. Because all of it lives in one Product Graph, the Decision and Validation Clocks stop running invisibly in someone's head.

Frequently asked questions

What is product velocity?

Product velocity is how quickly a team turns ideas into validated outcomes: from noticing a problem, to committing to a solution, to shipping it, to knowing whether it worked. It differs from engineering velocity, which measures how fast code moves from commit to production. A team can raise engineering velocity while product velocity stays flat.

How do you measure product velocity?

Record three dates for each roadmap bet: when the problem was logged, when the team committed with a success metric, and when the outcome was judged. Report median Decision, Build and Validation Clock times each quarter, plus total idea-to-validated-outcome time and the share of shipped bets that reached a verdict.

Does AI make software teams faster?

At writing code, often yes; end to end, the evidence is mixed. One controlled study measured a 55.8% faster task, while METR found experienced developers 19% slower on their own repositories. Faros saw 98% more merged pull requests on high-adoption teams but 91% longer reviews and no company-level gain. DORA 2025 still links AI to lower stability.

What is the AI productivity paradox?

It is the gap between individual and organisational gains from AI. Faros AI coined the term in 2025 after finding that developers on high-AI teams completed 21% more tasks and merged 98% more pull requests, while the link to performance disappeared at company level. The bottleneck moved to review, integration and deciding what to build.

Are DORA metrics enough to measure product team performance?

No. DORA's five metrics, including change lead time from commit to production and change fail rate, measure software delivery health. They don't cover deciding what to build or checking whether it worked. Use them for the Build Clock, and add Decision and Validation Clock measures for the rest.

Sources

  1. DORA — DORA's software delivery performance metrics
  2. Faros AI — The AI Productivity Paradox Report 2025
  3. METR — Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity
  4. METR — We are Changing our Developer Productivity Experiment Design (February 2026)
  5. Peng et al. — The Impact of AI on Developer Productivity: Evidence from GitHub Copilot (arXiv)
  6. Google Cloud — Announcing the 2024 DORA report
  7. Google Cloud — Announcing the 2025 DORA report
  8. Stack Overflow — 2025 Developer Survey: AI
  9. Pendo — The 2019 Feature Adoption Report
  10. Kohavi et al. — Online Experimentation at Microsoft (2009)

This story was originally published on 29 July 2026 at https://www.specky.space/blog/product-velocity-illusion.