iteration

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

Iteration

迭代

Iteration is the practice of repeatedly cycling through design, build, test, and refine — using each cycle's output to inform the next. The core insight: design problems rarely yield to single passes of careful planning. They yield to cycles, where each pass uncovers issues invisible to the prior pass. The teams that internalize iteration consistently outperform those that try to plan the perfect solution up front.

迭代是指反复循环执行设计、构建、测试和优化的实践——利用每个循环的输出为下一个循环提供依据。核心见解是：设计问题很少能通过一次周密规划就得到解决，而是需要通过循环迭代，每次迭代都会发现上一次迭代中无法察觉的问题。将迭代理念内化的团队，其表现始终优于那些试图预先规划出完美解决方案的团队。

Definition (in our own words)

定义（我们的解读）

A design that emerges through iteration is built by repeating a small set of operations: design something; build a version of it; test it (with users, with data, with a critical eye); learn what worked and what didn't; refine; design the next version. Each cycle reveals problems that couldn't be predicted from the inside of the previous cycle. The total work to reach a good design through iteration is usually less than the work to reach the same quality through up-front planning, because iteration converges on what users actually need rather than what you predicted they would need.

通过迭代形成的设计，是通过重复一系列小操作构建而成的：设计某样东西；构建一个版本；对其进行测试（与用户测试、通过数据测试、以批判性眼光测试）；总结有效和无效的部分；优化；设计下一个版本。每个循环都会揭示出上一个循环中无法预见的问题。通过迭代达成优质设计的总工作量通常少于通过预先规划达到同等质量的工作量，因为迭代会逐步趋近用户的真实需求，而非你预测的需求。

Origins and research lineage

起源与研究脉络

