---
title: "Deciding by delivering"
description: "Build → measure → learn. There’s no stopping it now."
canonical_url: "https://davesabine.com/articles/2026/11/deciding-by-delivering"
---

> Index of every page on this site: [llms.txt](https://davesabine.com/llms.txt)

*This is part 4 of 4 in a series about product development teams with AI agents. The other parts are linked at the end.*

## Decide by delivering

I meet executives and managers suffering analysis paralysis. They are desparately trying to **decide by planning** — an impossible pursuit in any complex work. Decades of my career have been devoted to helping those companies understand they cannot plan their way through complexity: they must **decide by doing**.

> “It is in the doing of the work that we discover the work that we must do. Doing exposes reality.”
> — [The 8 Agile Maxims of Woody Zuill](https://zuill.us/WoodyZuill/2012/09/16/the-8-agile-maxims-of-woody-zuill/)

> “The crucial variables are discovered by accident.”
> — John Gall [The Systems Bible, pg 98](https://amazon.ca/dp/B00AK1BIDM)

**Doing**, in my line of work, used to mean **start writing the code**. But even that bottleneck is gone and **doing** now means **deliver**. The fastest way to decide what to build is to build it, put it in front of real users, and study the outcomes.

That was always true but the price signals are radically different today than they were even a few months ago. Agents now produce in minutes what a full team of developers used to do in weeks. A working prototype costs less than a conventional project plan (see [part 1](https://davesabine.com/articles/2026/11/the-bottleneck-dissolved/)), so the case for deciding on paper has mostly collapsed.

## The common error: deciding by planning, then delivering the plan

You’ve seen it. A business case is written. A roadmap is approved. A steering committee signs off. Then the team builds what was decided. Sprint Reviews are used to check whether the work is going to plan, and monthly or quarterly reports check whether the roadmap was accurate.

Let’s make that distinction clear:

<definition-list>

Document-driven development

: Implementation decisions are made based on documents produced in the realm of conjecture (e.g., fantasy, wishful-thinking, guessing about the users’ needs).

: **Example:** “Customers will want bulk export. The business case says so.”

Outcome-driven development

: Implementation decisions are made based on what users were seen to do.

: **Example:** “We gave 10% of all users a plain bulk export on Tuesday. Only a few used it. The next Tuesday, we gave them a filtered export and 90% used it more than once by the end of the week.”

</definition-list>

### Modern app development

#### This is real, not a metaphor. This is today, not future.

Since the first computer, writing code was expensive. So companies did everything they could before coding: surveys, studies, committee reviews, and months of argument about whether to approve a project. That was rational. The coders were the expensive part, and every software product you didn’t make saved a fortune.

Eric Ries wrote *The Lean Startup* (2011) on the same economics. Building a product was expensive, so he showed people how to learn while paying as little as possible: smoke tests, landing pages, a person quietly doing by hand what the software would do later.

*Then the cost of code dropped to near zero.*

<golden-width>

![Left panel: people gathered with documents, trying to set priorities before a deadline. Right panel: same man, thinking. From his computer, software apps are spawning.](https://davesabine.com/articles/2026/11/steering-committe-versus-producer.jpg)

</golden-width>

The smallest experiment has changed. It doesn’t have to be limited to a landing page or a mock-up anymore. It can be a real app: a live, working user interface, in front of real users, doing real work.

But cheap code doesn’t mean make any app, any time. Two things still limit our work:

- **How good are your metrics.** Measuring the wrong thing leads to hallucination.
- **The users.** Every change you deliver disturbs their experience. Deliver too many changes, too fast, and they’ll tune out.

The limit on your experiments is no longer engineering hours. It’s how much interface change your users can absorb as you learn. (That’s the end-user advocacy skill from [part 3](https://davesabine.com/articles/2026/11/recomposing-the-team).)

## The cycle runs inside the team

The measure of success should never have been “we shipped” (i.e., a feature factory). The success metric to care about is **time-to-learn**: the interval between taking action on an idea and learning from feedback directly from end users. That cycle has to run inside the team, not above it. (In other words, wherever that cycle is measurable and actionable, that’s where the team is composed.)

Many enterprises pigeon holed that feedback loop in a a silo: an innovation lab, a product council, a strategy group. They ran the experiments, picked winners, and handed them down to delivery teams to build. It is time to break those feedback loops out of the silo. Every team unit is a learning circle.

## Engineer the flow, and shrink the decision unit

Draw the path an idea takes to reach a user, and mark every place it waits. Most of the waiting will be for decisions, not for code. (My [Kanban](https://davesabine.com/classes?topic=kanban) courses are a good starting point for making that flow visible and managing it.)

Then tighten the decision unit, so fewer people need to be involved in key decisions. This focuses accountability and radically improves decision time.

Reinertsen’s *The Principles of Product Development Flow* has two lines worth taping to the wall:

> “Decentralize control for problems and opportunities that age poorly.”

> “We don’t need long planning horizons when we have a short turning radius.”

## What to do instead

<alert>

*Important to remember:*

- A plan is a guess. A change in user behavior following an adjustment in your product is an outcome. Code is no longer the constraint. The most important constraints now are:
- The rate of change your users can absorb.
- The rate at which you can learn from changes in their behavior.

</alert>

### Today

If experiments are run by a lab, council, or strategy group outside your team:

- bring those people into your team, or
- you and your teammates take over those experiments.

Then rewrite the topmost items in your Product Backlog as an experiment:

> “We believe <span>
> 
> this change
> 
> </span>
> 
>  will help <span>
> 
> these users
> 
> </span>
> 
>  do <span>
> 
> this thing
> 
> </span>
> 
> . We’ll put it in front of <span>
> 
> how many
> 
> </span>
> 
>  users by <span>
> 
> date
> 
> </span>
> 
> . We’ll know it worked if we see <span>
> 
> this observable behavior
> 
> </span>
> 
> .”

#### Stop measuring the accuracy of your roadmap

Measuring reality against estimates (e.g., plans versus actuals) was always a bad idea. Doing so rewards the wrong thing. Measure time-to-learn (from [part 1](https://davesabine.com/articles/2026/11/the-bottleneck-dissolved/)).

### Tomorrow

Start counting approvals: count the sign-offs between an idea and a real user. Name each person. Consider which of them must truly be involved.

### This Week

Put a live, working version of something in front of a small group of real users. Study what they do, not what they say they’ll do.

## The goal

The outcome to strive for is:

1. Product reviews are frequent (like Sprint Reviews) and include analysis of user behavior. “We believed <span>

this change

</span>

 would help <span>

those users

</span>

 do <span>

that thing

</span>

. We put it in front of <span>

how many

</span>

 users on <span>

date

</span>

. We observed <span>

this change in {metric}

</span>

.”
2. Items in the queue (e.g., Product Backlog) are frequently added, deleted, or change position as a result of (1).

<alert>

*Want to challenge me?*
Maybe your context is unique. (Embedded hardware, safety-critical systems, and some heavily-regulated domains still have expensive code.) If writing code is still your constraint, tell me where and why. I’d like to hear it!

</alert>

<series-toc>



</series-toc>

## Sitemap

See the full [sitemap](https://davesabine.com/sitemap.md) for all pages.
