Iterations vs Increments (Mona Lisa and Mrs Fox)

One of the best ways to tilt the playing field of Product Development is to take an iterative or incremental approach. What does this mean though? It is easy to get confused about the difference between the two. Scrum, (one of the most popular software development frameworks) is an iterative method that teaches teams to deliver “potentially shippable increments” each iteration. Confused? That’s ok. You’re not alone. Lots of people are confused by this.

When we were doing research and writing “Delivering in Increments” (which became one of the Fundamentals of Value, Flow, Quality), Dan Rough and I spent some time discussing how to explain the difference between increments and iterations[1]. One of the most popular references explaining iterations comes from Jeff Patton, who does a great job encouraging teams to take iterations seriously using the Mona Lisa as an example in this blog post.

He starts with incrementing, in which a fully formed vision of the product is delivered in parts, quadrant by quadrant. There is no iterating previous parts and the process is purely additive[2], like this…

Incremental Mona Lisa
Incremental Delivery – by Jeff Patton

He then goes on to explain that iterating is different. This time it starts with only a few words to describe the idea: “woman in a pastoral setting”. Then a very rough first iteration of the whole product is produced, with later iterations filling in more of the detail and improving the overall quality, like this:

Iterative Mona Lisa
Iterative Delivery – by Jeff Patton

It’s a lovely explanation of iterations and he nicely summarises the approach with the following quip:

“It’s not iterating if you only do it once”.

I’ve found this to be a useful way to encourage people to deliver a rough version early and then deliver frequent improvements. Having said that, the Mona Lisa example doesn’t really do justice to the incremental approach and may even have built a straw-man argument in order to support the iterative approach.

The first issue with it is that it suggests that an incremental approach requires what is sometimes referred to (pejoratively) as “Big Design Up Front”. It implies that incremental delivery needs a fully formed idea in mind before you can get started with delivering.

The second issue is that the incremental version of the Mona Lisa[3] produces rather useless parts of the whole that don’t have any value. If we were to ship at the end of each increment, few people would be prepared to pay for a fully finished top-left corner of a painting. Thankfully, with software, we have more degrees of freedom, meaning that we can actually deliver an amazing amount of value by adding a single feature. I’ve seen a project where 90% of the value in a projected multi-month project was delivered in the first week. Perhaps if each of the instalments added value, increasing the attractiveness of the product to the market, it would be a fair comparison.

To better explain the difference, without the straw man, Dan and I started to play around with some different metaphors that could do a better job of explaining the difference. Our desired outcome was to show the power of delivering early and often – whether that was through iterations or increments. Depending on the context, and the product, delivering increments can be more valuable than an iteration of the whole. In other contexts iterations deliver more value. Sometimes either is  just as good. Having gone through a number of potential metaphors, diverging and converging through critique we eventually settled on something that seemed to work for both increments AND iterations: Language. The way we play with words and sentences to convey meaning is similar to how we develop products.

To demonstrate, let’s take a simple sentence that communicates some information. It’s not Hemmingway, but it could be part of a much bigger story (eventually) or with enough work it might even become the whole thing:

Over the dog the fox jumps.

We might consider this the minimum amount of information delivered. It doesn’t tell us much, and it’s not pretty – but it gets the job done. Now let’s try to incrementally deliver some value, by injecting into what we already have some additional detail.

Over the lazy dog the fox jumps.

So, there we have an increment. Ta-da! This additional information has created some value by describing an unseen characteristic about the dog.

Now, you might argue that this is an iteration as well, since the old sentence no longer exists. That would be true if I had used pen and paper, but thanks to the wonders of technology, I simply added the necessary letters in the place I wanted them [4]. There was no destruction: no words were harmed in the making of this (new) sentence.

Let’s try an iteration then. We’re not going to change the information, but we want it to be more easily read. Call it refactoring even.

The fox jumps over the lazy dog.

Here we have an iteration: no new words, no additional information, but we’ve made it easier to read and understand. Let’s continue iterating and incrementing and see where this goes. Actually, while we were developing this, another team has been beavering away and has developed the following sentence, which contains some visual information about the fox. You might say it adds a bit of colour to the story:

The fox is brown.

Now we could just append these two pieces of information together – integrating them into the same story. Or, perhaps we could go one step further and create another iteration. Some words will become redundant during this process. Sorry about that.

The brown fox jumps over the lazy dog.

