Iteration

The Design Squiggle is a simple illustration of the design process. The journey of researching, uncovering insights, generating creative concepts, iteration of prototypes and eventually concluding in one single designed solution. It is intended to convey the feeling of the journey. Beginning on the left with mess and uncertainty and ending on the right in a single point of focus: the design.

When designing responsive websites by starting with a small screen and introducing a breakpoint when the page layout requires it, you will resize your browser window all the time to see how the page layout works at different sizes.

This design process is impossible to follow by creating static mockups of page layouts in a design tool and then implementing those mockups for the browser.

...When the entire process is relying on the two subsequent steps of designing a polished static mockup with a design tool and then implementing it, you have introduced a nice waterfall process in your workflow and waterfall processes make learning slow and expensive, while you want quick learning in any software project!

I prefer coding and adjusting continuously within a browser, the medium of delivery.

...There are two ways to design with code:

It can be done by a single person able work with both forms of expression, design and code. Jim Nielsen calls this person a design engineer and Jim has an excellent example of the problems being solved by design with code in his text The Case For Design Engineers, Pt. II.

The alternative is two closely collaborating people, a designer and a coder, continuously working together to identify the relevant details, taking decisions and implementing so that it doesn´t feel like designed first and implemented second.

If I look at things that have turned out well in my life (my marriage, some of my essays, my current career) the “design process” has been the same in each case. It has been what Christopher Alexander called an unfolding. Put simply:

1. I paid attention to things I liked to do, and found ways to do more of that. I made it easy for interesting people to find me, and then I hung out with them. We did projects together.
2. I kept iterating—paying attention to the context, removing things that frustrated me, and expanding things that made me feel alive.
3. Eventually, I looked up and noticed that my life was nothing like I imagined it would be. But it fit me.

...If you cycle through this feedback loop ferociously for ten years, you will end up with a well-designed life. It will not look like you imagined it would. It will have unfolded around you, and you will struggle to wrap your head around how you ended up where you did.

You will have lost track of all the experiments and insights that led you to a fit. But the good news is that you don’t have to remember. The form does.

Some visitors may be familiar with the previous version of this site. For those who want the old experience, it's still available at this link.

We ship small changes daily, and something major almost every week. Every year, it's almost like a new product. This incremental way of building the product is hugely beneficial, and often necessary — though it unbalances the overall design, and leads to design debt. Each new capability adds stress on the product's existing surfaces for which it was initially designed. Functionality no longer fits in a coherent way. It needs to be rebalanced and rethought.

...While the design debt often happens in small increments, it’s best to be paid in larger sweeps. This goes against the common wisdom in engineering where complete code rewrites are avoided. The difference is that on the engineering side, a modular or incremental way of working can work as the technical implementation is not really visible. Whereas the product experience is holistic and visual. You cannot predict which path the user takes. If you update just one module or view at a time, the overall experience becomes more disjointed. Secondly, if your goal is to reset and rebalance the whole product UI and experience, you have to consider all the needs simultaneously. An incremental approach doesn’t let you do that.

Ahh… Project handoff. That universally hated period of inefficiency and frustration, throwing your work over the fence hoping there is someone on the other side to catch it.

Imagine a project where teams work together at each stage, progressively improving the end result based on qualitative and quantitative data. Project handoff is inefficient, risky… and unnecessary; a result of our stubborn insistence on siloed working patterns. As Adam Brock says, “the distance between design and production should be zero.” Today, we need closer collaboration than ever before. No Handoff is the next logical step in how we build and deliver value.

Today's Minimum Viable Product (MVP) is about iterating early to build the highest quality competitor to an existing idea, not validating a novel one. This journey involves refining early ideas to compete in an existing market, narrowing the target audience, strategically using a waitlist for feedback, and recognizing indicators of early product-market fit.

...Building something valuable is no longer about validating a novel idea as fast as possible. Instead, the modern MVP exercise is about building a version of an idea that is different from and better than what exists today. Most of us aren’t building for a net-new market. Rather, we’re finding opportunities to improve existing categories. We need an MVP concept that helps founders and product leaders iterate on their early ideas to compete in an existing market.

You might think that Mario 64 was built with tickets and sprints, but, according to interviews, there was no master plan, only the principles that the game should feel good and be fun. They started with just Mario in a small room, and tuned his animations and physics until he felt nice and responsive. After that, the levels were also created as they went, with the designers, developers, and director going back and forth using sketches and prototypes.

Building like this is never a straight line. Ideas and code get left on the cutting room floor because part of innovation is questioning whether what you made should exist. The process is cyclical and iterative, looking something like this.

