<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Lydia Jiang on Medium]]></title>
        <description><![CDATA[Stories by Lydia Jiang on Medium]]></description>
        <link>https://medium.com/@lydia.b.jiang?source=rss-7fde1acf3d38------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/2*KWUryKIOSjbrVaDT1OeD6g.jpeg</url>
            <title>Stories by Lydia Jiang on Medium</title>
            <link>https://medium.com/@lydia.b.jiang?source=rss-7fde1acf3d38------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 06:18:11 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@lydia.b.jiang/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[System Iteration: The Dangers of Iterative Design, Part II]]></title>
            <link>https://medium.com/@lydia.b.jiang/system-iteration-the-dangers-of-iterative-design-part-ii-f2538d8bad9c?source=rss-7fde1acf3d38------2</link>
            <guid isPermaLink="false">https://medium.com/p/f2538d8bad9c</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[iteration]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Lydia Jiang]]></dc:creator>
            <pubDate>Mon, 02 Apr 2018 13:08:58 GMT</pubDate>
            <atom:updated>2018-04-02T17:00:45.135Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YJzIEmy6ZDc8_55IwAlNmw.jpeg" /></figure><h4>Paying off design debt is a part of an Agile designer’s process. System iteration is a holistic way to pay off this debt.</h4><h4>The Dangers of Iterative Design Series:</h4><p>Part I: <a href="https://medium.com/@lydia.b.jiang/design-debt-and-system-iteration-the-dangers-of-iterative-design-45dd5a3724ff">Design Debt</a></p><p>Part II: System Iteration (this article)</p><h4>System iteration avoids the simplest solution.</h4><p>The result of one iteration is the starting point of the next. Often, our next iteration is building on top of the last one, as the learnings from the last iteration guide us towards future improvements.</p><p>Sometimes, the learning from our last iteration is that we have incurred too much design debt. In this case, <strong>building on top of what exists no longer makes sense</strong>.</p><p>Instead, we have to realize that the very foundation of our application must be changed. We must think of our next iteration as a <strong>system iteration</strong>: an iteration in which the design of software is holistically changed in order to increase consistency.</p><p>Instead of opting for the MVP of a feature, or the simplest viable solution, we look to bring all of our features back into the fold by evolving our design system to make them fit.</p><h4>System iteration must change the system itself, not simply add or subtract from it.</h4><p>Software applications are systems. Each feature is like a cog in a wheel — the behavior of one feature affects the others.</p><p>Similarly, the design elements which allow the user to interface with those features is also a system — the placement of one UI element, for example, will affect the placement of another.</p><p>We can no longer iterate simply by the addition or subtraction of design elements to a system — we must <strong>system iterate</strong>, or refactor the system to incorporate these new designs and features consistently, so that they interact smoothly with each other.</p><p>To make the design system consistent once more within our software, we may need to re-evaluate our visual design, user flow, information architecture, interactions between features, and even the features themselves.</p><h4>We don’t have to implement the system iteration all at once.</h4><p>While a designer may be able to design such a large iteration at no cost within their Sketch files, it might be an enormous effort for the team to actually implement and release it.</p><p>The team, especially from a technical perspective, may be daunted by the analogous task of having to eat the elephant that is this major design change.</p><p>But code refactors don’t need to happen all at once, and neither do design refactors. The team should evaluate if a design refactor can be released iteratively<em> </em>while still making sense — for example, implementing new visual styles without changing much of the flow, or vice versa, or changing the most important part of the user’s experience before tackling other parts.</p><p>Eating the elephant becomes a lot less daunting when we realize we can do it one bite at a time.</p><h4>System iteration is not the only type of iteration we should perform.</h4><p>As valuable as system iteration can be in improving the consistency of software and its user experience, it does not diminish the value of the smaller iterations.</p><p>There will still be many times, more often than not, when there are many unknowns about the user and their context. In this case, the addition of a small experimental design can be helpful in reducing the risk of wasting resources on features which are not useful (or guessing incorrectly about how it should behave) — even if it is slightly inconsistent with the existing design system.</p><p>Once such a feature has been proven useful, system iteration is the next step towards incorporating it into the larger picture.</p><h4>System iteration is not a one and done task.</h4><p>As our software grows to maturity and marketability, there will be many times when system iteration should take place.</p><p>There will always be improvements to make, features to add, and edge cases to consider. Continue to routinely system iterate, and it will become less costly over time. It will maintain and improve the health of our software’s user experience.</p><p>If you pay off your debt regularly, your payments will become less hefty over time.</p><h4>We will most likely have to argue for its value.</h4><p>Design can struggle to have a voice at the table when it comes to big decisions. Business stakeholders, product managers, and developers may not understand the value of a system iteration, especially if it’s the first such system iteration that the team will undertake.</p><p>Argue for a system iteration by pointing back to user data and best practices:</p><p><strong>Point to product analytics and qualitative data that reveals how users may be struggling with the software’s user experience.</strong> Data can help prove our point to the team that a user is struggling to get through the software, which can affect conversions, net promotor scores, or the user’s willingness to return.</p><p><strong>Compare a system iteration to a code refactor, or design debt to technical debt.</strong> While not completely synonymous, this can help the developers see the value in implementing the iteration as a best practice. Changing the design provides a lot of the same value as a code refactor — they adapt software for scale and change.</p><p><strong>A system iteration will increase the marketability and maturity of the software.</strong> A system iteration can include improvements to interactions and visual design changes, as well as better information architecture. This can increase the marketability and maturity of our software, especially as it takes flight from its original MVP state.</p><p>While it is still wise to consider the “MVP” of a feature as a first step, we must remember that MVP is a simple way to validate its own usefulness — it is not meant to stay in this state, but evolve with feedback over time to become usable, pleasant, and marketable.</p><h4>Go back to <a href="https://medium.com/@lydia.b.jiang/design-debt-and-system-iteration-the-dangers-of-iterative-design-45dd5a3724ff">Part I of The Dangers of Iterative Design: Design Debt</a>.</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f2538d8bad9c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Debt: The Dangers of Iterative Design, Part I]]></title>
            <link>https://medium.com/@lydia.b.jiang/design-debt-and-system-iteration-the-dangers-of-iterative-design-45dd5a3724ff?source=rss-7fde1acf3d38------2</link>
            <guid isPermaLink="false">https://medium.com/p/45dd5a3724ff</guid>
            <category><![CDATA[iteration]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[iterative-design]]></category>
            <category><![CDATA[design]]></category>
            <dc:creator><![CDATA[Lydia Jiang]]></dc:creator>
            <pubDate>Mon, 02 Apr 2018 02:55:01 GMT</pubDate>
            <atom:updated>2018-04-02T16:54:45.014Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MdK2iVvA5o_ZNHSBYo3mKQ.jpeg" /></figure><h4><em>Iterative design is a crucial part of an Agile designer’s process, but it can incur hefty design debt for your product. How can you pay off this debt over time?</em></h4><h4>The Dangers of Iterative Design Series:</h4><p>Part I: Design Debt (this article)</p><p>Part II: <a href="https://medium.com/@lydia.b.jiang/system-iteration-the-dangers-of-iterative-design-part-ii-f2538d8bad9c">System Iteration</a></p><h4>We want to deliver value, but it’s risky.</h4><p>When you’re part of an Agile software team, you are constantly trying to balance two major goals.</p><blockquote><strong>Goal #1:</strong> I want my software to deliver as much <strong>value</strong> to users as possible.</blockquote><blockquote><strong>Goal #2:</strong> I want to reduce the <strong>risk</strong> that my software will fail as much as possible.</blockquote><p>Whenever we spend time, money, and manpower on creating software without releasing it to our users, we build up the risk that we are creating something that no one wants or which is difficult to use.</p><p>We could spend two years working on an application with twelve features and release it — only to find out that users:</p><blockquote>#1 — Are only interested in using two of the twelve features</blockquote><blockquote>#2 — Are extremely confused on how to navigate through the application</blockquote><p>In which case, we just wasted an extra year in development on an unusable user flow and blew more than half of our budget on non-useful features.</p><p>This is exactly the risk that Agile software teams are meant to combat. We are here to deliver value while decreasing the risk of failure — and if something is doomed to fail, <strong>we’ll find out sooner rather than later</strong>.</p><p>We are here to reduce the risk of the unknown by making it known, little by little.</p><h4>Designing and delivering iteratively reduces risk.</h4><p>One of the best and most common ways to balance user value and risk is to deliver working software <strong>iteratively</strong>.</p><p>We choose to work on and deliver our software to the user in smaller, quicker-to-develop units called iterations. Each iteration is a changed version of our software which has been incrementally improved upon since the last iteration. Improvements can include anything from new features to UI changes to bug fixes.</p><p>The team can evaluate the software’s effectiveness after each iteration, and make changes based on that information. For example, the team might find through product analytics or user interviews that the users haven’t been using one of the application’s features at all. The team might choose to de-prioritize working on it.</p><p>On the other hand, the engineers might discover that the database is not configured optimally and is causing a submission error, so they’ll prioritize fixing the bug and releasing that fix to users.</p><p>Iterative or continuous delivery can mitigate the risks of failing in the market by allowing for rapid changes based on frequent feedback. While iteration itself can’t save a bad idea from failing, it can identify such failure earlier and at lesser cost than a waterfall release. But it comes with its own unique disadvantages and risks.</p><h4>Designing iteratively can lead to choosing the simplest solution.</h4><p>Like the Agile teams they are embedded in, designers are constantly balancing two goals. Our designs must strive to provide user value — to be 1) useful and 2) usable to our users.</p><p><strong>Equally important, however, is the knowledge that we cannot fully predict the behavior of our users or the context that surrounds them. </strong>Design changes can upset users or cause user drop-off. A feature we spent a month designing and testing can end up not being used at all, or used in a way we never predicted. The visual metaphors and interactions we choose may confuse a large part of our user base.</p><p>To deliver value while mitigating risk, Agile designers will incrementally improve a design over time based on user feedback. These short feedback loops identify design problems early, and allow the designers to iterate those problems out of the software over time.</p><p>This is what as known as <a href="https://en.wikipedia.org/wiki/Iterative_design">iterative design</a>, and as simple as it sounds, it’s not a cut-and-dry process. Agile designers do not design in a silo; they must make tough decisions based on a variety of factors, including user feedback, complexity of implementation, unknowns about the user, and business requirements.</p><p>Designers will often test prototypes, interview users, or release a simple version of a feature to gather feedback and change their designs accordingly.</p><p>While we may want to design things “right” altogether, the truth is, there are often too many unknowns to design our software exactly right the first time. <strong>When much is unknown about the users, and the potential for unpredictable emergent behavior is high, it is often wise to design and release a solution which is relatively simple,</strong> and which will be improved over time through user data and feedback (or removed).</p><h4>The addition of new features threatens design consistency.</h4><p>But if we are not careful, our software can become disjointed: we’ll keep adding a simple version of a feature onto a system of already simple versions of features. This can negatively affect the quality of our software and user experience.</p><p>This is especially prevalent in software which has already achieved a post-MVP state. The design and feature set for MVP were carefully thought of together, working as a cohesive system in the designer’s mind.</p><p>But as new features, opportunities, and requirements are added to our software, we as Agile designers will attempt to minimize risk while maximizing value. We’ll create small design changes for these features and changes, tacking them on to the existing design system without changing much of the underlying structure.</p><p>These new feature designs don’t exactly fit into the system and consistency of the previous design — but these new designs are as much a way to gather feedback about users as it is to provide value to them. They’re not ideal, but they’re still functional, so the designer and the team accept the inconsistency for one feature. Then they accept the minor inconsistency of a second feature. Then they accept a third, and then a fourth.</p><p><strong>Very quickly, the design system of our software has become inconsistent — sometimes incoherent.</strong> This makes the user experience suffer. Users may no longer know how to navigate through this system or perform a task; they become slowed down, stuck, or frustrated, and they may question the quality of the software.</p><p>Iterative design poses a unique risk: we begin to break the very cohesive patterns of the software we had created—and if we lose sight of that cohesiveness in the long-term, iterative design can quickly become an obstacle to a good user experience.</p><h4>Iterative design very often incurs design debt.</h4><p>For a new Agile designer, this outcome can be disheartening. It can lead to the belief that we are bad designers, unable to serve the user we are trying to help. However, this situation is fairly common, even for experienced designers— teams, product managers, and engineers also face this difficulty.</p><p>One of the major outcomes of iterative design, and iteration itself, is <strong>debt</strong>. When we deliver value in smaller units, we may choose to compromise the quality of our application for a faster release or to reduce unknowns.</p><p>In the Agile world, this compromise in quality is called “debt” and can exist in the code (<a href="https://en.wikipedia.org/wiki/Technical_debt">technical debt</a>) or in the design (design debt). We incur technical and design debt with the promise that we will iterate it out of the software in the future, for the sake of delivering value and reducing unknowns <strong>now</strong>, not two years later.</p><p><strong>Debt is a valuable tool if we make good on this promise; however, to neglect making payments towards it is to diminish the usability and code quality of the software.</strong></p><h4>Refactoring reduces technical debt. What about design?</h4><p>Refactoring is a well-known process that software engineers use to pay off their technical debt. It’s considered healthy to consistently change the code patterns they’ve written in the past to meet future requirements. Engineers will usually have learned something from their first try at implementation — based on these learnings, even if there are no new features to add, they’ll perform refactors to make the current state of their codebase cleaner and more efficient.</p><p>They are not bad engineers for fundamentally changing what they once made; nor are they bad for not designing their code perfectly the first time. On the contrary, they are living into Agile by responding to change and feedback, and living into development best practices by iterating on their system as a whole.</p><p>But what about design? What technique exists for Agile designers to pay off their design debt?</p><h4>Read <a href="https://medium.com/@lydia.b.jiang/system-iteration-the-dangers-of-iterative-design-part-ii-f2538d8bad9c">Part II of The Dangers of Iterative Design: System Iteration</a>.</h4><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=45dd5a3724ff" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>