So we’ve taken two sentences, with a total of 11 words and we have produced an iteration of both parts into an 8 word sentence that conveys the same meaning – but in a more efficient and less robotic way. We have a description of the dog, but we don’t really know much about the fox other than its colour. Let’s add some more information to convey to the reader what is the fox like.

The quick brown fox jumps over the lazy dog.

Ok, in this increment we have injected a word that describes how the fox moves – we are starting to conjure up a more complete picture. But it is still a snapshot, a moment in time. There doesn’t seem to be any before or after the jump. Let’s add some more, take some away, reorganise and reword, repeating this iterative and incremental process a number of times…

It was a quiet summer evening. A warm breeze was blowing from the East, and it stirred the long shaggy fur of the dog lying upon the porch. Max, an elderly collie, was sleeping on the worn mat by the open back door of the house. Retired from herding sheep, Max had spent the long hot day in herding geckos from their basking spots on the path into the flowerbeds. Now the only noise likely to wake the tired dog would be the well-known tread of his master returning from the fields. The silent paws of a fox approaching the door made no impression at all. Even her sharp scent was wafted away by the breeze. The vixen, thin from weeks spent with her cubs in the den, had smelt the remains of a joint cooling on the kitchen table. Her sharp ears pricked forward and a wary eye on the sleeping dog, the fox drifted up onto the porch, sidling as silent as a shadow towards the door. Her muscles bunched; she sprang. Even the waft of her first leap barely stirred Max. But as she returned, the joint clenched unevenly between her jaws, her claws scrabbled on the polished floorboards as she readjusted the bone. Max shook his heavy head and raised it, eyes rheumy with age and sleep – but before his legs could lift him, the fox had jumped once more. A soft thump of paws on the porch steps; a whisk of the white tip of her brush and she had passed into the long nettles, back towards her hungry cubs.[5]

Many increments and no doubt iterations later, we now have a more fully formed picture/story. Perhaps in later increments we discover that the fox is an orphan, that it is taken in by the family, domesticated and raised alongside Max. Perhaps it will spend its days going from town to town rescuing small children from dangerous situations. The point is, we don’t know. We don’t have a fully formed vision of the end product. That doesn’t mean we can’t incrementally add words, take words away and combine these increments with many iterations in between. The point of sometimes building on top of, removing from and of course rearranging is to develop something that both conveys meaning and resonates with the reader.

Both increment and iterations are a powerful way of getting to something of value quickly. Speed is not the only benefit though. Delivering in increments and iterations create options to either stop, go to market, change direction or keep going. It also provides a means to test ideas with the intention of improving the outcomes, in a discovery process, learning what works and what doesn’t. So if we couple an iterative and/or incremental approach with feedback we can adjust what we do next based on what we have discovered along the way. Together, iterations and increments are both powerful ways to tilt the playing field and improve the chances of success.



1. We actually planned to do another book called “Iterations”, but this idea was iterated on :) In the end we decided to combine the two concepts of iterations and increments into a new book called “Delivering Early and Often”. (In fact, this book still has the stepwise icon on the cover that Dan Barton designed to convey incremental delivery). Basically, iterations and increments are better together. AND not OR. ^back

2. So much of product development is reductive or simplified rather than additive. Picasso’s Bull is a better example of the sort of iterations that we see in successful products than Da Vinci’s Mona Lisa. Watch how Picasso first builds up and then abstracts away into the essence of the shape and form of the bull. ^back



3. The Mona Lisa, which is hidden behind glass in a very crowded room in The Louvre, Paris is actually one of two paintings. The second, far less famous version can be found in an uncrowded room in the Museo del Prada with nothing separating you from the oil on canvas. There are various theories about this second Mona Lisa. Perhaps the most interesting of these is that the Mona Lisa was one of the first attempts at stereoscopic 3D art. It is also likely that this was simply one of Da Vinci’s understudies, who was painting alongside him. That would also explain the slight difference in perspective. I’ll leave this as a question to ponder: what would be the smallest valuable increment of a 3D stereoscopic image? ^back

Stereoscopic Mona Lisa


4. I am distinguishing here between iterating the process and iterating the product. It’s obvious that the process of starting to write something and finishing writing something is being repeated, so I don’t think this is controversial. The question is whether we are iterating the product, not whether the process is iterative in nature. It’s a minor point, but you should of course be repeating your process and iterating to improve your process. Discovering how you work best is also part of the discovery. This is why Retrospectives are considered an important part of pretty much all lean/agile approaches. ^back

5. My thanks to the lovely Helen for her help to improve the quality of this short story.^back