It is toward the end of the second draft, if I’m lucky, when the feeling comes over me that I have something I want to show to other people, something that seems to be working and is not going to go away. The feeling is more than welcome, yes, but it is hardly euphoria. It’s just a new lease on life, a sense that I’m going to survive until the middle of next month. After reading the second draft aloud, and going through the piece for the third time (removing the tin horns and radio static that I heard while reading), I enclose things in boxes for Draft No. 4. If I enjoy anything in this process it is Draft No. 4. I go searching for replacements for the words in the boxes. The final adjustments may be small-scale, but they are large to me, and I love addressing them.

I’ll try to convince you of two things:

1. Creating quality is context specific. There are different techniques for solving essential domain complexity, scaling complexity, and accidental complexity.
2. Quality is created both within the development loop and across iterations of the development loop. Feedback within the loop, as opposed to across iterations, creates quality more quickly. Feedback across iterations tends to measure quality, which informs future quality, but does not necessarily create it.

The way I revise is: I read my own text and imagine a little meter in my head, with “P” on one side (“Positive”) and “N” on the other (“Negative”)... This involves making thousands of what I’ve come to think of as “micro-decisions.” These are instantaneous, intuitive – I just prefer this to that… I just have a feeling and react to that feeling, in the form of a cut phrase, or an added word, or an urge to move this whole section, and so on. And then I do that over and over, for months, sometimes years, until that needle stays up in the “P” zone for the whole length of the text…With each choice, even the smallest ones, the story becomes more and more…well, it becomes more her, you could say. There’s more of her essential nature in it, more of what will distinguish her from all of those other writers out there. And gradually, the story starts to become something she couldn’t have foreseen when she started out – bigger, more complex, smarter, funnier, whatever.

Initial designs for sophisticated software applications are invariably complicated, even when developed by competent engineers. Truly good solutions emerge after iterative improvements or after redesigns that exploit new insights, and the most rewarding iterations are those that result in program simplifications.

Evolutions of this kind, however, are extremely rare in current software practice—they require time-consuming thought processes that are rarely rewarded. Instead, software inadequacies are typically corrected by quickly conceived additions that invariably result in the well-known bulk.

Success depends wholly on the anticipation and obviation of failure, and it is virtually impossible to anticipate all the uses and abuses to which a product will be subjected until it is in fact used and abused not in the laboratory but in real life. Hence, new products are seldom even near perfect, but we buy them and adapt to their form because they do fulfill, however imperfectly, a function that we find useful.

I don't exactly outline, but I do write in some sort of iterative top-down way. I'd already noticed that I tend to write in three rough passes for most of my writing, both technical writing and blog posts. This isn't some method I stick rigidly to, it just seems to work out that way for me.

Pass 1: landmarks
I paste in all the things I already know I want to cover, in roughly the right order.

Pass 2: everything else except the annoying bits
Then I draw the rest of the owl, except the absolute worst parts of the owl, which I mark with a couple of blank lines with "!!" between them. These are all the annoying bits that I come back to in pass 3. Anything that significantly interrupts my flow gets a "!!" and I move on.

Pass 3: the annoying bits
Pass 3 is a small-scale version of Finishing The Project mode, where I backwards-chain from the goal of getting the damn thing finished. [Connective tissue, facts and precise statements, images]

Fascinatingly, one of the other big complaints people had about agile is no iteration. I don't understand how being in an agile environment makes people less iterative, but somehow that seems to be the case. And I think it's because people misunderstand and think that agile is just about putting features out faster, and not about the important part, which is getting something in front of users faster so that you can get feedback on it and make it better.

This immersion over years, or decades, what George Saunders calls “rigorous, iterative engagement,” can be fruitful, but it can also make a book’s endpoint more difficult to see. Huddleston’s 50-year project, which is nearing completion, has in the end surprised him. “I’ve returned to the project many times after feeling it was done,” he says, and in doing so, encountered an unexpected complication: wishing the work could go on. Similarly, Vauhini Vara, author of The Immortal King Rao (2022), says of the 13 years it took to write her debut novel, “On some level I wanted to keep spending time with it, finding its unexplored corners, tunneling into its wormholes. I didn’t want to let it go.”

So—know when to let go, keep faith in the process, be flexible, fail better, and whenever possible, stay astonished. Though perhaps most importantly, recognize the value that comes with the passing of time itself.

• The act of writing the first draft creates new “essential data” that feeds the imagination and makes possible figuring out the second draft.
• Or: In your head, ideas expand until they max out “working memory” – and it’s only be externalising them in the written word that you have capacity to iterate them.
• Or: Good writing necessarily takes multiple edits, and the act of writing and act of rewriting are sufficiently different that performing both simultaneously is like rubbing your tummy and patting your head.

