Measuring Inner-Loop Agility

When I teach teams and managers about the feedback loops of software development, I try to stress the two most important loops – the ones that define agility.

Releases are where the value gets delivered, and – more importantly – where the end user feedback starts, so we can learn what works and what doesn’t and adapt for the next release.

The sooner we can release, the sooner we can start learning and adapting. So agile teams release frequently.

But frequency of releases doesn’t really define agility. I see teams who release every day or every week, but feature requests still take months to get into production.

That feature-to-production lead time is our best measure of how responsive to change we’re really being. How soon can we adapt to customer feedback?

For a portfolio of software products, a client of mine plotted average feature-to-production lead times against the average time it took to build and test the product.

We see a correlation between that feature-to-production lead time and the innermost loop of software delivery – build & test time.

Of course, this is a small data set, and all the usual caveats about “lies, damned lies and statistics” apply (I would love to do a bigger study, if anyone’s interested in participating).

But I’ve seen this distribution multiple times, and experienced it – and observed many, many teams experiencing it – in the field.

Products with slow build & test cycles tend to have much older backlogs. Indeed, backlogs themselves are a sign of slow lead times. I explained the causal mechanism for this in a previous post about Inner-Loop Agility. When we want to optimise nested loops, we get the biggest improvements in overall cycle time by focusing on the innermost loop.

Now, here’s the thing: everything that goes on between releases is really just guesswork. The magic happens when real end users get real working software, and we get to see how good our guesses were, and make more educated guesses in the next release cycle. We learn our way to value.

That’s why Inner-Loop Agility is so important, and why I’ve chosen to focus entirely on it as a trainer, coach and consultant. I can’t guarantee that you’re building the right thing (you almost certainly aren’t, no matter how well you plan), but I can offer you more throws of the dice.

Author: codemanship

Founder of Codemanship Ltd and code craft coach and trainer

Leave a Reply

Fill in your details below or click an icon to log in: Logo

You are commenting using your account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s