<?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 Erin Donnelly on Medium]]></title>
        <description><![CDATA[Stories by Erin Donnelly on Medium]]></description>
        <link>https://medium.com/@edonnellydesign?source=rss-274b7eed54a6------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*LlUj919B2auiHjW6LBdfxg.jpeg</url>
            <title>Stories by Erin Donnelly on Medium</title>
            <link>https://medium.com/@edonnellydesign?source=rss-274b7eed54a6------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 22:05:15 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@edonnellydesign/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[Designing Against Over-Reliance]]></title>
            <link>https://medium.com/design-bootcamp/designing-against-over-reliance-9d03dc5e216e?source=rss-274b7eed54a6------2</link>
            <guid isPermaLink="false">https://medium.com/p/9d03dc5e216e</guid>
            <category><![CDATA[trust]]></category>
            <category><![CDATA[ai-design]]></category>
            <category><![CDATA[ep]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Erin Donnelly]]></dc:creator>
            <pubDate>Fri, 04 Sep 2026 19:01:19 GMT</pubDate>
            <atom:updated>2026-09-08T20:29:30.684Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*D7pv1dfZWlzl0EzEz7B7hA.jpeg" /></figure><h3>Patterns for Designing Against Over-Reliance</h3><h3>When trust goes too far</h3><p>We usually treat trust as something to build up. More explanation, more transparency, more reassurance. But a user’s confidence in an output should match how reliable that output actually is. When confidence runs low, people ignore good work and stop using the feature. When it runs too high, people accept things that were never checked.</p><blockquote>When users under-trust, the feature takes the hit. When they over-trust, the outcome does.</blockquote><h3>Over-reliance is a rational response to what we built</h3><p><a href="https://arxiv.org/abs/2212.06823">Studies suggest</a> that over-reliance isn’t simply a failure to think critically. People often weigh the effort of checking an AI output against the effort of accepting it. When verification is difficult, accepting the answer can feel like the easier and more rational choice. On the design side, this means reducing the effort required to verify an output can be an important way to prevent over-reliance.</p><p>The lack of verification isn’t limited to low-stakes AI interactions. <a href="https://pubmed.ncbi.nlm.nih.gov/24581700/">Research</a> has documented automation bias in high-stakes domains like healthcare and aviation, where people can follow incorrect system recommendations even when they have the expertise to make the decision themselves. More <a href="https://www.medrxiv.org/content/10.1101/2025.08.23.25334280v2">recent research</a> with generative AI has found similar patterns, including physicians becoming more likely to accept <strong>incorrect</strong> AI recommendations.</p><blockquote>Attention and time are a fixed budget. When verification costs more than the budget allows, people will naturally look for ways to reduce that cost.</blockquote><p><strong>The design goal isn’t to make people distrust AI. It’s to make appropriate reliance easier: knowing when to accept an output, when to question it, and when to verify it.</strong></p><h3>Will this go away as models get better?</h3><p>Models are getting better at questions with clear, verifiable answers, but much of what people use them for is not that. It is “what should we do here?” where the answer depends on context the model does not have: what your team can ship, what your users need, or what trade-offs you are willing to make. In those cases, the model is not necessarily wrong. It may simply be missing information that changes the answer.</p><p>Over-reliance is most likely when a system is good enough that people stop checking, but not good enough that checking is unnecessary. That is where trust can outrun reliability. And as errors become less frequent, our ability to recognize them can weaken. This creates a design challenge around calibrating reliance and helping users apply the right level of judgment to AI outputs.</p><p>There are many ways designers can approach this. Here are four design approaches that can help reduce over-reliance:</p><h3>1. Reduce validation friction</h3><p>The goal should be to go beyond showing users where an answer came from, and to also make verifying that answer easy enough that they will actually do it.</p><p>When a user has to click into a citation, find the relevant passage, and figure out how it supports the claim, verification becomes a separate task. The more effort it takes, the less likely people are to do it, even when the information matters.</p><h4>Design patterns to consider:</h4><ul><li><strong>Anchor sources to the claim</strong><br>Place the source directly alongside the statement it supports, so users don’t have to figure out which citation belongs to which claim.</li><li><strong>Deep-link to the exact passage</strong><br>Take users directly to the relevant page, paragraph, or excerpt.</li><li><strong>Inline evidence previews</strong><br>Give users a lightweight preview of the supporting evidence without requiring them to leave their current workflow.</li><li><strong>Copy with citations</strong><br>Preserve the connection between an output and its supporting sources when users move information into another document or workflow.</li></ul><blockquote><strong>Principle: Go beyond providing evidence, and design a seamless path to verifying it.</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DlC6m3gClXW9UqetBGJF_Q.png" /><figcaption>Glean deep-links citations to the relevant source and surfaces a preview of the supporting passage, reducing the effort required to verify an AI-generated claim.</figcaption></figure><h3>2. Break the output into pieces that can be checked</h3><p>AI often presents its work as a finished answer: a paragraph, recommendation, or completed workflow. That makes review more difficult because the user has to unpack the output before they can evaluate it.</p><p>Decomposition removes the work of reconstructing the output before it can be assessed, and it can convert a single global accept into a series of smaller judgments.</p><h4>Design patterns to consider:</h4><ul><li><strong>Break outputs into checkable units</strong><br>Present claims, recommendations, or decisions as distinct units so users can evaluate them individually rather than reviewing one large block of output.</li><li><strong>Separate retrieval from inference</strong><br>Make it clear what the system found in the source material versus what it concluded from that information.</li><li><strong>Mark what came from the user.</strong> Distinguish content the user supplied from content the system generated, so the parts of an output that carry AI authorship stay identifiable as the work moves forward.</li><li><strong>Show diffs and change summaries</strong><br>For agentic workflows, highlight what changed and why rather than asking users to compare the before and after themselves.</li></ul><blockquote><strong>Principle: Don’t make users deconstruct an answer to understand what they’re being asked to trust.</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jBjoAihgwHMXIjgmlpWUyA.png" /><figcaption>Harvey splits each cell into Answer and Reasoning, with citations at the statement level and Verify attached to the unit being judged. The granularity allows users to more efficiently verify the model’s reasoning and answer.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0Bzl-yWg2v3rbcNI-I--Vw.png" /><figcaption>Granola renders the users notes in black and its own additions in grey, making the parts of a note that need checking visible at a glance.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Dq-RaT21qfBSKfiSo6EfgQ.png" /><figcaption>Spellbook renders each suggested edit as track changes with its reasoning attached. Reviewers judge one change at a time rather than accepting a draft whole.</figcaption></figure><h3>3. Say what the answer does not cover</h3><p>The previous two approaches make checking easier or more likely. This one tells users when checking is worth doing. Someone who knows an answer didn’t cover preprints won’t verify a claim, but they’ll know where the answer has a hole and can decide whether it matters for their situation.</p><p>This only helps if the user can act on it. “Searched 400 of roughly 1,200 matching papers, 2019 to present, with no coverage of preprints” can be checked against their own needs. However, a summary judgment about the answer’s quality gives them less to work with.</p><h4>Design patterns to consider:</h4><ul><li><strong>State what shaped the answer, and what it left out.</strong> <br>Show the sources, time periods, and datasets that bounded the result, plus anything unavailable or not searched. Gaps are hard for users to spot on their own.</li><li><strong>State the assumptions behind the answer.</strong> <br>Show what the system took as given when information was missing, so users can judge whether those premises hold. <br><em>Note: This one is generated rather than measured, so treat it as less dependable. Placement matters here, as a limitation stated before the answer influences how it’s read.</em></li></ul><blockquote><strong>Principle: Make the scope and limitations of an output visible at the point of judgment.</strong></blockquote><p><strong>A caution specific to this approach:</strong> Telling users an answer is well covered gives them a reason not to check for themselves, and the system making that claim is the one being checked. Users should be able to see what the claim rests on.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MgcuZtu95u214dN32rLJNg.png" /><figcaption>Elicit puts the scope, filters, and counts before the conclusion, so the reader forms a view of the evidence base before there is an answer to accept.</figcaption></figure><h3>4. Treat verification as a habit rather than a step</h3><p>Verification tends to decline as users become familiar with a system. When the system performs well consistently, checking can start to feel unnecessary, even when an error still matters.</p><p>Cognitive forcing functions are one way to interrupt that drift. <a href="https://arxiv.org/abs/2102.09692">Research</a> has found that requiring people to make an initial judgment before seeing the AI recommendation, or asking them to choose between alternatives, can reduce over-reliance. The idea is to create moments that keep users actively engaged in the decision rather than defaulting to acceptance.</p><h4>Design patterns to consider:</h4><ul><li><strong>Put friction where it counts.</strong> Keep users involved at the points where errors would be consequential or hard to reverse, rather than asking for approval at every step or only at the end. Low-risk steps can stay lightweight.</li><li><strong>Confirm premises before the work compounds.</strong> When the system has inferred goals, constraints, or scope, let users correct that before it shapes everything downstream.</li><li><strong>Present alternatives.</strong> Give users several plausible options rather than a single answer that is easy to accept by default. <br><em>Note: This also makes variability a more obvious characteristic of the output.</em></li><li><strong>Use reflection instead of interruption.</strong> For longer sessions, summarize what the system did, what the user accepted, and where they made changes.</li></ul><blockquote><strong>Principle: Make opportunities to exercise judgment a recurring part of the workflow, with the level of friction matched to the consequences.</strong></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pDjlyFzUANrZYoQ8ovnbWA.png" /><figcaption>Cursor Plan Mode: Cursor drafts the spec, then asks three questions with named options before implementation begins</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oY_yaD_2kgAzF5Y_kkEiMA.png" /><figcaption>Gemini states its plan and asks before it runs. “Edit plan” makes correcting the premise easy.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_ulUjxySa9jmr4kYcqjs2w.png" /><figcaption>Cursor’s agent reads the codebase, then stops to ask what the interface should display before writing anything. The question is posed as a choice rather than a confirmation, so there is no default to accept.</figcaption></figure><h3>Conclusion</h3><p>As AI becomes more capable, users should be able to understand how much reliance the output warrants, and what level of judgment the situation calls for.</p><p>That puts an important responsibility on the interface. Evidence should be easy to verify. Outputs should be structured for review. Limitations should be visible where decisions are made. And workflows should create meaningful opportunities for users to exercise judgment, with the amount of friction reflecting the consequences of getting something wrong.</p><p>When these patterns work together, verification becomes a natural part of using the product rather than an extra task users have to remember to perform.</p><p><strong>The goal is appropriate reliance: knowing when an output is well supported, when something deserves a closer look, and when human judgment needs to take the lead.</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9d03dc5e216e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/designing-against-over-reliance-9d03dc5e216e">Designing Against Over-Reliance</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing the Context Window]]></title>
            <link>https://medium.com/@edonnellydesign/designing-the-context-window-0f0a9ae06a92?source=rss-274b7eed54a6------2</link>
            <guid isPermaLink="false">https://medium.com/p/0f0a9ae06a92</guid>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[conversational-ai]]></category>
            <category><![CDATA[ai-product-design]]></category>
            <category><![CDATA[ui-design]]></category>
            <dc:creator><![CDATA[Erin Donnelly]]></dc:creator>
            <pubDate>Thu, 11 Jun 2026 02:44:36 GMT</pubDate>
            <atom:updated>2026-06-11T02:44:36.053Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*E0zz6FYSh715BPRVNaS-Sg.png" /></figure><h4>How UX can shape what AI knows and does</h4><h4>The AI forgot something important. <br>It used the wrong document. <br>It contradicted itself. <br>It gave an answer that was confidently wrong.</h4><p>Sometimes this is a model problem. But more often it’s a context problem, and context problems are problems where designers can help.</p><p>Every time a model responds, it works within a context window: the total input it processes in a single call. It draws on a combination of things: the user’s message, conversation history, retrieved documents, system instructions, tool outputs. Together, these form the context available to the model.</p><p>The interface shapes what a user can put in, how much, and in what order , and the backend layer translates those interactions into what actually enters the context window. Together, they’re one of the highest-leverage surfaces in an AI product, and one designers should understand and actively influence.</p><h3>Why the window fills up badly by default</h3><p>Two things happen to context windows without deliberate design.</p><p><strong>Problem 1: Too much information</strong></p><p>Long conversations accumulate history. Retrieval systems pull in documents. Eventually the context window fills with information that was relevant fifteen minutes ago but no longer matters. This dilutes what the model actually attends to.</p><p><strong>Problem 2: The wrong information gets attention</strong></p><p>Models don’t treat all information equally. Research has shown that models can attend unevenly to context, with content in the middle of a long window sometimes receiving less attention than content at the edges. Relevant information can become buried.</p><p>The interface can shape what goes into the window, when, and in what order. That’s the design problem.</p><h3>Pattern 1: Make the context visible</h3><p>Most AI products give users no visibility into what the model is working from. The user types a message, a response appears, and whatever happened in between is opaque.</p><p>When the model reasons from an outdated document, or ignores a file the user assumed was active, or carries forward a wrong assumption from ten messages back, users have no way to spot it. They just get a response that’s off, and they can’t tell why.</p><p>Cursor does this with @file and @codebase, where referenced files appear explicitly in the response. NotebookLM shows active sources as a persistent panel. Claude surfaces which documents were referenced via inline citations. Each approach is different, but they share a function: giving users enough visibility to spot when the context is wrong and do something about it.</p><p>The surface doesn’t need to expose token counts or retrieval scores. It needs to answer one question the user actually has: <em>is the AI working from the right information right now?</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_Ma8YImv2rg6Qkpz6Hu3OQ.png" /><figcaption>NotebookLM answers the user’s question, “Is the AI working from the right information right now?” by explicitly showing the scope of what it’s working from. The UI surfaces its active sources, making it easy for the user to intervene and adjust the scope.</figcaption></figure><h3>Pattern 2: Manage what’s in scope (Explicitly or Implicitly)</h3><p>Historically, retrieval systems made autonomous, black-box decisions about what entered the context window. When they got it wrong, users were left with polluted context and no recourse. When treating context scope as a design decision, there are a few approaches:</p><p><strong>1. Explicit Source Control (Manual Agency)</strong> This approach gives users direct agency over what’s active. At its simplest, this is a document selector: users include or exclude specific files before a conversation starts, or remove a source mid-conversation that’s clearly pulling the model in the wrong direction. The more durable version is a workspace model, where a project or case defines a persistent context boundary. Users manage the workspace rather than the individual conversation, and context lives at the project level rather than the thread level.</p><p><strong>2. Intelligent Background Curation (Automated Synthesis)</strong> Conversely, rather than asking the user to manually prune their data, some models use background processing to automatically curate the context window. <a href="https://openai.com/index/chatgpt-memory-dreaming/">ChatGPT’s <strong>“Dreaming”</strong> architecture is an example of this pattern</a>. Instead of dumping raw, multi-year memories into the active window, a background process continuously synthesizes past conversations, extracts relevant implicit preferences, and actively decays “stale” facts over time. This keeps the context window fresh without requiring manual user intervention.</p><p>Whether through explicit manual control or automated systems, giving the context window a defined, curated scope prevents context pollution before it causes a bad response, rather than forcing the user to diagnose it after.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lGIXXtZiJqX90ar3fDIGfg.png" /><figcaption>An screenshot from ChatGPT’s ‘Memory Summary’ UI under the new Dreaming architecture, showing how users can highlight automatically synthesized background context to make inline corrections or delete stale preferences. <a href="https://openai.com/index/chatgpt-memory-dreaming/"><em>Check out their full blog post.</em></a></figcaption></figure><h3>Pattern 3: Design for context repair</h3><p>Every AI system eventually accumulates bad context. A conversation drifts, or an early wrong assumption gets reinforced across subsequent turns.</p><p>A “new chat” button is a blunt instrument. It clears everything, including the useful context the user has spent time building.</p><p>Surgical repair patterns are more useful:</p><p><strong>Selective removal.</strong> The ability to delete a specific message, document, or assumption from the active context, actually removing it from what gets sent to the model rather than just hiding it in the UI. This directly addresses the problem of bad context that keeps propagating through a conversation.</p><p><strong>Mid-conversation source swapping.</strong> Replacing a document that’s no longer accurate without starting the conversation over. Users shouldn’t have to rebuild an entire thread because one source changed.</p><p><strong>Correction injection.</strong> Some products let users pin a correction as a high-priority instruction. This works in part because pinned content is typically placed at a position the model tends to attend to strongly, making it more likely to override earlier information rather than compete with it.</p><p><strong>Context quality degrades over time. </strong>Repair should be a first-class feature of the interface, with enough granularity that users can fix specific problems without losing everything.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6SI_bvelikMy8ELCO4naxg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5ypFMhLw8rfqSbITv2p2uA.png" /><figcaption>The inline thread branching pattern. The user edits an old prompt from an early mistake (‘Are cats better than dogs’) to the intended query (‘Are cats better than people’), discarding the polluted context downstream to start a clean conversational branch.</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0J12ncKrEfILxk-s5XRO2g.png" /></figure><h3>Pattern 4: Guide users toward better context inputs</h3><p>Output quality is bounded by input quality. Most users don’t know what information the model actually needs, and most interfaces do nothing to help them figure it out.</p><p>The blank prompt box is the default. It’s also the least effective interface for context acquisition because it gives users no signal about what would actually be useful to include.</p><p>Better patterns help users build context progressively:</p><p><strong>Structured inputs</strong> replace open-ended prompts with forms or guided flows for high-value use cases. A support tool might ask for product area, what the user has already tried, and what the expected behaviour should be. Each field maps to a specific piece of context the model needs rather than leaving the user to figure out what to volunteer.</p><p><strong>Clarifying questions before generation.</strong> Rather than responding immediately with incomplete context, the model asks targeted questions first. This front-loads context gathering and produces better first responses, with fewer correction cycles. Note: This works best for high-stakes or complex use cases where a better first response is worth the extra step, as for simpler tasks, the questions can feel like friction.</p><p><strong>Onboarding as context collection.</strong> First-run experiences in most AI products focus on explaining features. They should also be collecting the information the model will need to be useful over time: role, goals, preferences, constraints. That’s persistent context that improves every subsequent interaction.</p><p>The interface is where users provide the information environment the model reasons within. Designing for that explicitly is one of the highest-return investments in AI product quality.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LL57Fq2QJP7QCTWvcjIZ8w.png" /><figcaption>An example of a goal-oriented context pruning pattern in Cursor’s Plan Mode. By presenting an explicit multiple-choice gate regarding accessibility standards (WCAG AAA vs. OS Media Queries), the interface prevents semantic context pollution before the model initiates code generation.</figcaption></figure><h3>Pattern 5: Manage conversation length proactively</h3><p>Long conversations are a context window liability. History accumulates, old information competes with new information, and the window fills with turns that stopped being relevant many messages ago.</p><p>Most products handle this passively in the background, summarizing older messages without any user visibility into what got compressed or when.</p><p>More intentional approaches give users visibility or agency:</p><p><strong>Scope nudges.</strong> When a conversation shifts topic significantly, surface a prompt suggesting a fresh conversation. A clean window means the model starts with only the information relevant to the new problem, rather than carrying forward everything from the previous topic.</p><p><strong>Explicit summarization.</strong> A user-triggered “summarize and compress” action serves as an explicit signal that the model should treat the summary as canonical history going forward. This is more reliable than passive background summarization because it’s intentional rather than invisible.</p><p>Conversation length is a resource. Designing tools that help users manage it keeps the model working from the information that actually matters.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oiYmWQSFZsw6Fu1AxIhZ_A.png" /><figcaption>An example of topic drift intervention via thread forking in Perplexity: When a user shifts from a financial market query to an unrelated query about dog breeds, the system forks the thread. This is preserving the original history while dropping the irrelevant context to keep the new conversation clean.</figcaption></figure><h3>Designing the window, not just the screen</h3><p>None of these patterns require exotic technology. Source selectors, context panels, repair actions, structured inputs, scope nudges: these are interface primitives.</p><p><strong>The basic mental model: </strong>user types message, model responds, designer makes that feel good.</p><p><strong>The more complete model: </strong>user interacts with interface, interface (alongside the backend layer) shapes the information environment the model reasons within, and the response reflects the quality of that assembly.</p><blockquote>Designing that environment well improves the probability of a good response. What the model does with it (how it attends, weighs, and reasons) remains, in part, outside anyone’s full control.</blockquote><p>Designers don’t just shape the interaction anymore. They can help to shape the information environment the model reasons within.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0f0a9ae06a92" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing in Cursor is About More Than Speed]]></title>
            <link>https://medium.com/design-bootcamp/designing-in-cursor-is-about-more-than-speed-f46e49de5f7e?source=rss-274b7eed54a6------2</link>
            <guid isPermaLink="false">https://medium.com/p/f46e49de5f7e</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ai-product-design]]></category>
            <category><![CDATA[cursor]]></category>
            <dc:creator><![CDATA[Erin Donnelly]]></dc:creator>
            <pubDate>Thu, 07 May 2026 07:14:47 GMT</pubDate>
            <atom:updated>2026-05-07T22:36:50.238Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SGXAgiNztBHmovjZvbWHCg.png" /></figure><h4><strong>Designing with Real AI Outputs</strong></h4><p>Enterprise designers have traditionally designed dashboards, reports, and content experiences against a small curated subset of data. A few representative examples, a mocked response, or maybe even a best-case output. That worked for traditional software design, but for AI products, it breaks quickly.</p><p><strong>The thing that changed my prototyping approach was a JSON file.</strong><br>I was prototyping an AI feature with an engineer in Cursor when he added the ability to upload the actual JSON outputs his system was generating directly into the prototype. Almost immediately, the prototype prompting goal stopped being “design with this example content”. The goal became: can this hold up across every file we upload?</p><p>That thinking shift changes the nature of the design work.</p><h4><strong>From Interface Thinking to Systems Thinking</strong></h4><p>When you design around a very small curated output, you’re making decisions that optimize for those cases. The layout, the hierarchy, and the way information is presented is tuned to the examples in front of you. It looks great in review. Then real data shows up and the edges start to fray.</p><p>Designing next to the real outputs from the beginning forces you to think differently. Instead of building interface rules, you start building system rules. Your decisions need to survive variability, inconsistency, and edge cases across the full distribution of outputs.</p><p>The work shifts from polishing surfaces to shaping behaviour with system style prompting.</p><p>You start asking different questions:</p><ul><li>What needs to remain consistent regardless of the input?</li><li>What structure can absorb variability without collapsing?</li><li>Where does the system break down?</li></ul><p>AI product design requires designing that is much closer to systems design than traditional interface design.</p><h4><strong>Why Cursor Changes This</strong></h4><p>Figma is excellent for shaping interfaces. But AI systems are often less about static interfaces and more about behaviour, structure, and variability over time.</p><p>Working with AI outputs means dealing with JSON files, changing schemas, incomplete structures, and responses that refuse to behave like the clean examples in a mockup. Cursor puts you directly in contact with that reality.</p><p>In Cursor, you can test prompts and interface logic against many real outputs quickly, see where things fail, and iterate inside the same environment where the system is actually being built.</p><blockquote>You are no longer designing a representation of the product. You are designing inside the product.</blockquote><p>That proximity changes what becomes visible.</p><p>Edge cases stop feeling theoretical because you encounter them constantly. Assumptions surface immediately because the data exposes them. The resulting design decisions become grounded in system behaviour instead of idealized flows.</p><h4><strong>What Changes When You Work This Way</strong></h4><p>When designers work directly with real outputs, conversations with engineers and data teams become more concrete. Instead of discussing ideal flows, you are discussing behavior across inputs, failure states, and system constraints.</p><p>The conversation shifts from, “<em>Here’s the flow I designed”</em> to <em>“Here’s where the system holds up, and here’s where it breaks.”</em></p><p>That creates a much tighter feedback loop between design, engineering, and AI behaviour itself.</p><p>The second thing that changes is confidence.</p><p>There’s a difference between presenting work that looks convincing and presenting work that has actually been tested against reality. Designing against real outputs gives you a much clearer understanding of what your decisions are built on and where they fail.</p><p>Most design practices evolved in a world where the content was controlled. However, AI products break that assumption. You cannot design AI experiences from a curated slice of outputs and expect them to hold up nicely in production. The real design work happens across the full distribution because that is where variability, ambiguity, and edge cases live.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f46e49de5f7e" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/designing-in-cursor-is-about-more-than-speed-f46e49de5f7e">Designing in Cursor is About More Than Speed</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[When Engineering Moves First: Tips for Designers Navigating Technical PoCs]]></title>
            <link>https://medium.com/design-bootcamp/when-engineering-moves-first-tips-for-designers-navigating-technical-pocs-46c622b562aa?source=rss-274b7eed54a6------2</link>
            <guid isPermaLink="false">https://medium.com/p/46c622b562aa</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[proof-of-concept]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[genai-design]]></category>
            <dc:creator><![CDATA[Erin Donnelly]]></dc:creator>
            <pubDate>Wed, 02 Jul 2025 03:05:53 GMT</pubDate>
            <atom:updated>2025-07-02T10:35:22.968Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xVR7TF1otAAoFdfe0oSwhQ.png" /></figure><p>I’ve seen quite a few projects lately where the code had been written, but the team wasn’t sure if it was actually worth building. In today’s AI-driven product landscape, technical proofs of concept (PoCs) are becoming a more prevalent part of product development, especially in fast-moving or experimental environments.</p><p><strong>This article offers practical techniques to help designers:</strong></p><ul><li>Recognize when a technical PoC hides untapped user value</li><li>Turn technical wins into real, usable features</li><li>Avoid the trap of shipping something shiny but doesn’t serve the user</li></ul><h3><strong>What is a PoC?</strong></h3><p>A technical proof of concept (PoC) is a quick, backend-first build that answers one question: “Can we do this?” It’s not a product. It doesn’t guarantee user value. It’s a feasibility test.</p><p>The rise of AI has only accelerated their use. With powerful tools evolving daily, engineering teams are moving fast to explore new functionality, <strong>sometimes faster than design can catch up</strong>. PoCs are everywhere now because they reduce risk, can be created faster than ever before, and help teams validate what’s possible before they commit to building something at scale.</p><p>But just because something <em>works</em> doesn’t mean it delivers user value. That’s where design can step in.</p><h3>The Challenges of Designing Around a PoC</h3><p>Working with PoCs is rarely clean. You’re often brought in after momentum has started, and your role is to reintroduce user thinking into a process that moved fast without it. Here’s why it can be a challenge:</p><ol><li><strong>You’re late to the party.</strong> Design can come in <em>after</em> engineering has proven the concept.</li><li><strong>There’s little or sometimes no user story.</strong> The PoC shows what can be done, but not always articulating why or for whom.</li><li><strong>The UI is non-existent or hacked together.</strong> What you see wasn’t built for users, just for technical proof.</li><li><strong>Expectations are uneven.</strong> Stakeholders may already be excited or attached to the direction.</li><li><strong>Time is short.</strong> There’s often pressure to productize quickly after a successful PoC.</li></ol><p>With those realities in mind, here are three common types of PoCs you may encounter, and how to navigate each one.</p><h3>1. The “Iceberg” PoC (<em>More useful than it first appears)</em></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NHN3f3mhJ6_BCNDgdok7dA.png" /></figure><p>PoCs begin as a way to prove something technical, and sometimes that thing ends up unlocking new value that wasn’t anticipated.</p><p>In one case, a backend capability was developed to stream partial conversation responses as they became available in a more modular way, primarily to address speed concerns. Technically, it succeeded in that information could appear progressively, reducing perceived latency. But the unlock wasn’t just faster delivery, it was also the structural potential of breaking responses into pieces. This opened the door for new forms of transparency and explainability on the front end for the user. Each module could carry its own explanation or supporting evidence, helping users understand not just the output, but how it was generated.</p><p><strong>Design’s role in an “Iceberg” PoC</strong> is to recognize and elevate hidden user value. As designer’s we supply another lens to technical PoCs. Instead of asking <em>“Is this possible?”</em>, designers ask, <em>“What does this unlock for the user?”</em></p><p>In these cases, design brings a holistic lens that looks at the system, the user journey, and the unexpected ripple effects a new capability might create. By applying systems thinking, pattern recognition, and contextual understanding, designers can help recognize the “Iceberg” PoCs potential.</p><p><strong>How to Spot (and Maximize) an “Iceberg” PoC:</strong></p><ul><li><strong>Look Beyond the Primary Goal</strong><br>Ask: <em>What was this built to solve?</em> Then ask again: <em>What else could this enable for the user?</em></li><li><strong>Check for Structural Shifts, Not Just Outcomes</strong><br>Is the PoC introducing new data formats, interaction patterns, or content delivery styles? These shifts often open up previously unavailable UX possibilities.</li><li><strong>Ask: Is This Reusable in Other Contexts?</strong><br>If the technical gain feels flexible or portable, it may be part of a larger opportunity space.</li></ul><h3>2. The “Treasure Map” PoC (the value’s there, users just can’t get to it)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SQam4ZMrhOOzpDS7n_OBEw.png" /></figure><p>Sometimes, the technical capability is in place <em>and</em> the user value is obvious, but there’s no UX to deliver it.</p><p>In one case, engineers successfully connected older, structured data into a new AI-powered workflow. The integration made sense and offered obvious benefits to users. But it wasn’t yet clear how that data should show up in the interface.</p><p><strong>Design’s role in a Treasure Map PoC</strong> is to clear a usable path to what’s newly available. You’re not discovering the value, you’re making it reachable.</p><p><strong>Tip for designing with a “Treasure Map” PoC:</strong></p><ul><li><strong>Clarify the User Purpose First</strong><br>Anchor your design decisions by asking: <em>What job is this helping the user do?</em> Reaffirm the core user need this capability supports to ensure the experience is shaped around impact, not just visibility.</li><li><strong>Design for Placement, Not Just Presence</strong><br>Don’t just “add” the new capability, embed it where it naturally fits in the user’s journey. Consider when, where, and how it should surface to feel helpful and intuitive.</li><li><strong>Map Entry Points Across the Flow</strong><br>Create multiple touch points where users might encounter the value. Make the path to value discoverable, not buried.</li></ul><h3>3. The “Mirage” PoC (Looks impressive, but doesn’t deliver user value)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w1TymN4h3LYLDLs2QClpdQ.png" /></figure><p>Not every PoC should ship. Some demo well, generate excitement, and check the technical feasibility box. But once real users try to interact with them the illusion fades. The functionality exists, but the product story doesn’t hold no matter how you twist it. That’s a <em>Mirage PoC</em>.</p><p>In one case, engineering explored transforming long form responses into interactive diagrams. Technically, it worked. But as we designed the experience, it became clear that users didn’t understand the capability, expected more than we could deliver, and were ultimately confused. The idea felt promising in theory, but in practice, it didn’t help users progress.</p><p><strong>Design’s role in a Mirage PoC</strong> is to test not just whether it works, but whether it <em>resonates</em>. And if it doesn’t, the most valuable thing design can do is help a team realize when <em>not</em> to build.</p><p><strong>How to avoid shipping a “Mirage” PoC:</strong></p><ul><li><strong>Validate feasibility <em>and</em> fit.</strong> Just because it runs doesn’t mean it resonates.</li><li><strong>Test the narrative, not just the output.</strong> What story does this feature tell the user? Does it create clarity or confusion?</li><li><strong>Use low-fidelity tools to test concept viability.</strong> Don’t over invest before proving the core value.</li><li><strong>Celebrate pivots.</strong> A well-informed “no” clears the runway for better ideas.</li></ul><h3><strong>A Designer’s Guide to Making PoCs Work</strong></h3><p>Whether a technical PoC is hiding value, lacking UX, or dazzling without purpose, designers play a critical role in shaping what happens next. Here’s a reference you can use across <em>any</em> type of PoC:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5-zJ2njSAlo0ErHxMP1qGQ.png" /></figure><h3>Final Thoughts</h3><p>When design comes in after a technical PoC, it’s not just cleanup. Instead, it’s a shift in when discovery happens, not whether it happens. There’s still valuable alignment and insight to uncover. And in fast-moving, AI-driven environments, it’s one of the most strategic contributions design can make.</p><blockquote>A technical PoC isn’t a handoff from engineering to design. It’s a shift from “could it work?” to “should it ship?”</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46c622b562aa" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/when-engineering-moves-first-tips-for-designers-navigating-technical-pocs-46c622b562aa">When Engineering Moves First: Tips for Designers Navigating Technical PoCs</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Lean UX and Agile Design: The Faster, Smarter team for Gen AI Design]]></title>
            <link>https://medium.com/design-bootcamp/lean-ux-and-agile-design-the-faster-smarter-team-for-gen-ai-design-298546ed397a?source=rss-274b7eed54a6------2</link>
            <guid isPermaLink="false">https://medium.com/p/298546ed397a</guid>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[agile-design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ai-design]]></category>
            <category><![CDATA[lean-ux]]></category>
            <dc:creator><![CDATA[Erin Donnelly]]></dc:creator>
            <pubDate>Tue, 17 Dec 2024 02:59:13 GMT</pubDate>
            <atom:updated>2024-12-17T11:14:40.789Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fk_Cl35JfiN0wvsLaMU1Dg.png" /></figure><h3><strong>Designing for AI Is Complex and Costly</strong></h3><p>AI systems, especially conversational interfaces, are unpredictable. Their behaviour depends on complex models that can generate responses no one anticipated. Designing for every possible outcome is nearly impossible!</p><p>For example, a conversational assistant designed to explain niche concepts might hallucinate answers or fail to recognize domain-specific acronyms, frustrating users when it is finally launched. Addressing unexpected issues requires adaptability, not rigid upfront planning.</p><p>Building robust AI features is also resource-intensive. Validating the need for features before building them can save significant time and effort. For instance, creating a full conversational flow for filtering responses by multiple fields might take months — only to discover users are happy just typing in one or two simple filters.</p><p>The competitive Gen AI product space puts additional pressure on teams to deliver better products faster. Traditional UX processes struggle to keep up, which is why <strong>integrating Lean UX and Agile Design can help…..</strong></p><h3>What Is Lean UX?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dApGQNHCbo5ZdSu8sn4HgA.png" /></figure><p>Lean UX is about learning fast and validating ideas early. It prioritizes lightweight ways to test hypotheses about user behaviour or needs. Let’s focus on three key principles taken from Lean UX that are particularly effective for AI design:</p><p><strong>1. Solve the Right Problem </strong><br>Lean UX constantly validates both the problem and the solution through rapid testing and feedback, ensuring teams build something users truly need. Testing starts during the ideation phase and continues iteratively.</p><blockquote>Traditional UX may validate comprehensive designs to ensure they work as expected. Lean UX instead validates assumptions early and throughout the design phase, avoiding wasted design effort.</blockquote><p><strong>2. Exercise Flexibility</strong><br>Lean UX emphasizes adaptability. Testing small ideas early allows teams to iterate based on feedback without being stuck with rigid designs.</p><p>For example: Instead of building a full “yes/no” confirmation system, you could test if users engage with typing “yes” or “no” through a simple prototype. If users skip these prompts, you may quickly pivot to implicit confirmations instead of a more extensive confirmation system.</p><p><strong>3. Act as One Team</strong><br>Lean UX promotes collaboration across design, engineering, and product. This prevents silos and misalignment. And particularly valuable for Gen AI products, collaborations surface technical misunderstandings or constraints early.</p><h3>What Is Agile Design?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sW2v2b-fhTYG2pWKcGVIng.png" /></figure><p>Agile Design (like agile in general) emphasizes delivering value incrementally, aligning with Lean UX’s focus on fast learning. Every sprint is an opportunity to ship meaningful updates.</p><blockquote>Deliver value incrementally by implementing <strong>validated ideas </strong>within sprints. Agile Design’s sprint-based cycles complement Lean UX’s iterative approach, ensuring continuous improvement.</blockquote><h3>How Lean UX and Agile Design Work Together to Ship Valuable Ideas Often</h3><p>Lean UX and Agile Design align exploration with execution. Together, they prioritize rapid learning, collaboration, and incremental value delivery.</p><p><strong>Lean UX: </strong>Provides the framework for exploring and validating ideas.<br><strong>Agile Design: </strong>Executes those ideas incrementally.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*49vA4J0J-d7JcCmJam94Qg.png" /><figcaption>How Lean UX and Agile Design work together</figcaption></figure><blockquote>By combining these approaches, teams can solve the right problems, deliver value quickly and adapt to user needs and feedback.</blockquote><p>This synergy is ideal for the unpredictable nature and delivery pressure of AI design.</p><h3>How is this Different from Traditional UX?</h3><p>Traditional design assumes that the team has a clear understanding of the user’s needs, pain points, and goals upfront via the research that has gone into the initial problem statement. Thorough planning and documentation of the user needs occur early on, with belief that these requirements won’t change much throughout the project. Traditional design then launches larger, all encompassing designs creating long cycles.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pEzo5RfKbX73Zd28ffTLQQ.png" /></figure><h3>Project Example</h3><p>Let’s use a mock project example to compare a traditional approach with a Lean UX approach. <strong>Imagine users have expressed a need for additional explainability within a conversational tool.</strong></p><p><strong>A traditional UX process may look like this:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FiLEC3fozHFsSQ8b4fEbYA.png" /><figcaption>Traditional UX Process Example</figcaption></figure><p>1. <strong>Design:</strong> Conduct in-depth research, define system goals, create polished mockups, validate prototypes, and gain stakeholder approval.</p><p><strong>2. Develop:</strong> Build the complete feature, addressing technical constraints without returning to user validation.</p><p><strong>3. Launch:</strong> Deliver the entire explainability feature at once.</p><p><strong>A Lean UX process may look like this:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zTN9vvQNL_6OsZFur0WrGw.png" /><figcaption>Lean UX Process Example</figcaption></figure><p>1. <strong>Design: </strong>Define the problem collaboratively and write a hypothesis, e.g., <em>“Providing a brief explanation of how queries are interpreted will increase user trust.”</em> Then start quick, scrappy prototyping with a simple feature, like a “Why this answer?” button to see if anything may be missing.</p><p><strong>2. Develop:</strong> Roll out incrementally<br>Sprint 1: Build a basic button.<br>Sprint 2: Add collapsible sections for deeper context.<br>Sprint 3: Refine with visuals and personalization.</p><p><strong>3. Launch:</strong> Roll out incrementally, starting with the simplest feature and expanding as validated.</p><p><strong>The Key Differences:</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qVO8R0biWHhVYMFYft_gNA.png" /></figure><h3>Integrating Lean UX and Agile Design into your process:</h3><p>There are things we can do within our own process to start working towards this design framework today:</p><ol><li><strong>Shift from Deliverables to Outcomes <br></strong>Focus on achieving user-centered outcomes instead of polished deliverables. Define success by what you’ve validated, not what you’ve produced.</li></ol><p><strong>2. Design in Iterations<br></strong>Deliver a minimum viable design and improve based on feedback. Define the smallest, testable version of your idea.</p><p><strong>3. Collaborate Early and Often</strong><br> Involve engineers and PMs early in the design process to ensure alignment. Treat design as a collaborative effort, not a handoff.</p><h3>Integrating Lean UX and Agile Design into a cross-functional team:</h3><p>Adopting Lean UX and Agile Design goes beyond just the design process, it requires a cultural shift on your cross functional team. Here’s how to lead the change:</p><ol><li>Start Small: Start by implementing principles in low-risk areas, like a single feature.</li><li>Foster Collaboration: Use weekly rituals like co-design workshops to align all members of the team on iterative goals.</li><li>Advocate for User Value: Highlight how small changes can significantly improve UX.</li><li>Align the team on the definition of “Done”: Ensure that “done” means delivering user value, not just completing tasks.</li></ol><h3>Conclusion</h3><p>By combining Lean UX and Agile Design, teams can:</p><ul><li>Solve the right problems by validating ideas early.</li><li>Deliver value incrementally, adapting to user needs.</li><li>Focus on shipping meaningful, user-focused improvements every sprint.</li></ul><blockquote>In the dynamic world of AI design, embracing rapid learning, iteration, and collaboration is the key to success.</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=298546ed397a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/lean-ux-and-agile-design-the-faster-smarter-team-for-gen-ai-design-298546ed397a">Lean UX and Agile Design: The Faster, Smarter team for Gen AI Design</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tips and Insights —  Prototyping an LLM Experience]]></title>
            <link>https://medium.com/design-bootcamp/tips-and-insights-prototyping-an-llm-experience-1d613f97f504?source=rss-274b7eed54a6------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d613f97f504</guid>
            <category><![CDATA[llm-applications]]></category>
            <category><![CDATA[prototyping]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[conversational-ui]]></category>
            <category><![CDATA[figma]]></category>
            <dc:creator><![CDATA[Erin Donnelly]]></dc:creator>
            <pubDate>Wed, 15 May 2024 05:35:26 GMT</pubDate>
            <atom:updated>2024-05-16T22:20:19.945Z</atom:updated>
            <content:encoded><![CDATA[<h3><strong><em>Tips and insights — prototyping an LLM experience</em></strong></h3><figure><img alt="A purple wave graphic ith some creen shots of an LLM experience. The figma logo and ChatGPT logo are also included in this decorative banner." src="https://cdn-images-1.medium.com/max/1024/1*QiQWwcL9QpawLX2mCARDmQ.png" /></figure><p>In the world of product design, creating and communicating the design of an LLM experience presents a unique set of challenges and opportunities. This article dives into various aspects of prototyping that experience, ranging from communicating differentiation of responses, to why stepping outside of Figma into hybrid prototyping is important, and a bonus section around how we may need to adapt our traditional design processes to accommodate the fluid nature of LLM content.</p><h4>Contents:</h4><ol><li><em>Differentiating LLM-Generated Responses from Hard-Coded Responses</em></li><li><em>Designing for New and Shifting Behaviors</em></li><li><em>Enhancing Design Reality through Hybrid Prototyping</em></li><li><em>Incorporating Prompt Guidance in Design</em></li><li><em>Beyond Prototyping: Adapting the Design Process</em></li></ol><h3>Differentiating LLM-Generated Responses from Hard-Coded Responses</h3><p>A primary concern when integrating LLMs into product design is distinguishing between dynamically generated content and static, hard-coded responses. This differentiation is crucial as it impacts the flexibility and scalability of the design. Designs that fail to communicate the dynamic nature of LLM outputs risk overfitting to scenarios that aren’t flexible, where the experience performs poorly in unpredicted contexts. Moreover, without clear differentiation, stakeholders — including engineers and test-users — may not fully grasp the variability and dynamics of LLM content, leading to potential communication gaps.</p><p><strong>To manage this, product designers can employ several strategies:</strong></p><ul><li><strong>Visual Differentiation: </strong>Using markers such as “[LLM]” or different color codes to signify dynamic content can clarify which parts of an interface are generated by LLMs.</li><li><strong>Documentation &amp; Annotations: </strong>Annotating design files to outline what needs to be coded as flexible and what remains static.</li><li><strong>Multiple Output Examples: </strong>Presenting a range of potential responses from the LLM to illustrate how the outputs may vary, which helps in understanding the dynamic aspects of the design.</li></ul><figure><img alt="A screen shot showing an example of visual differentiation for LLM generated content. On the left the answer is purple and the card text is white, indicating dynamic answer content, and static card content. On the right all of the text is purple, including the multiple choice options, indicating all dynamic LLM generated content." src="https://cdn-images-1.medium.com/max/1024/1*aOi9ddULSm6Vmc9nXpmgVQ.png" /><figcaption>Here are a couple of examples when visual differentiation (colour and [text]) can help distinguish between dynamic and static parts of a response, that may otherwise be unclear.</figcaption></figure><h3>Designing for New and Shifting Behaviors</h3><p>LLMs introduce new interaction patterns and requirements, and may necessitate a re-evaluation of the importance we place on some current user interface behaviors and appearances.</p><p><strong>These new considerations may include:</strong></p><p><strong>UI Adaptation:</strong> Consider how you may need to detail the UI adaptations based on interactions with the Gen AI. For example:</p><ul><li>If a user frequently requests simplifications of complex answers, the system might adapt by defaulting to simpler explanations in future interactions.</li><li>If during a session, a user engages more with certain types of interactive elements like clickable tables or collapsible sections, the system could default to offering these elements more prominently in future sessions.</li></ul><figure><img alt="There are 2 screen shots to show an example of UI adaption. On the left is a text answer, and a small map card. On the right is a large map image and some text." src="https://cdn-images-1.medium.com/max/1024/1*XnwfSd8i3UJrydYa8I0x_Q.png" /><figcaption>In this scenario, a user may have engaged with the map repeatedly during their search. A UI adaption would be for the system to open the map, and feature it more prominently for the next response.</figcaption></figure><p><strong>Session-Specific Changes:</strong> Consider and communicate if an interaction with the LLM changes anything in the UI that needs to persist beyond that session.</p><p>For example:</p><ul><li>If a user prefers a specific font size or theme (like dark mode) for readability. Once they adjust this setting during a conversation, the UI can remember and apply these preferences in all future sessions. The LLM could then confirm this adjustment with a message like, “I’ve set your preference to dark mode. I’ll remember this setting for your future visits.”</li><li>If a user indicates they prefer more detailed responses or are interested in specific highlights, the LLM can adjust the detail level of future responses or filter the content to highlight these interests.</li></ul><p><strong>Streaming LLM Responses:</strong> Instead of waiting for a full block of text, streaming involves displaying the text as it’s generated (i.e. a single word, or set of words). This means we can show the progress in real-time, and users don’t need to wait for the entire text to load. This has benefits to combat latency, but requires consideration such as including visual or textual indicators that the response is complete, such as a checkmark, a change in the color of the loading animation, or a simple message like “Done!” to provide closure to the interaction sequence. This is still a relatively uncommon pattern, presenting opportunities for innovation. For example, if a user notices that an AI is generating a response in an undesired direction, they could stop the process and either redirect it or pose an alternative question.</p><figure><img alt="This video shows Chat GPTs streaming text. A blinking cursors follows the text as it generates. When the text is done being generated, the cursor disappears, and new icons appear under the text block." src="https://cdn-images-1.medium.com/max/1024/1*7al1teM5t_HzKCwLwd9DoQ.gif" /><figcaption>Chat GPT lets the user know that the response is finished being generated by removing the streaming icon, and displaying the response action icons.</figcaption></figure><p><strong>Maintaining Context:</strong> It is essential to retain the conversation context in ongoing interactions, ensuring a seamless and coherent user experience. Here are some ways that context can be maintained effectively beyond just ensuring there is short-term conversation memory:</p><ul><li><strong>Long-term Memory: </strong>For apps where users log in, the LLM can retain context across sessions, recalling past interactions, preferences, and ongoing topics from past conversations.</li><li><strong>Separate Threads:</strong> In complex conversations, the LLM may create separate threads, switching between them when the user query shifts focus. This can be done in the UI with colour-coded text, icons, or tabs to help the user keep track of what more specific topic they are discussing.</li></ul><p>It is important to also consider different scenarios for maintaining context. For example, if a user returns to a topic discussed earlier or if their input is ambiguous, the LLM may be designed to clarify or confirm the current topic to be sure that the response is relevant. (e.g., “Are you referring to your earlier question about [search target] or something else?”). Another example is that after a lengthy interaction, or upon returning to a previous topic, the LLM could summarize the points discussed so far to ensure alignment and refresh the context. This is called an interactive summary, and means that at regular intervals or when resuming a topic, the LLM provides a brief recap of what was discussed previously, possibly using interactive elements for exploration.</p><h3>Addressing Shifting Importance</h3><p>As new behaviors emerge, so may the importance of the traditional considerations we are already familiar with:</p><p><strong>Learnability:</strong> Guidance becomes even more important in an LLM experience as there is a higher need for baseline education with this very new technology. It’s vital to inform users about what they can do with new LLM features, particularly when they encounter them for the first time. For example, empty states should be utilized to communicate capabilities, and perhaps provide jumping off-points to accelerate learnability.</p><p><strong>Readability and Text Clarity:</strong> Given the text-heavy nature of LLM interactions, ensuring legibility with appropriate font sizes, spacing, and color contrasts is paramount.</p><p><strong>Sentiment and Inclusion: </strong>Designing for inclusivity and warmth not only encourages user adoption but also builds trust in this new technology. We should give more consideration to the sentiment and emotional connection our users feel with our product.</p><p><strong>LLM UI Patterns that lead to trust:</strong></p><ul><li>Clearly communicating limitations to set realistic expectations of the technology.</li><li>A respectful and friendly tone can make a significant difference in how users perceive the experience.</li><li>Accurate and source-backed answers</li><li>Consistency in results, and UI arrangements</li><li>Clarification requests, instead of making incorrect assumptions.</li></ul><p><strong>Patterns that lead to Distrust:</strong></p><ul><li>Overstepping, and making assumptions for the user without clear permission.</li><li>Generic or irrelevant responses can make interactions feel impersonal and unhelpful.</li><li>Failing to escalate to another interaction method, or conversational guidance when an LLM can’t resolve the issue.</li><li>Impersonal or robotic tone without elements of warmth or personality.</li></ul><h4>New flow. New needs.</h4><p>In traditional prototype designs, we’ve often relied on linear user flows, where one step logically follows another. However, with the advent of LLM-based interfaces, the interaction becomes conversational, mimicking human dialogue. Here, users can change the course of interaction at any point, pursuing different paths to reach their goals. This requires some updates to the arrangement and content of our prototypes.</p><p>We should communicate a flow that can accommodate unpredictable user interactions, and allow for multiple paths based on user dialogue. Avoiding overly rigid designs and prioritizing flexibility allows products to handle a wide range of conversational scenarios.</p><p>Although the possibilities are many for paths that a user may take in a conversational experience, it is important that the answer is designed first so that the system is optimized toward the ideal user outcome.</p><p><strong>We can do this by:</strong></p><ul><li><strong>Backward design: </strong>Define the ideal outcome and design the response that allows users to achieve this first. Then develop the conversational pathways that lead the users here. This helps to make sure that the interactions that occur along the pathways are purposeful.</li><li><strong>Design using Modular Thinking: </strong>Design components rather than whole systems. Each component should be able to handle a segment of the conversation independently or in sequence, depending on user input.</li><li><strong>Annotating, or Describing the Structure Breakdown: </strong>Detail how the responses break into modular components to function independently and integrate seamlessly into the broader ecosystem.</li></ul><blockquote>Designing and communicating this modular approach not only enhances scalability of the output — allowing us to add, remove, or update components without disrupting the entire system — but also allows for adaptation to the unpredictable user flow of LLMs.</blockquote><h3>Enhancing Design Reality through Hybrid Prototyping</h3><p>Hybrid prototyping merges traditional design tools like Figma with generative technologies such as LLMs, significantly enhancing the realism and depth of our prototypes.</p><p>This approach is pivotal not only for achieving precise design communication but also for improving our comprehension as we engage with new LLMs. By co-evolving UI designs alongside an LLM representation, designers can experiment and align model outputs with user-centered design needs, ensuring the authenticity of the design and effectively addressing the integration challenges between our intentions and engineering implementation.</p><h4>Benefits:</h4><ul><li>By working directly with LLM outputs during the prototyping phase, designers can ensure that the designs are not only innovative but also practical and executable.</li><li>Helps to mitigate common collaboration challenges with engineering teams due to the difficulties of aligning AI behaviors with user expectations.</li><li>Lets designers capture accurate user feedback on the reality of the experience, which is invaluable for refining the product before it reaches wider audiences.</li><li>Enables designers to gain a deep understanding of LLM capabilities and limitations through firsthand experience, ensuring that designs are grounded in reality rather than idealization.</li></ul><h4>Strategies for Hybrid Prototyping:</h4><ul><li>Experiment with various plugins and tools that integrate LLM functionality directly into Figma. These tools embed LLM-generated elements within the design files, making prototypes closer to the final product. This is particularly helpful during the creative process to educate designers on the probable nature of LLMs.</li><li>Use real LLM outputs in design prototypes to align with feasibility</li><li>Prototype your experience in an LLM, and link your figma prototype with the LLM. This allows you to demo or communicate your prototype alongside real-time LLM technology to your team and stakeholders.</li></ul><p>At this time there is a continuous evolution of plugins and tools that support LLM integration into design files that will further empower designers to create more sophisticated and accurate prototype experiences.</p><figure><img alt="A marketing image of the Figma GPT figma plugin. Large words reading “Figma GPT” and small text reading “A plugin that can talk with ChatGPT. You can easily copy and use the chat texts, and customize the response by adjusting the parameters. It’s up to you how you use it!”" src="https://cdn-images-1.medium.com/max/1024/1*LmqsD95JlchS028BmswXXg.png" /><figcaption>Figma GPT allows you to work with GPT directly in your Figma file. Designers can use the actual LLM outputs in their designs, and adjust prompt parameters within the plugin window.</figcaption></figure><h3>Incorporating Prompt Guidance in Prototypes</h3><h4>Why are designers needed for Prompt Guidance?</h4><p>The content of our LLM prompts directly influences the quality and relevance of the AI’s responses. Effective prompt guidance ensures that the AI generates outputs that are not only meaningful but also tailored to specific use cases. This involves crafting prompts that not only guide the AI accurately but also respect and anticipate the varied needs of our end users.</p><p>Collaboration on prompt engineering is still a developing practice at many organizations, but it’s clear that providing user-backed guidance is a part of the equation. Prompt guidance includes a collaboration of insights from design, data, and engineering teams.</p><h4>Strategies for Prompt Guidance in Prototypes</h4><p>The insights gained from users during the testing might not lead to changes in the UI but rather to how the AI should respond based on how we formulate prompts. One approach is to annotate prompt guidance directly within prototypes. For example, ensuring that responses from the AI are always displayed in bullet point format can be communicated in the Figma file. This ensures that the AI’s responses are aligned with what users find most helpful.</p><blockquote>Annotations within design prototypes serve as a visual to ensure that everyone involved in the design and development process understands how user insights are captured within the design, even if that is within the prompt.</blockquote><p>Annotating prompt guidance within Figma is an additional representation of prompt guidance from designers, as a more informative collaboration document will likely live outside of Figma prototypes to ensure prompt engineers have the artifacts that work best within their workflow.</p><h3>Bonus section: Beyond Prototyping — Adapting the Design Process for LLM Experiences</h3><p>The advent of LLMs in product design is not just an addition to our toolkit — it’s a paradigm shift that forces us to rethink how we create, collaborate, and connect during our design process. So I also wanted to explore various ways our design processes may evolve beyond prototyping to effectively integrate LLM experiences.</p><h4>1. Build to Test.</h4><p>One of the fundamental changes is the shift towards building prototypes that can quickly be turned into testable code, often referred to as ‘scrappy’ designs. This could also involve adding an engineering spike in the design process very early on. This approach allows for rapid iterations based on real user interactions and feedback, essential for refining LLM integrations.</p><p><strong>The reason behind this shift:</strong></p><ul><li><strong>Infinite inputs and outputs: </strong>LLMs generate outputs that are highly dependent on the inputs they receive, which can vary significantly. Designers must anticipate a broad range of potential user interactions, which is difficult to do within a single design cycle.</li><li><strong>Unpredictable Technology: </strong>Unlike more stable, predictable technologies, LLMs can behave in unexpected ways due to their complex, data-driven nature. This unpredictability necessitates frequent iterations and continuous testing to ensure that the LLM behaves as intended under various conditions.</li></ul><h4>2. A More Iterative Design Process</h4><p>The ongoing evolution of LLMs means that the products we design today may need to be adjusted tomorrow. This reality necessitates a more flexible, iterative approach to design:</p><ul><li><strong>Model Evolution: </strong>LLMs are continually updated with new data and improvements. Each update can alter how the model responds, which in turn may require changes to the user interface to ensure consistency and usability.</li><li><strong>Feedback Loop Implementation: </strong>Incorporating user feedback into the design process is crucial for refining LLM responses. This feedback is crucial for training the model, and insights gathered can lead to further design changes to better meet user needs.</li><li><strong>Evolving User Expectations: </strong>As users become more accustomed to interacting with LLMs, their expectations and interaction patterns will evolve. The design process must be adaptable to keep pace with these changes, ensuring that user interfaces remain intuitive and effective.</li><li><strong>Continuous Learning:</strong> Both users and designers are on a learning curve when it comes to understanding and utilizing LLM capabilities. This process uncovers new user needs and potential enhancements, which can feed back into the design process, fostering continuous improvement.</li></ul><figure><img alt="An infographic showing consecutive and repeated circles that read “Design, Develop, Test” there are 6 circles total that have the text inside saying “Iteration”" src="https://cdn-images-1.medium.com/max/1024/1*UIsckDy-QduTFY3Jqf_WAQ.png" /></figure><h3><strong>Conclusion: Embracing change in the LLM era</strong></h3><p>Prototyping an LLM experience presents a blend of challenges and exciting opportunities, as we learn and apply strategies to carry dynamic designs from ideation to launch. Staying flexible and centering our designs around users, while embracing even more iteration, allows designers to adapt quickly to the fast-moving requirements of this technological shift.</p><p>Adjusting our thinking and processes enables designers to maintain our influential role and ensure that our creations serve the users effectively. This focus keeps the user experience at the forefront of an LLM design. As LLM technology continues to evolve, our methodologies must also progress, ensuring that our designs remain effective and adhere to the fundamental values that define outstanding product design. By doing so, we can create experiences that not only meet current user expectations but are also primed for future demands.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5cjG3oQRgEdt0fC1AsuxLw.png" /></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1d613f97f504" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/tips-and-insights-prototyping-an-llm-experience-1d613f97f504">Tips and Insights —  Prototyping an LLM Experience</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>