The tech am I digging recently is a software framework called LangChain which does something pretty straightforward: it makes it easy to call OpenAI’s GPT, say, a dozen times in a loop to answer a single question, and mix in queries to Wikipedia and other databases.

This is a big deal because of a technique called ReAct...[which] looks innocuous but here’s the deal: instead of asking GPT to simply do smart-autocomplete on your text, you prompt it to respond in a thought/act/observation loop.

We like to think about this process as the game discovering itself over time. Because as iterators, rather than designers, it’s our job to simply play the game, listen to it, feel it, and kind of feel out what it seems to want to become - and just follow the trails of what’s fun.

We Don’t Really Know the Goal When We Start

The most serious model shortcoming is that the designer often has a vague, incompletely specified goal, or primary objective. In such cases, the hardest part of design is deciding what to design.

I came to realize that the most useful service I was performing for my client was helping him decide what he really wanted.

Today, we recognize that rapid prototyping is an essential tool for formulating precise requirements. Not only is the design process iterative; the design-goal-setting process is itself iterative. Knowing complete product requirements up front is a quite rare exception, not the norm. Therefore, goal iteration must be considered an inherent part of the design process.

Let me start with an observation: Throughout my career, I’ve interviewed many designers and product managers. I always ask candidates to walk me through the process for one of their projects. In response, nearly every person shares a similar version of this story:

First, they began with research, then the team had a big brainstorm with Post-its (naturally), then a series of hand-drawn sketches, all culminating in a shiny pixel-perfect prototype, which was tested, and then shipped out into the world. Voila!

It’s such a satisfying tale from conception to completion.

But here’s the thing: I rarely believe it. Products today never get built in such a clear, linear, and picture-perfect way. The reality is so much messier. So why do we act like it isn’t?

Much of the design process is a conversation, a back-and-forth as we walk around the tables and play with the models. He doesn't like to read complex drawings. He wants to see and feel a model. He's right. I get surprised when we make a model and then realize it's rubbish, even though based on the CAD renderings it looked great.

He loves coming in here because it's calm and gentle. It's a paradise if you're a visual person. There are no formal design reviews, so there are no huge decision points. Instead we can make the presentations fluid. Since we iterate every day and never have dumb-ass presentations, we don't run into major disagreements.

Out of all the cameras that Fujifilm has produced during the past 12 years, the X100 series and the X-Pro series are the cameras that have always been my tools of the trade. I’ve seen the two lines grow more complete with every new iteration, to the point where I thought that Fujifilm couldn’t improve upon the X100V. It has been that perfect to me. But then again, so was the S, the T and the F.

...Yet again I need to express my awe of Fujifilm. How did they once again mange to improve upon a camera that I already thought was pure perfection? I really have no good answer to that. Anyway that’s what they did, and that’s where we’re at. An already wonderful do-it-all camera just got made even better.

The X100VI is absolutely fantastic.

Design is non-linear. At Figma, we often talk about “embracing the mess,” and that really means leaning into the chaos and complexity that makes the design process what it is. Even once you have the seedling of an idea, you need to explore and iterate, then pull back and evaluate to see what’s working and what’s not. Sometimes you’ll scrap an idea after a brainstorm session, and other times you’ll get pretty far with a concept, but still need different perspectives and input to move forward.

Why care so much about a stupid personal website? Well, aside from the fact that this is the only entry website for how I make all my income - MORE IMPORTANTLY I think it’s the cure to loneliness.

As you get older it’s harder and harder to meet new people, expand your circles and show up in new spaces. But my website is a little antidote. Just last week I had 6 coffee meetings and zooms with people I’d never met before. What a time to be alive!

As I’ve said before, the unit of blogging is the conversation.

Getting feedback can be thought of as a form of design research. In the same way that we wouldn’t do any research without the right questions to get the insights that we need, the best way to ask for feedback is also to craft sharp questions.

It is widely accepted that creative design is not a matter of first fixing the problem and then searching for a satisfactory solution concept; instead it seems more to be a matter of developing and refining together both the formulation of the problem and ideas for its solution, with constant iteration of analysis, synthesis, and evaluation processes between the two “spaces” – problem and solution.

Every month or so, Manock and Oyama would present a new iteration based on Jobs's previous criticisms. The latest plaster model would be dramatically unveiled, and all the previous attempts would be lined up next to it. That not only helped them gauge the design's evolution, but it prevented Jobs from insisting that one of his suggestions had been ignored.