Skip to content
Quevell
Menu

You don't need story points. Not even in Scrum.

Scrum doesn't require story points, and velocity isn't a measure of developer productivity. A look at relative estimation, flow metrics, and how teams can plan work using actual delivery data.

2026-11-18 · Position

logo

I stopped relying on story points about three or four years ago, back when we were still working with Scrum.

We continued planning sprints, discussing priorities, reviewing completed work, and improving our process. What became increasingly difficult to justify was assigning an abstract number to every issue.

Recently, I came across a claim that story points are dead. The argument was that estimation was mostly a trust problem: if you trust your developers, why make them assign points to everything? And with AI accelerating implementation, perhaps time matters less than product risk and complexity.

There is something compelling about that argument. But it also skips a few important questions.

What were story points supposed to solve? Do they still solve it? And what actually happens when a team stops using them?

Scrum never required story points

This is worth establishing before discussing whether estimation is useful.

The official Scrum Guide does not require story points, Fibonacci sequences, Planning Poker, or point-based velocity.

It describes Product Backlog refinement, including the size of backlog items. Developers are responsible for sizing the work, but the guide does not prescribe a particular technique or unit.

For Sprint Planning, it emphasizes understanding previous performance, upcoming capacity, and the Definition of Done. Better knowledge of those factors makes forecasting more reliable.

Scrum requires planning and an empirical understanding of what a team can accomplish. It does not require assigning five points to an issue.

A team can work in sprints, maintain a Sprint Goal, conduct reviews and retrospectives, and deliver usable increments without adopting story points.

Removing them does not, by itself, mean abandoning Scrum.

When estimation becomes the work

Relative estimation has a reasonable purpose.

Developers often cannot predict how many hours an unfamiliar task will require. Comparing tasks can be easier than assigning precise durations.

One issue seems straightforward. Another involves several components. A third contains unknown dependencies that could make the implementation substantially more difficult.

Discussing these differences can be valuable.

If one developer thinks an issue is trivial and another considers it complex, the disagreement may expose missing requirements or a technical risk. The conversation is useful even if nobody agrees on a number.

Problems begin when the number becomes a performance measure.

Imagine two developers. One completes 25 story points during a sprint, while the other completes 12.

Was the first developer twice as productive?

The second might have investigated a production incident, prevented a security problem, resolved architectural uncertainty, or helped several colleagues finish their work.

None of that is adequately represented by a single total.

Even comparing velocity across teams is unreliable because teams develop different estimation scales. This limitation is acknowledged in published guidance on agile metrics.

Story points can support planning within a team. They cannot reliably rank people or establish which team creates more value.

Once a number becomes a target for individual performance, it also becomes something people have an incentive to optimize independently of the actual work.

What if you set a time budget instead?

One alternative appears in Shape Up.

Rather than starting with a proposed solution and asking how long it will take, the process begins by deciding how much time the problem deserves.

This is called an appetite.

A small improvement might justify one or two weeks of work. A substantial project might receive a six-week cycle.

The team then shapes a solution that fits the available time.

If the intended implementation is too large, the scope needs to change. The team looks for a smaller, meaningful outcome rather than automatically extending the schedule.

This approach does not eliminate uncertainty. It establishes a boundary around how much of that uncertainty the organization is prepared to absorb.

It also requires judgment. Not every requirement is negotiable. Regulatory obligations, critical defects, and explicit contractual commitments may leave little room to adjust scope.

Still, Shape Up demonstrates that teams can plan substantial work through time constraints, priorities, and deliberate scope decisions without estimating every issue in points.

The central question becomes how to deliver something meaningful within an agreed investment.

Measuring the work that actually happened

Another approach is to base forecasts on historical delivery data.

The May 2025 Kanban Guide defines four fundamental flow metrics:

  • Work in Progress: The number of items started but not yet finished.
  • Throughput: The number of items completed during a period.
  • Cycle Time: The elapsed time between starting and finishing an item.
  • Work Item Age: How long an unfinished item has already been in progress.

These measures provide a different view of delivery.

How much work is the team completing? How long does an item remain in progress? Which items are aging beyond expectations? Is the team trying to do too many things simultaneously?

The guide also defines a Service Level Expectation, or SLE, as a forecast combining a time period and a probability.

For example, a team might have historical evidence supporting the statement that 85% of its work items finish within eight days.

This does not guarantee that the next issue will take eight days. It describes what the observed system has been capable of delivering.

There are limitations, of course.

Counting completed issues becomes misleading if a team treats a one-line fix and a major architectural change as equivalent units of work. Useful forecasts require a sensible definition of work items, appropriate grouping, and enough historical observations.

Flow metrics are also not business value metrics. Finishing more items does not automatically mean delivering a better product.

But they offer something story points cannot provide on their own: direct measurements of how work moves through the system.

And they require no fictional unit of complexity.

Productivity is bigger than one number

The 2021 research paper The SPACE of Developer Productivity made an important point: developer productivity cannot be adequately measured by a single metric.

The SPACE framework considers satisfaction and well-being, performance, activity, communication and collaboration, and efficiency and flow.

That does not mean every engineering organization needs an elaborate dashboard covering all five dimensions.

It means the work is too varied to be understood through a single quantity.

A developer might ship several small changes in a day. Another might spend that day investigating a complex failure that could affect thousands of users.

A team might complete every planned issue but introduce serious regressions. Another might decide not to implement an expensive feature after discovering a simpler way to solve the underlying problem.

Those outcomes cannot be meaningfully compared by adding up story points.

Activity matters. Delivery speed matters. But neither should be confused with the complete value of engineering work.

Does AI make story points obsolete?

AI has certainly changed software development.

Generating an initial implementation can be substantially faster. But generated code still needs to be understood, reviewed, tested, integrated, and maintained.

The 2025 DORA research describes AI as an amplifier of existing organizational strengths and weaknesses.

In a March 2026 analysis, DORA researchers reported that time saved during initial code generation is frequently reallocated to auditing and verification.

Higher AI adoption was associated with increased software delivery throughput, but also with greater delivery instability.

In other words, faster code generation does not automatically mean faster or safer production delivery.

AI changes where the effort goes. It does not eliminate the need to understand dependencies, assess risk, or validate results.

The argument that time no longer matters is particularly difficult to defend. Customers still need reliable delivery dates. Production incidents still require timely responses. Organizations still have finite engineering capacity.

What matters is understanding the full delivery process rather than treating code generation as the entire job.

AI does not make story points mandatory or unnecessary. It makes it even more important to know what the team is actually measuring.

Planning without points is still planning

Removing story points does not eliminate difficult planning conversations.

What can we deliver this cycle? Which dependencies might block us? How much uncertainty are we accepting? When should stakeholders expect a result? What happens if the scope changes?

Teams still need answers.

They can break large initiatives into smaller deliverable pieces, investigate unknowns before committing to implementation, and use historical delivery data to inform forecasts.

They can track aging work, identify bottlenecks, and examine quality alongside delivery speed.

They can also use rough estimates where those estimates genuinely improve a decision.

There is no requirement to choose one measurement technique for every situation.

If relative estimation helps a team uncover complexity and plan effectively, that is a reasonable reason to keep using it.

If the team can make reliable commitments without story points, bringing them back solely because the process is supposed to include them adds little value.

I stopped using story points years ago, not because I stopped caring about planning.

At some point, the numbers simply stopped telling me enough about the work.

The sprints continued. Planning continued. We still had to discuss priorities, understand risks, review outcomes, and take responsibility for what we delivered.

We just no longer needed to spend time deciding whether an issue deserved three points or five.

#Work management #Product development #Scrum