Lidwell, Holden & Butler (2003) distinguished two types of iteration: design iteration (the planned, expected refinement during the design phase) and development iteration (the unplanned, costly rework during build that indicates inadequate design). The first is good; the second is a failure of the first.
Henry Petroski, The Evolution of Useful Things (Knopf, 1992) and To Engineer Is Human (St. Martin's, 1985). Petroski's central thesis: useful objects evolve through accumulated failure and refinement, not through a single brilliant design moment. Successful designs encode many cycles of iteration.
Eric Ries, The Lean Startup (Crown Business, 2011). Translated iteration into product-management vocabulary: minimum viable product, build-measure-learn loop, validated learning. Influential across software product design.
Tom Kelley & David Kelley at IDEO, Creative Confidence (Crown Business, 2013) and earlier IDEO publications. Codified design thinking as an iterative discovery process: empathize → define → ideate → prototype → test → repeat.
Boyd's OODA loop (military strategy, applied to design) — observe, orient, decide, act, then repeat. The faster the loop, the better the outcomes.
Modern agile / continuous-delivery practice — Scrum, Kanban, XP, DevOps all encode iteration as a structural commitment. Releases shrink; feedback cycles tighten.

Lidwell、Holden & Butler（2003）区分了两种迭代类型：设计迭代（设计阶段中计划内的、预期的优化）和开发迭代（构建阶段中计划外的、高成本的返工，表明设计不足）。前者是有益的；后者是前者失败的结果。
Henry Petroski，《有用之物的进化》（Knopf, 1992）和《工程师是人》（St. Martin's, 1985）。Petroski的核心论点是：有用的物品是通过累积的失败和优化演变而来，而非源于某个单一的天才设计时刻。成功的设计蕴含了许多轮迭代循环。
Eric Ries，《精益创业》（Crown Business, 2011）。将迭代转化为产品管理术语：最小可行产品（MVP）、构建-衡量-学习循环、验证性学习。在软件产品设计领域影响深远。
IDEO的Tom Kelley & David Kelley，《创意自信》（Crown Business, 2013）及早期IDEO出版物。将设计思维整理为一个迭代式探索流程：共情→定义→构思→原型→测试→重复。
Boyd的OODA循环（军事策略，应用于设计）——观察、定位、决策、行动，然后重复。循环速度越快，结果越好。
现代敏捷/持续交付实践——Scrum、Kanban、XP、DevOps都将迭代作为结构性承诺。发布周期缩短；反馈循环收紧。

Why iteration matters

迭代的重要性

A first design is built on assumptions. Some assumptions are right; some are wrong. The wrong ones can only be discovered by exposing the design to reality — to users, to use cases, to edge cases the designer didn't anticipate. The longer the design avoids contact with reality, the more wrong assumptions accumulate; the bigger and more painful the eventual correction.

Iteration shortens the gap between assumption and verification. Each cycle exposes a few wrong assumptions; the next cycle corrects them. After several cycles, the design is largely correct because the assumptions have been replaced by observations. Without iteration, the design is shipped on assumptions still mostly untested.

The cost of iteration vs. up-front planning:

Up-front planning is cheap to start (no implementation cost) but expensive to revise (entrenched specifications, sunk cost, political resistance).
Iteration is expensive to start (each cycle requires building) but cheap to revise (each cycle is small).

For complex products with significant unknowns, iteration usually wins.

初始设计基于假设。有些假设是正确的；有些则是错误的。错误的假设只能通过将设计暴露于现实——用户、使用场景、设计师未预料到的边缘情况——才能被发现。设计脱离现实的时间越长，错误假设积累得越多；最终的修正代价就越大、越痛苦。

迭代缩短了假设与验证之间的差距。每个循环都会暴露一些错误假设；下一个循环则会修正这些假设。经过几个循环后，设计基本正确，因为假设已被观察结果取代。如果没有迭代，设计将基于大多未经测试的假设发布。

迭代与预先规划的成本对比：

预先规划启动成本低（无需实现成本），但修改成本高（规格固化、沉没成本、政治阻力）。
迭代启动成本高（每个循环都需要构建），但修改成本低（每个循环规模小）。

对于存在大量未知因素的复杂产品，迭代通常更具优势。

Design iteration vs. development iteration

设计迭代 vs 开发迭代

The book's distinction matters in practice:

书中的这一区分在实践中至关重要：

Design iteration

设计迭代

Planned cycles during the design phase — sketching, prototyping, testing, refining. Each cycle is intentional and produces learnings.

Healthy design iteration:

Cycles measured in days to weeks.
Low-fidelity prototypes early, higher-fidelity later.
User feedback at each cycle.
Explicit criteria for "done with this cycle."

设计阶段的计划内循环——草图绘制、原型制作、测试、优化。每个循环都是有意图的，能产生新认知。

健康的设计迭代：

周期以天到周为单位。
早期使用低保真原型，后期使用高保真原型。
每个循环都收集用户反馈。
明确“完成此循环”的标准。

Development iteration

开发迭代

Unplanned rework during the build phase, usually because the design wasn't iterated enough during design. The team builds something, discovers it doesn't work, partially rebuilds, discovers the rebuild has its own problems, etc.

Development iteration is costly because building is more expensive than designing. Reduce it by iterating more thoroughly during design.

The principle: spend cheap iteration cycles (design, prototype) to avoid expensive iteration cycles (build, rebuild).

构建阶段的计划外返工，通常是因为设计阶段的迭代不够充分。团队构建某样东西，发现它无法工作，部分重构，又发现重构后的版本存在新问题，以此类推。

开发迭代成本高昂，因为构建比设计更昂贵。通过在设计阶段更充分地迭代来减少开发迭代。

原则：投入低成本的迭代循环（设计、原型制作），以避免高成本的迭代循环（构建、重构）。

When to apply

适用场景

Whenever the design has significant unknowns. New product categories, new user segments, new technologies — anything where you can't predict the right answer.
In MVP design. The MVP is a vehicle for iteration; it ships not because it's "done" but because shipping enables the next iteration.
In any project where the cost of wrong assumptions is high. Iteration tests assumptions cheaply.
When stakeholders disagree. Iteration replaces argument with evidence.

当设计存在大量未知因素时。新产品类别、新用户群体、新技术——任何你无法预测正确答案的场景。
MVP设计中。MVP是迭代的载体；它发布不是因为“完成了”，而是因为发布能推动下一轮迭代。
任何错误假设成本高的项目中。迭代能以低成本测试假设。
当利益相关者存在分歧时。迭代用证据取代争论。

When NOT to over-apply

不宜过度应用的场景

In safety-critical systems. The cost of "iterating" on aircraft control software is human lives. Use iteration during design and prototype; lock down before deployment.
For decisions with high switching cost. Some decisions (database schema, API design that external partners depend on) are expensive to revise. Iterate intensely during design; commit deliberately.
When the ground truth is well-known. A standard CRUD form for a familiar use case may not need many cycles. Iteration is investment in discovery; if you already know the answer, skip the discovery.

安全关键系统。对飞机控制软件进行“迭代”的代价是人的生命。在设计和原型阶段使用迭代；部署前锁定设计。
切换成本高的决策。有些决策（数据库架构、外部合作伙伴依赖的API设计）修改成本高昂。在设计阶段进行密集迭代；谨慎做出承诺。
当事实真相已明确时。针对熟悉场景的标准CRUD表单可能不需要太多循环。迭代是对探索的投入；如果你已经知道答案，可以跳过探索。

The iteration cycle

迭代循环

A workable cycle:

一个可行的循环流程：

1. Define the question

1. 定义问题

What are you trying to learn or decide in this cycle? "How do users discover the new feature?" or "Which onboarding flow has higher completion?" Specific questions yield specific answers.

在这个循环中，你试图了解或决定什么？比如“用户如何发现新功能？”或“哪个引导流程的完成率更高？”具体的问题会带来具体的答案。

2. Build the cheapest thing that answers the question

2. 构建能回答问题的最低成本方案

The MVP for this cycle. A sketch, a clickable prototype, a coded version, an A/B test — whichever is cheapest and still answers the question.

此循环的MVP。草图、可点击原型、编码版本、A/B测试——选择成本最低且仍能回答问题的方案。

3. Expose it to reality

3. 暴露于现实

Users (research session, beta cohort), data (analytics on a partial release), or a critical reviewer (design critique, code review). The design must encounter something outside the design team.

用户（研究会话、测试 cohort）、数据（部分发布的分析）或关键评审者（设计评审、代码评审）。设计必须接触设计团队之外的事物。

4. Observe and learn

4. 观察与学习

What happened? What surprised you? What confirmed assumptions; what disconfirmed?

发生了什么？什么让你惊讶？哪些假设得到了证实；哪些被推翻？

5. Decide the next cycle

5. 确定下一个循环

Based on learnings, what's the next question? Refine, replace, or keep.

The full cycle should take days to weeks for most software design — fast enough that learnings stay fresh; slow enough that real building can happen.

基于所学内容，下一个问题是什么？优化、替换或保留现有方案。

对于大多数软件设计，完整循环应耗时几天到几周——速度足够快，让新认知保持新鲜；同时足够慢，确保能完成实际构建。

Worked examples

实践案例

Example 1: a new feature on an existing product

案例1：现有产品新增功能

A team wants to add a new analytics dashboard. Iteration cycle:

Cycle 1: paper sketches, internal review. Cheap; surfaces obvious structural questions.
Cycle 2: clickable Figma prototype, 5 user interviews. Reveals which widgets users find valuable; which they ignore.
Cycle 3: coded version, beta with 10% of users. Reveals real-world performance issues; surfaces edge cases.
Cycle 4: refined version, full release with feature flag and monitoring. The dashboard is now mostly correct.

Each cycle costs more than the last; each replaces more assumptions with evidence.

团队希望添加一个新的分析仪表盘。迭代循环：

循环1：纸质草图，内部评审。成本低；能发现明显的结构问题。
循环2：可点击Figma原型，5次用户访谈。揭示用户认为有价值的组件和被忽略的组件。
循环3：编码版本，向10%的用户开放测试版。发现实际性能问题；暴露边缘情况。
循环4：优化版本，通过功能标志全面发布并监控。此时仪表盘已基本完善。

每个循环的成本都高于上一个；每个循环都用证据替换更多假设。

Example 2: a complete product redesign

案例2：产品全面重设计

A team redesigns a product. Without iteration: 18 months of design and rebuild; ship; users hate it; emergency rollback or "v2" project.

With iteration:

Phase 1 (3 months): redesign one critical flow. Ship behind a feature flag; A/B test. Refine based on data.
Phase 2 (3 months): redesign the next critical flow. Repeat.
Phase 3 (3 months): adopt the new design system across surfaces that haven't been redesigned. Cosmetic-only.

Total: 9 months, with each phase de-risked by data. Far better outcome than the 18-month bang.

团队重设计一款产品。如果不迭代：18个月的设计与重构；发布后用户反感；紧急回滚或启动“v2”项目。

如果采用迭代：

阶段1（3个月）：重设计一个关键流程。通过功能标志发布；进行A/B测试。基于数据优化。
阶段2（3个月）：重设计下一个关键流程。重复上述步骤。
阶段3（3个月）：在未重设计的界面中采用新设计系统。仅做外观调整。

总耗时：9个月，每个阶段都通过数据降低风险。结果远优于18个月的一次性发布。

Example 3: API design

案例3：API设计

An API exposed to external developers can't be casually iterated — each version becomes a contract. But internal iteration before exposure can be intense:

Cycle 1: design the API on paper; review with 3 internal teams.
Cycle 2: implement a prototype; integrate from 1 internal client.
Cycle 3: expose to 3 internal clients; gather feedback.
Cycle 4: refine; release as
```
v1
```
to external partners.

The pre-release cycles are cheap; the post-release iteration is expensive.

面向外部开发者的API不能随意迭代——每个版本都是一份契约。但在对外发布前的内部迭代可以非常密集：

循环1：在纸上设计API；与3个内部团队评审。
循环2：实现原型；与1个内部客户端集成。
循环3：向3个内部客户端开放；收集反馈。
循环4：优化；作为
```
v1
```
版本向外部合作伙伴发布。

发布前的循环成本低；发布后的迭代成本高。

Example 4: an onboarding flow

案例4：引导流程

The team wants to improve sign-up completion. Iteration:

Cycle 1: instrument current flow; identify drop-off step. (Discovery.)
Cycle 2: hypothesize fix; build A/B test variant. Run for 2 weeks.
Cycle 3: analyze; ship winner; identify next drop-off step.
Cycle 4: repeat.

Each cycle is data-driven and cheap. The cumulative improvement after 6–12 cycles often exceeds what any single redesign could achieve.

团队希望提高注册完成率。迭代：

循环1：为当前流程添加埋点；确定流失步骤。（探索阶段）
循环2：提出修复假设；构建A/B测试变体。运行2周。
循环3：分析结果；发布获胜变体；确定下一个流失步骤。
循环4：重复上述步骤。

每个循环都以数据为驱动，成本低。经过6-12个循环后的累积改进，往往超过任何单一重设计能实现的效果。

Cross-domain examples

跨领域案例

Industrial product design

工业产品设计

The development of any complex industrial product (a new car, an appliance, a medical device) involves dozens of prototype iterations — clay models, foam mockups, 3D-printed parts, working prototypes, pilot production. Each iteration reveals issues invisible at the previous fidelity.

任何复杂工业产品（新车、家电、医疗设备）的开发都涉及数十轮原型迭代——油泥模型、泡沫模型、3D打印部件、工作原型、试生产。每一轮迭代都会发现上一个保真度下无法察觉的问题。

Architecture

建筑设计

Frank Lloyd Wright's process: many sketches, sometimes hundreds, before settling on a design. The Guggenheim went through years of iterative revision before construction.

Frank Lloyd Wright的流程：在确定最终设计前绘制大量草图，有时甚至数百张。古根海姆博物馆在动工前经历了多年的迭代修改。

Software open-source

开源软件

Open-source projects iterate continuously through patches, pull requests, and releases. Linux, the modern web stack, and every major open-source product evolved through tens of thousands of iteration cycles.

开源项目通过补丁、拉取请求和发布持续迭代。Linux、现代Web栈以及所有主要开源产品，都通过数万次迭代循环演变而来。

Manufacturing (Toyota Production System)

制造业（丰田生产系统）

Toyota's "kaizen" — continuous small improvements — is iteration applied to manufacturing process. Each shift makes small changes; over decades, the cumulative improvement is enormous.

丰田的“kaizen”（持续改进）是应用于制造流程的迭代。每个班次都做出小改进；数十年后，累积的改进效果巨大。

Scientific method

科学方法

Science is iteration: hypothesize, experiment, observe, refine. The same loop applied to design produces similar accumulating quality.

科学本身就是迭代：提出假设、实验、观察、优化。将同样的循环应用于设计，也能产生类似的累积质量提升。

Anti-patterns

反模式

The big-bang ship. A design developed in isolation for months, shipped without iteration, fails on contact with reality.
No iteration criteria. Cycles without explicit "what are we trying to learn?" go on indefinitely without converging.
Cycles too long. Quarterly cycles in a product that should be iterating weekly or daily. Learnings stale; the team forgets the previous cycle's context.
Cycles too short. Daily redesigns that don't give the previous version time to be evaluated. Whiplash, no learning.
Iteration without measurement. Cycles that produce changes but no evidence of whether the changes helped. Pure motion, no progress.
Skipping the "expose to reality" step. Design cycles that stay inside the design team. Useful for some questions; useless for "does this work for users?"
Confusing prototypes with products. A prototype is an iteration vehicle; a product is what survives multiple iterations. Treating prototypes as products produces brittle, unfinished work.

一次性大规模发布。设计在孤立环境中开发数月，未经过迭代就发布，接触现实后失败。
无迭代标准。循环没有明确的“我们试图了解什么？”目标，无限期进行却无法收敛。
循环周期过长。在本应每周或每日迭代的产品中采用季度循环。新认知过时；团队忘记上一个循环的背景。
循环周期过短。每日重设计，不给上一个版本留出评估时间。团队疲于奔命，无法学习。
无衡量的迭代。循环产生了变化，但没有证据表明这些变化是否有效。只有动作，没有进展。
跳过“暴露于现实”步骤。设计循环仅在设计团队内部进行。对某些问题有用；但对“这对用户有用吗？”这类问题毫无用处。
混淆原型与产品。原型是迭代的载体；产品是经过多轮迭代后留存下来的成果。将原型当作产品会产生脆弱、未完成的作品。

Heuristics

启发式方法

The "what would surprise us?" check. Before each cycle, predict what will happen. After, compare. Surprises are the value of iteration.
The cycle-time metric. How long from "we have an idea" to "we have evidence about the idea"? Shorter is usually better.
The fidelity ladder. Are you using the cheapest fidelity that answers the question? Don't build a coded prototype when a sketch would do.
The "stop iterating" criteria. Define explicitly when iteration ends and shipping begins. Otherwise iteration can become procrastination.

“什么会让我们惊讶？”检查。每个循环前，预测会发生什么。循环后，对比预测与实际结果。惊喜是迭代的价值所在。
周期时间指标。从“我们有一个想法”到“我们有关于这个想法的证据”需要多长时间？通常越短越好。
保真度阶梯。你是否使用了能回答问题的最低成本保真度？如果草图就能解决问题，就不要构建编码原型。
“停止迭代”标准。明确定义迭代结束、开始发布的时机。否则迭代可能变成拖延。

Related principles

Sub-aspect skills

子技能

iteration-design-vs-development
— distinguishing healthy design iteration from costly development rework.
iteration-prototype-fidelity
— picking the right fidelity for each cycle's question.

iteration-design-vs-development
—— 区分健康的设计迭代与高成本的开发返工。
iteration-prototype-fidelity
—— 为每个循环的问题选择合适的保真度。

Closing

结语

Iteration is the principle that separates teams who ship good products from teams who ship the products they planned. The teams that internalize "we will be wrong about something; let's find out which something cheaply" consistently outperform teams that try to be right the first time. Build the next cycle into every project plan.

迭代是区分“交付优质产品的团队”与“交付预先规划产品的团队”的核心原则。那些内化“我们肯定会在某些事情上出错；让我们以低成本找出这些事情”理念的团队，其表现始终优于试图一次就做对的团队。将下一轮迭代纳入每个项目计划中。