Deciding by delivering

Build → measure → learn. There’s no stopping it now.
Published: 2026-Nov-15

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

“The crucial variables are discovered by accident.” — John Gall The Systems Bible, pg 98

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), 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:

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.”

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.

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.)

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 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

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.

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 this change will help these users do this thing. We’ll put it in front of how many users by date. We’ll know it worked if we see this observable behavior.”

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).

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 this change would help those users do that thing. We put it in front of how many users on date. We observed this change in {metric}.”
  2. Items in the queue (e.g., Product Backlog) are frequently added, deleted, or change position as a result of (1).

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!

Team composition in the age of agentic SDLC
Read the series