<?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 Sumeet on Medium]]></title>
        <description><![CDATA[Stories by Sumeet on Medium]]></description>
        <link>https://medium.com/@sumeeeet?source=rss-44260e16fd53------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*oBGzPdnffI36R-AsBNLCLg.jpeg</url>
            <title>Stories by Sumeet on Medium</title>
            <link>https://medium.com/@sumeeeet?source=rss-44260e16fd53------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 11:09:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sumeeeet/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[A 3-Agent Chain That Turns Competitor Screenshots Into a UX Teardown That Doesn’t Hallucinate]]></title>
            <link>https://sumeeeet.medium.com/a-3-agent-chain-that-turns-competitor-screenshots-into-a-ux-teardown-that-doesnt-hallucinate-7cf53527689b?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/7cf53527689b</guid>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 09:54:14 GMT</pubDate>
            <atom:updated>2026-07-21T09:54:14.924Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YQfWI4XNcU4vqtzfN6V5Ww.png" /></figure><blockquote>A Researcher → Analyst → Writer agent chain that turns three competitor apps into a PM-ready teardown, with the handoff schema that keeps it from hallucinating.</blockquote><p>~9 min read. For product designers handed a competitive teardown of 2–4 SaaS apps due end of week. By the end you’ll have a Researcher → Analyst → Writer agent chain that produces a severity-ranked, PM-ready fix-list table, where every claim traces back to a captured observation you can point to in a design review.</p><h3>The teardown ChatGPT gives you is confidently wrong</h3><p>You paste three competitor screenshots into ChatGPT. You type: “Give me a competitive UX teardown of these three apps.” In thirty seconds you have a confident, structured, multi-page breakdown.</p><p>Here is what is wrong with it.</p><p>The severity ratings have no basis. “High priority” and “critical usability issue” appear next to observations the model assembled from pattern-matching. No rubric was applied. When a PM asks “why is this a severity 3?” you have no answer, because the model had no answer either.</p><p>The feature descriptions are invented. At least one thing in that list describes a feature the competitor does not ship. The model filled in what made sense given the context. It sounds plausible. Check it against the actual product and it falls apart.</p><p>The best practices are fabricated. “Competitor A uses progressive disclosure principles effectively throughout onboarding” is exactly the kind of sentence GPT-4 produces when asked for a teardown. It sounds analytical. It was confabulated in the render pass.</p><p>And there is no trace from claim to evidence. Which screen? Which element? Which state? The output is a floating set of opinions with nothing anchoring them to the actual screens you fed it. You cannot audit the teardown, reference it in a ticket, or defend it in a review.</p><p>The instinct at this point is to write a better prompt: more detailed instructions, a chain-of-thought nudge, a longer system prompt. Worth trying. It won’t fix it.</p><p>The failure is structural: you asked one model to simultaneously gather observations, apply heuristic logic, and write a PM-ready document. Those are three different cognitive modes. Conflating them is where hallucination enters, because the model forms severity judgments on observations it invented in the same pass.</p><p>The fix is splitting the job across three agents with a strict handoff contract between them. The deliverable you actually need is a fix-list table where every severity rating points back to a specific observation captured from the actual screens. That table is auditable, referenceable, and droppable into a Jira story. You get it from an agent chain with a structured contract between agents, not from a single prompt however carefully worded.</p><h3>Why three agents beat one mega-prompt for design analysis</h3><p>The direct objection: a single well-constructed prompt can produce a structured teardown without any multi-agent overhead. That objection is correct for small inputs. One screen, one competitor, one specific question: run one good prompt. The split does not earn its keep there.</p><p>It earns its keep at three or four competitors where context bleeds. By the time you’ve described App A’s onboarding, App B’s checkout flow, and App C’s dashboard in one prompt window, the model’s severity judgments on App C are contaminated by everything it has already said about Apps A and B. Invented comparisons appear. Observations conflate. The model is doing too many cognitive jobs at once in a degrading context window.</p><p>Designer and researcher Matteo Loglio, in his oio talk “Intelligence as a Material,” describes a three-agent chain he calls a “walk cast” built from a Creator, an Editor, and a Host. Each is a distinct system prompt. Each hands off to the next. The most important instruction in each agent, Loglio notes explicitly, is “what they should NOT do.”</p><p>That shape maps directly onto the teardown problem:</p><ul><li><strong>Researcher</strong> (= Creator): ingest screenshots, flows, and copy. Emit a structured observations file. No interpretation, no rating.</li><li><strong>Analyst</strong> (= Editor): apply heuristic logic, severity triage, cluster tensions. The opinionated pass. Works only from what the Researcher captured.</li><li><strong>Writer</strong> (= Host): render to PM-ready format. Formatting and tone only. No new analysis.</li></ul><p>Anthropic’s June 2025 write-up on their multi-agent research system puts the structural requirement precisely: each subagent needs “an objective, an output format, guidance on the tools and sources to use, and clear task boundaries.” Without all four, agents “duplicate work, miss information, or misinterpret assignments.” Their orchestrator-worker setup, with Claude Opus 4 leading Sonnet 4 subagents, outperformed a single Opus 4 agent by 90.2% on internal evaluation. The gain came from isolating what each agent is allowed to do, not from throwing more model intelligence at the problem.</p><h3>The handoff schema is the actual design artifact</h3><p>The prompts you write for each agent are not the design surface. The JSON schema each agent emits and the next agent consumes is the design surface.</p><p>Free-text handoffs are where the chain breaks. If the Researcher writes a narrative paragraph about what it observed, the Analyst reading that paragraph can rationalize severity ratings that were never grounded in real observations. Free text gives the Analyst too much latitude. A strict schema gives it none.</p><p>The Researcher emits this structure for every observation it captures:</p><pre>{<br>  &quot;competitor&quot;: &quot;AppName&quot;,<br>  &quot;screen&quot;: &quot;Onboarding / Step 2&quot;,<br>  &quot;observation_id&quot;: &quot;OBS-014&quot;,<br>  &quot;element&quot;: &quot;Primary CTA button&quot;,<br>  &quot;observation_text&quot;: &quot;Button label reads &#39;Continue&#39; with no indication of what happens next or how many steps remain.&quot;,<br>  &quot;evidence_ref&quot;: &quot;Screenshot_AppName_Onboarding_02.png&quot;<br>}</pre><p>Six fields. Every field is factual. The Researcher does not decide whether the observation matters. It does not assign severity. It captures what is there: the competitor, the screen, the specific element, what was observed, and the screenshot that proves it. The observation_id is the load-bearing field. Every downstream claim must anchor to one.</p><p>The Analyst reads the Researcher’s full observations file and extends each relevant record:</p><pre>{<br>  &quot;observation_id&quot;: &quot;OBS-014&quot;,<br>  &quot;heuristic&quot;: &quot;Match between system and real world&quot;,<br>  &quot;severity&quot;: 3,<br>  &quot;rationale&quot;: &quot;Users cannot estimate progress or anticipate the next step, increasing drop-off risk at a known abandonment point in onboarding.&quot;,<br>  &quot;cluster&quot;: &quot;Onboarding transparency&quot;<br>}</pre><p>Four additional fields. The schema enforces traceability mechanically: the Analyst cannot produce a severity rating without naming the observation_id it belongs to. There is no field for &quot;I also noticed...&quot; There is no free-text escape. Every severity-3 in the final teardown traces through observation_id to a specific element on a specific screen with a screenshot attached.</p><p>That’s what makes the teardown auditable. A fabricated claim has no observation_id to reference and nowhere to live in the schema. The contract does that enforcement work, not the prompts.</p><h3>AI prompt guardrails to stop hallucination in competitive analysis</h3><p>Each agent’s most important instruction is a prohibition.</p><p>This is Loglio’s explicit point. Agents are defined as much by “what they should NOT do” as by what they are supposed to do. It is also the thing every generic “AI for competitive analysis” article omits. Each prohibition in this chain kills a specific failure mode from the single-pass teardown.</p><p><strong>Researcher MUST NOT</strong> interpret, evaluate, or rate what it observes. No “this seems like a usability issue.” No implied priority. It records observable facts only. This guardrail kills ungrounded severity at the source. If the Researcher does not produce a severity judgment, the Analyst cannot inherit a hallucinated one.</p><p><strong>Analyst MUST NOT</strong> introduce any observation not already present in the Researcher’s output file. If it cannot point to an observation_id, the observation does not exist. This is the anti-hallucination guardrail for inherited errors, the single most common failure mode in free-text chains, where the Analyst &quot;recalls&quot; something the Researcher never captured. The Analyst is allowed to be opinionated on severity. Severity triage is inherently subjective. But that subjectivity operates only on verified raw material.</p><p><strong>Writer MUST NOT</strong> add new analysis. Formatting, language, table structure, tone: yes. New observations, new severity escalations, new “worth noting” additions: no. This guardrail kills fabricated best practices, which enter almost always in the final rendering pass, when the model tries to make the deliverable sound more comprehensive by adding editorial observations.</p><p>Each prohibition traces back to a named failure mode. These are not generic safety instructions. They are architectural decisions that eliminate known breakdowns.</p><p>Before you write a single system prompt for this chain, write the MUST-NOT list for each agent against your specific competitor set. What are the ways your Researcher might drift into analysis? What comparisons might your Analyst invent? What would your Writer add if you let it? The prohibitions are where the actual design thinking happens.</p><h3>Running it once: the output, and where it still breaks</h3><p>A real pass looks like this. Feed the Researcher three sets of screens from onboarding flows across three SaaS apps, roughly four to five screenshots each. Give it the JSON schema as its required output format and the MUST-NOT guardrail as its first system instruction. It produces an observations file: typically 30 to 50 records, each a factual, element-level capture.</p><p>A slice of the output:</p><pre>[<br>  {<br>    &quot;competitor&quot;: &quot;AppA&quot;,<br>    &quot;screen&quot;: &quot;Onboarding / Step 1&quot;,<br>    &quot;observation_id&quot;: &quot;OBS-001&quot;,<br>    &quot;element&quot;: &quot;Email field&quot;,<br>    &quot;observation_text&quot;: &quot;No inline validation. Error state only appears on form submit.&quot;,<br>    &quot;evidence_ref&quot;: &quot;AppA_Onboarding_01.png&quot;<br>  },<br>  {<br>    &quot;competitor&quot;: &quot;AppB&quot;,<br>    &quot;screen&quot;: &quot;Onboarding / Step 1&quot;,<br>    &quot;observation_id&quot;: &quot;OBS-002&quot;,<br>    &quot;element&quot;: &quot;Email field&quot;,<br>    &quot;observation_text&quot;: &quot;Inline validation fires on blur with a green checkmark confirmation.&quot;,<br>    &quot;evidence_ref&quot;: &quot;AppB_Onboarding_01.png&quot;<br>  }<br>]</pre><p>The Analyst reads the full file, applies heuristic logic, assigns severity 1 through 4, and clusters related observations. Severity 1 is cosmetic; severity 4 is a likely completion blocker. The Writer reads both files and renders a fix-list table: one row per severity-3 or severity-4 item, with columns for competitor, screen, issue summary, severity, heuristic, and the observation_id for traceability.</p><p>The table that comes out is the kind you drop straight into a ticket. What was an afternoon of review and manual synthesis, copying observations between tabs and debating priority with no audit trail, is a structured deliverable that already exists.</p><p>Analyst agent applying heuristics to Researcher output — every severity rating traces to an OBS ID ⬇</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*euIx37UNWtVb0M4jGrcswQ.png" /></figure><p>Now the honest part.</p><p>This chain uses roughly 15 times the tokens of a single chat session (Anthropic, June 2025). Agents alone run about 4 times a standard chat interaction; orchestration overhead pushes the total to 15 times. For a one-screen review that trade is bad. For a 3-to-4 competitor batch that would otherwise eat a half-day of work, the cost is negligible against the time saved and the defensibility of the output.</p><p>Non-determinism is real. Loglio flags it in the oio talk directly: the chain produces something “sometimes good, sometimes random.” The schema and guardrails reduce variance significantly because there is less room to wander when the output shape is rigid. They do not eliminate variance.</p><p>The mitigation is a verification pass, an eval in the AI engineering sense, a structured check that confirms the output satisfies the contract. Add it to your chain as a fourth step. It scans the Analyst’s output and confirms every severity field maps to a real observation_id in the Researcher&#39;s file. Any severity rating without a matching observation is an orphan. One pass of this caught a fabricated severity-3 that referenced an observation the Researcher had never made. The check takes seconds and is the layer that makes the deliverable trustworthy enough to hand over.</p><h3>A teardown you can defend in the review</h3><p>Speed is a side effect. The actual value is that every line in the fix-list table traces to a captured observation.</p><p>When a PM looks at your severity-3 on AppB’s onboarding flow and asks “where did this come from?”, you have a precise answer. It came from OBS-014, which captured the CTA label ambiguity on step 2, which has a screenshot attached. The severity was assigned by the Analyst against the “match between system and real world” heuristic. It was not invented in a render pass.</p><p>That traceability exists because the schema made it mandatory, not because the prompts were well-written. Every observation has an ID, every severity cites that ID, and every ID points back to a captured element on a named screen with a screenshot behind it.</p><p>The prompts are adjustable per project. The schema is the artifact worth keeping. Run this on a new competitor set two months from now and you’ll probably retune the prompts. The handoff contract stays the same.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7cf53527689b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From a Vague Icon Brief to One Ranked Winner: Batch Icon Directions With a Vision Model]]></title>
            <link>https://medium.com/design-bootcamp/from-a-vague-icon-brief-to-one-ranked-winner-batch-icon-directions-with-a-vision-model-7678dc860ff7?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/7678dc860ff7</guid>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[branding]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[icons]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Sun, 14 Jun 2026 12:14:10 GMT</pubDate>
            <atom:updated>2026-06-14T12:14:10.409Z</atom:updated>
            <content:encoded><![CDATA[<p>Use AI to Explore Icon Style Directions in an Afternoon ⬇</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*N6RO08871vLwueTIJyDfEA.png" /></figure><blockquote>Turn a vague icon brief into structured style specs, batch-generate a base set across directions, and triage to one ranked winner with a vision model.</blockquote><p><em>~10 min read. For product designers doing a design-system icon-set refresh or building a small cohesive icon family for a feature. By the end you’ll have a four-step AI chain that produces a ranked, scored direction shortlist: the kind you can take to a design review and defend, rather than a gut-feel choice made under deadline.</em></p><p>You have a vague brief: “explore a few directions for the icon set.” So you open Figma and start drawing. You pick two or three styles that feel plausible, rough them out by hand, and somewhere around the third style, the one where you’ve already sunk two hours, you realize you’re comparing a finished-feeling direction against a half-done sketch. The comparison is broken before it starts.</p><p>This is the ritual José Torre describes from the Shopify Polaris icon refresh. In his 2020 article “Uplifting Shopify Polaris,” he wrote that “for each style iteration, we designed dozens of icons, because we had to see them in context to find which performed the best.” Variants tried: 1.5px outline, duotone with 1px outline, 1px outline, 1.5px outline again, filled. Most discarded. The team needed to see the icons in context to decide. The only way forward was to make them. In volume.</p><p>That cost is no longer fixed. IconikAI generates 100+ icon variations in under 2 minutes. Recraft produces a 6-icon set in one click. The generation half of the exploration problem is already a commodity.</p><p>The part still done by hand is the deciding.</p><p>By the end of this article you’ll have a four-step AI chain that handles both halves: turn a vague brief into a set of structured, comparable style specs (LLM), batch-generate the same base icon set across every direction with consistency anchors (image model), triage the contact sheet with a vision-model rubric that scores and discards the weak directions, and hand the ranked survivor to Figma for manual refinement. The deliverable is a scored direction table. Not shippable SVGs, but a decision-ready ranked shortlist that didn’t cost you an afternoon of Figma work to produce.</p><h3>The part AI already solved — and the part it didn’t</h3><p>Generation is solved. The tools are real: IconikAI runs batch generation within a defined style system, Recraft lets you load a style reference and generate a set in one click. Both prove the cost-collapse is real.</p><p>The gap neither fills: none of them take a vague brief and produce multiple, <em>comparable</em> directions and then help you decide which one wins. IconikAI is a one-style-system pipeline. Recraft starts from a style you’ve already chosen. The exploration step, the part where you figure out <em>which direction to commit to</em>, still happens in Figma by hand.</p><p>In a talk on the design process, Torre identified the leverage flip: “the cook is exactly what AI is optimizing for, so it’s coming for you first.” The cook does the volume work: drawing the 100th throwaway icon to see how a style reads in context. The chef decides. The gap in the tool landscape is that tools handle neither the cook’s volume work <em>across directions</em> nor the triage that follows it. They pick up after the chef has already chosen a style.</p><p>This is the four-step chain that fills the gap:</p><ol><li><strong>Structured style spec:</strong> LLM turns the vague brief into one explicit spec per candidate direction (grid / stroke / radius / fill / metaphor language as locked parameters)</li><li><strong>Consistency-anchored batch generation:</strong> image model generates the same base icon set across all directions using four consistency anchors that prevent drift</li><li><strong>Vision-model rubric triage:</strong> vision model scores each direction contact sheet on four dimensions and outputs a ranked discard table</li><li><strong>Hand the winner to Figma:</strong> manual refinement of the surviving direction on-grid</li></ol><p>The featured-snippet version of this workflow: a structured style spec per direction makes directions comparable; a grid-in-one-image generation trick keeps them consistent; a vision-model rubric pass discards the directions with clear structural failures so your judgment lands on 1–2 survivors.</p><h3>Step 1 — Turn the vague brief into a structured style spec</h3><p>The consistency failure mode of naive AI icon generation is not that models produce bad icons. It’s that each generation prompt drifts. Stroke weight wanders. Perspective shifts. Padding contracts. You end up comparing noise, not design decisions.</p><p>The fix is a structured style spec: a locked set of explicit parameters that every generation prompt inherits. Think of it as design tokens for the exploration phase: you set the values once per direction, and the generation prompts read from them.</p><p>The parameters that matter, and why each one matters at 16/20/24px:</p><ul><li><strong>Grid</strong> — Standard value: 24x24px, 2px padding (20x20 live area); Why it matters at small sizes: Divisible by 2/4/8/12 for crisp scaling; the standard per designsystems.com</li><li><strong>Stroke weight</strong> — Standard value: 2px (standard); 1.5px if the direction calls for it; Why it matters at small sizes: Mixing stroke weights “destroys cohesion instantly” (DEV Community, Albert Nahas, 2025)</li><li><strong>Corner radius</strong> — Standard value: 2px, scaled by multiples of two; Why it matters at small sizes: Keeps metaphor legible without rounding into ambiguity</li><li><strong>Fill style</strong> — Standard value: Outline / filled / duotone (pick one per direction); Why it matters at small sizes: Filled reads better in navigation at 16px; outline at 24px+</li><li><strong>Perspective</strong> — Standard value: Flat 2D, no gradients, no shadows; Why it matters at small sizes: Gradients collapse at 16px; flat reads at every size</li><li><strong>Metaphor language</strong> — Standard value: “a settings gear with visible teeth, no nested elements”; Why it matters at small sizes: Forces you to commit to the concept before generating</li></ul><p>Write one spec per candidate direction. If you’re exploring three directions, you write three specs. The discipline of writing the spec is the whole game. It forces a real decision about what each direction <em>is</em> before you generate a single icon.</p><p>Here is a prompt structure for the LLM spec-writing step:</p><pre>You are a design systems consultant. I am exploring icon style directions for a product design system.</pre><pre>Brief: [paste your vague brief here]</pre><pre>For each of [N] distinct candidate directions, produce a structured style spec with these exact fields:<br>- Direction name (e.g., &quot;Minimal Outline&quot;, &quot;Soft Filled&quot;, &quot;Technical Line&quot;)<br>- Grid: [24x24px, Xpx padding, Ypx live area]<br>- Stroke weight: [value in px]<br>- Corner radius: [value in px]<br>- Fill style: [outline / filled / duotone]<br>- Perspective: [flat 2D / isometric / etc.]<br>- Metaphor language: [how to describe each icon concept — one sentence per icon in the base set]<br>- Distinguishing character: [one sentence — what makes this direction feel different from the others]</pre><pre>The directions must be genuinely distinct from each other. Minimal overlap. Format as a numbered list of specs.</pre><p>The LLM output is your specs table. Each spec is a contract that the generation step must honor.</p><h3>Step 2 — Batch-generate the same base set across every direction</h3><p>The contact sheet is the exploration artifact every direction-comparison was gated on. With specs locked, you can now produce one.</p><p>The failure mode here is per-prompt drift: if you generate each icon in a separate prompt, stroke weight shifts between calls, perspective wanders, and you’ve produced five sets that aren’t comparable. This is why the four consistency anchors must work together. Each anchor alone fails; the combination holds.</p><p><strong>Anchor 1: Fixed grid in every prompt.</strong> Every generation prompt restates the full spec: “24x24px grid, 2px stroke, 2px corner radius, flat 2D, no gradients, no shadows.” Not shortened, not implied. Stated verbatim each time.</p><p><strong>Anchor 2: Shared keyword anchors.</strong> Identify 3–5 style keywords that all icons in a direction must carry. “Geometric, precise, terminal-rounded” for one direction. “Organic, slightly irregular, friendly” for another. These words appear in every prompt for that direction, keeping the model’s style register consistent across the set.</p><p><strong>Anchor 3: Base-icon reference.</strong> Generate the simplest, most neutral icon in your base set first (typically a settings gear or a home icon). Use that output as a visual reference image in subsequent prompts: “Generate the following icons in the exact same style as this reference image.”</p><p><strong>Anchor 4: Grid-in-one-image.</strong> This is the most reliable consistency trick available in current image models, documented by Christy Tucker in “How to Generate Icon Sets with AI” (2025). Generate all icons for a direction in a single image, a grid of icons on one canvas, then split the grid after. When the model renders everything in one pass, it holds style across the set more reliably than it can across separate calls.</p><p>Claude scoring three icon contact sheets on four rubric dimensions and outputting a ranked Keep / Discard table. ⬇</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DpV78eOPh-f2hmmVuHElOg.png" /></figure><p>The generation prompt structure for the grid-in-one-image approach:</p><pre>Generate a 3x3 grid of icons on a white background. Each icon occupies a 24x24px cell with 2px padding (20x20 live area). All icons share these style properties:</pre><pre>Style: [direction name]<br>Stroke: 2px, rounded caps and joins<br>Corner radius: 2px<br>Perspective: flat 2D<br>No gradients. No shadows. No decorative fills.<br>Keywords: [your shared keyword anchors for this direction]</pre><pre>Icons (one per cell, left to right):<br>1. Settings — a gear with [N] visible teeth, no nested elements<br>2. Home — simple house silhouette with a peaked roof<br>3. Search — circle with a handle extending to the lower right<br>[continue for your full base set]</pre><pre>Match the style reference image exactly. [attach your base-icon reference]</pre><p>Run this prompt once per direction. The output is one contact sheet per direction, comparable because they all inherit the same base set and the same grid.</p><h3>Step 3 — Score and triage the directions with a vision-model rubric</h3><p>This is the step no existing tutorial covers. Christy Tucker’s 2025 guide on generating icon sets explicitly stops before scoring or triaging directions. Every tool landing page stops at generation. This is where the chef-vs-cook inversion earns its keep: you now have five contact sheets and a decision to make, and you need to make it without spending three hours staring at them.</p><p>A vision-model rubric pass is severity triage, not a verdict. The model does not pick your direction. It filters the field. It discards the directions with obvious structural problems so your judgment lands on the 1–2 survivors that actually deserve scrutiny. Think of it as a first-pass eval run, the kind a QA team uses to separate the clearly-broken from the probably-fine before a human reviews.</p><p>The four rubric dimensions:</p><ol><li><strong>Brand fit:</strong> Does the visual character match the brand personality words in your brief? (e.g., “technical and precise” vs. “warm and approachable”) Score 1–5.</li><li><strong>Internal consistency:</strong> Do all icons in the set look like they belong to the same system? Flag any icon where stroke weight, corner radius, or fill style visibly deviates. Score 1–5.</li><li><strong>A11y legibility at small sizes:</strong> Does the metaphor read at approximately 16–20px equivalent? Are the distinguishing shapes clear, or do they collapse into blobs? Score 1–5.</li><li><strong>Metaphor clarity:</strong> Would a user unfamiliar with the UI recognize what each icon represents? Flag any icon where the concept is ambiguous. Score 1–5.</li></ol><p>Rubric-based prompting, as Adsroid documented in 2025, “sets explicit criteria for AI responses, reducing errors and improving factual accuracy.” The guidance: validate the rubric by having multiple evaluators (or multiple model calls) rate the same contact sheets, then tighten any dimension where scores diverge before scaling. For icon triage, this means running the scoring prompt twice on each contact sheet and comparing scores. If a direction scores differently between runs, that rubric dimension needs sharper language.</p><p>The scoring prompt:</p><pre>You are a design systems reviewer evaluating icon style directions for a product design system.</pre><pre>Score the attached contact sheet on these four dimensions. Each dimension: 1 (poor) to 5 (strong). After scoring, write one sentence of severity triage per dimension — note what specifically failed, not just that it failed.</pre><pre>Rubric:<br>1. Brand fit — [paste your brand personality words from the brief]<br>2. Internal consistency — all icons in the set share the same stroke weight, corner radius, and fill style<br>3. A11y legibility at 16–20px — metaphor reads at small sizes; shapes do not collapse<br>4. Metaphor clarity — concept is recognizable without UI context</pre><pre>Output format:<br>| Dimension | Score (1–5) | Severity note |<br>|---|---|---|<br>| Brand fit | | |<br>| Internal consistency | | |<br>| A11y legibility | | |<br>| Metaphor clarity | | |</pre><pre>Overall direction verdict: Keep / Discard / Investigate further<br>One-sentence rationale for the verdict.</pre><p>Run this prompt once per contact sheet. The output is a ranked table across all directions. Directions that score Keep on all four dimensions advance. Directions that score Discard on any dimension with a severity note of “significant” get cut without further review.</p><p>What used to mean staring at five contact sheets until one felt right becomes a table you can read in five minutes and drop into a design review.</p><h3>Step 4 — Hand the winner to Figma (and where AI stops)</h3><p>The triage output is a ranked shortlist, not shippable SVGs. This is the boundary the workflow is designed to hold.</p><p>AI-generated icons are raster artifacts produced by image models that have no concept of vector paths, grid snapping, or optical size adjustments. They are evidence of a direction, not production assets. Christy Tucker’s 2025 guide notes three generation paths (Midjourney, Nano Banana / ChatGPT grid-split, Brushless for vector output), but even the vector output paths require manual cleanup. The Polaris team ultimately chose 1.5px outline with filled variants for navigation, a decision that required rendering dozens of icons in actual UI contexts to validate. That validation step still belongs to Figma.</p><p>What the AI chain produced: a direction call made on structured evidence rather than attachment. The designer who drew 2–3 styles by hand before comparison already has a favorite, and the comparison is biased. The designer who runs this chain has a scored table and can defend the choice.</p><p>The handoff is the same move Torre describes, but executed in hours instead of days: take the surviving direction, open Figma, build the first 8–10 icons on-grid by hand using the spec parameters from Step 1 as the constraint set. The spec you wrote to lock AI generation is also the spec you work against in Figma: stroke weight, corner radius, live area, fill style, all the same values.</p><p>Two objections come up here, and both target the wrong phase.</p><p>“A vision model can’t judge brand fit.” It doesn’t need to judge it the way a designer would. It needs to flag the directions that fail the brand criteria in the brief so you don’t spend two hours on them. That’s severity triage, not a hiring decision.</p><p>“AI icons aren’t production-ready.” Correct. The workflow never claimed otherwise. The contact sheet is a direction signal, not a deliverable. The designer rebuilds the winner on-grid.</p><p>This is the chef-vs-cook inversion Torre flagged but never resolved: AI does the cook’s grunt work, the 100th throwaway icon, the contact-sheet assembly across five directions, the first-pass scoring pass. The designer stays the chef who makes the call.</p><p>The cost of throwaway exploration has collapsed. What hasn’t changed is that the direction call still requires a human who understands the brand, the product context, and the use cases the icon set will live in. The bottleneck moved from making to choosing, and choosing is exactly where a designer’s judgment should have been concentrated all along.</p><p>One exercise before you run the chain: take your next icon brief and write two style specs by hand using the Step 1 parameter table, before you generate anything. Grid, stroke, radius, fill, metaphor language. Write them out. You’ll notice the brief forces you to make design decisions you were planning to defer until you could “see” the icons. That forcing function is not a side effect of the workflow. It is the workflow. The spec is the whole game.</p><p>The chain turns that discipline into a repeatable process, one you can run on any icon brief, any direction count, any level of brief vagueness.</p><p>I’m packaging the full kit from this workflow: the LLM spec-writing prompt template, the consistency-anchored batch-generation prompts with all four anchors pre-built, and the vision-model triage rubric with the scoring prompt that outputs the ranked table. Everything you’d need to run this chain on your next icon brief without rebuilding it from scratch.</p><p>[Join the list] and I’ll send it when it’s ready.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7678dc860ff7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/from-a-vague-icon-brief-to-one-ranked-winner-batch-icon-directions-with-a-vision-model-7678dc860ff7">From a Vague Icon Brief to One Ranked Winner: Batch Icon Directions With a Vision Model</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[The Rigid Design Process Is Dead: Run This 3-Day Solution-First AI Sprint Instead]]></title>
            <link>https://sumeeeet.medium.com/the-rigid-design-process-is-dead-run-this-3-day-solution-first-ai-sprint-instead-2ee840e353e8?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/2ee840e353e8</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ai-development]]></category>
            <category><![CDATA[design-sprint]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Sun, 14 Jun 2026 10:57:38 GMT</pubDate>
            <atom:updated>2026-06-14T10:57:38.808Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>Jenny Wen says the rigid design process is dead. She’s right. But the fix isn’t winging it on intuition. It’s a faster, solution-first sprint you run with AI. Here’s the whole loop.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sxlVg8t59UCbo7ha1GyTwA.png" /></figure><p><em>~9 min read. For product designers who’ve run a Google Ventures-style sprint and feel it’s too slow now that PMs vibe-code prototypes mid-meeting. By the end you’ll have run a 3-day sprint on one real feature and walked away with a craft teardown, five solution directions narrowed to one, an intuition brief built from your own feedback, and a prototype plus two reaction artifacts that test desirability before you build a single screen. Every prompt is copy-paste.</em></p><p>You opened a fresh sprint on Monday. You knew the steps. Map the problem space, build the persona with the generated headshot and the fake name, draw the journey map, write the “How might we.” You were maybe two sticky notes into the problem statement when a PM dropped a working prototype into the channel. Vibe-coded over lunch. No persona, no journey map, no research. It already did roughly the thing you were still trying to frame.</p><p>That is the moment the old sprint stopped making sense. The Google Ventures sprint is problem-first, and it front-loads two full days of research artifacts: the persona, the map, the problem statement. In a shop where a prototype costs an afternoon, problem-first is backwards. You spend Monday and Tuesday producing documents that the end user, as Jenny Wen put it in her talk on why the design process is dead, “doesn’t give a damn about,” while someone else has already shown the team what the answer might look like. And the whole thing takes five days. At a startup, five days is a quarter.</p><p>So Wen’s diagnosis is right: the rigid process is dead. But the conclusion most people draw from it, “trust yourself, stop following steps,” is the wrong fix. A designer who throws out the process and runs on pure feel produces work that’s brilliant on Tuesday and incoherent on Thursday. “Don’t trust the process” is not “have no process.” It’s “replace the slow one with a faster one you actually control.” This article is that faster one: a solution-first, AI-run sprint compressed to three days. By the end you’ll have produced four things for one real feature you’re working on right now. A severity-ranked craft teardown of a best-in-class competitor. Five solution directions, narrowed to one. A one-page intuition brief synthesized from your own user feedback. And a prototype plus two reaction artifacts that tell you whether to build before you’ve drawn a screen.</p><h3>Why the 5-day design sprint breaks in an AI shop</h3><p>Be precise about how the classic sprint fails now, because each failure maps to a step that fixes it.</p><p><strong>It’s problem-first when prototypes are nearly free.</strong> The whole sprint is built on the assumption that getting to a testable solution is expensive, so you’d better define the problem rigorously before you spend the money. That assumption is gone. Wen’s clearest example is Claude Artifacts, the interactive right-hand panel that shows generated code as it runs. It didn’t come from a problem statement. A researcher built a prototype, a designer saw it and iterated, the team reacted to it, and only then did anyone realize it was a problem worth solving. The solution revealed the problem, not the other way around. When that’s possible, leading with a problem statement is leaving your fastest path on the table.</p><p><strong>The front half is research theater.</strong> Personas with stock photos, journey maps with color-coded emotional arcs. These are process artifacts, and Wen’s point about portfolios applies to sprints too: people spend their effort on the artifacts and almost none on the one screen at the end that the user actually touches. The map is for the team’s comfort, not the product.</p><p><strong>Five calendar days is too slow for the divergence it produces.</strong> The Tuesday sketching session exists to generate options. A model generates a wider spread of options in ten minutes than a room of three people generates in a day. The expensive part of divergence got cheap, but the sprint still budgets two days for it.</p><p>The fix is not to abandon structure. It’s to re-sequence it. Put the solution first, let AI carry the divergence and the synthesis, and compress to three days. Here’s the loop.</p><h3>Day 1: Generate five solution directions before you write a problem statement</h3><p>This is the inversion, and it’s the part that feels illegal if you were trained on the double diamond.</p><p>Start from the capability, not the problem. The question isn’t “what does the user need.” It’s “what can the tool now do that it couldn’t six months ago, and what old, half-abandoned problem does that quietly solve?” Wen described this as the loop her team runs every time a model gets better: a new capability shows up, and they look backward at the pile of problems they’d shelved and ask which ones are now solvable in a different way. Claude’s research feature, which goes off for ten or twenty minutes and writes a full report, came from exactly that: the capability for long multi-step reasoning arrived, and the team looked back for a problem shaped like it.</p><p>You can run the same move on your own feature. Here’s the first prompt.</p><pre>You are a senior product designer helping me run a solution-first<br>design sprint. We are NOT starting from a problem statement.</pre><pre>CONTEXT:<br>- Product area: [e.g. our team&#39;s project dashboard]<br>- Capability I now have access to: [e.g. an LLM that can summarize<br>  and cluster freeform text reliably]<br>- Constraints: [platform, timeline, anything fixed]</pre><pre>Generate 5 distinct solution directions for this area, one in each<br>category:<br>1. Safe (an obvious, low-risk improvement)<br>2. Workflow-shift (changes how the user sequences their work)<br>3. Agentic (the product does multi-step work on the user&#39;s behalf)<br>4. Wildcard (something most teams would call too weird to ship)<br>5. Contrarian (does the opposite of the category norm)</pre><pre>For each: a 2-sentence description, and a one-line &quot;why someone would<br>say wow&quot; the first time they see it.</pre><p>You’ll get five directions to react to. Now do the thing the old process forbade: react, don’t analyze. Don’t build a scoring spreadsheet yet. Read the five and notice which one makes you say “wow” before you can justify why. That gut pull is the divergence paying off. Pick it, then write one sentence explaining the reason it pulled you. That sentence is your problem statement, written last instead of first. Problem-last is the whole trick.</p><p>Then set the craft bar. Wen praises Linear, Notion Calendar, and the Not Boring apps as the “anti-AI-slop” standard: things that feel hand-built and worth paying for. She never says how to extract that standard and apply it. This prompt does. Severity triage here means rating each gap by how badly it undercuts the feel of the product, so you fix the ones that matter first.</p><pre>I&#39;m going to paste descriptions (or screenshots) of [best-in-class<br>competitor, e.g. Linear] and a description of my current design.</pre><pre>First, extract the specific craft moves that make the competitor<br>feel high-quality. Be concrete: interaction affordances, motion and<br>timing, microcopy, empty states, density, keyboard support. Not<br>&quot;clean UI.&quot; Name the actual moves.</pre><pre>Then compare my current design against each move and output a table:<br>| Craft move | Their version | Mine | Severity (2-4) | Fix |<br>Severity 4 = badly undercuts the feel, 2 = minor polish.<br>Sort highest severity first.</pre><p>By the end of Day 1 you have five directions, one chosen by reaction, a problem statement written backward from it, and a ranked table of exactly where your craft falls short of the bar you’re aiming at.</p><p>Day 1 craft teardown: a severity-ranked table comparing your design against a best-in-class competitor ⬇</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*HfxlyGL8_Oujr-k_Pvm9FA.png" /></figure><h3>Day 2: Build an intuition brief from your own feedback, then prototype</h3><p>Wen’s defense of intuition is the most useful and least actionable part of her talk. “Intuition is not guessing,” she says. It’s the ability to make a reasoned judgment fast because you’ve built an internal model of your users from feedback, research sessions, dashboards, and the principles you learned in school. She lists every input. She never says how to turn the pile of inputs into the model. That synthesis is the AI step.</p><p>Spend the first half of Day 2 assembling the corpus. Half an hour of copy-paste: recent app-store reviews, the Twitter and Reddit threads where people complain about your product, a handful of support tickets, notes from the last two sales calls, the highlights from last quarter’s research. Messy and unsorted is fine. Then synthesize it.</p><pre>Below is raw, unsorted feedback about my product from reviews, social,<br>support tickets, and sales calls. Build me a one-page intuition brief:</pre><pre>1. Top 5 recurring user beliefs or frustrations (rank by how often<br>   they appear; give the rough count behind each)<br>2. 3 unmet jobs users are hiring the product to do<br>3. 2 things users clearly love (so I don&#39;t break them)<br>4. The cognitive biases or mental models shaping how they react</pre><pre>Mark any item LOW CONFIDENCE if it shows up fewer than 3 times.<br>Do not invent patterns to fill a category. If the data isn&#39;t there,<br>say so.</pre><pre>FEEDBACK:<br>[paste]</pre><p>The “internal model” you get back is the thing you can defend a decision against without re-running research for every button placement. One caveat worth knowing before you trust it: the model will over-index on the loudest voices and, given a thin corpus, will happily invent a pattern that isn’t there. That’s why the prompt forces a count behind each theme and a low-confidence flag. Read the flagged items as hypotheses, not findings.</p><p>Now prototype the direction you chose on Day 1, judged against the brief. You don’t hand this off. Designers can build now. Drop the direction into Claude Artifacts, v0, or Lovable and get something clickable in an hour. Keep it scrappy. The prototype is the spec, and a rough interactive thing teaches you more than a pixel-perfect static frame ever did. By the end of Day 2 you have a defensible one-page brief and a working prototype of your chosen direction.</p><h3>Day 3: Pressure-test desirability with two reaction artifacts</h3><p>Amazon’s working-backwards method has you write the press release before you build. Wen found it static and not relevant to Figma, so she rewrote it: instead of a press release, imagine the tweet a user would post about the feature. She built a brainstorm component around it and used it for FigJam features like cursor chat and stamps, and when those shipped, real tweets resembled the imagined ones. She describes the exercise. She doesn’t hand you the template. Here it is.</p><pre>Here&#39;s the prototype I built: [describe the feature and the flow].<br>My user is: [specific segment, e.g. an eng manager who lives in Linear].</pre><pre>Write 6 tweets this exact user would post if this shipped:<br>- 3 delighted (in their real voice, specific about what won them over)<br>- 3 disappointed (specific about what let them down)</pre><pre>Make them sound like real tweets, not marketing copy.</pre><p>Read the delighted three. If none of them makes you grin, the direction is weaker than your Day-1 gut said. Read the disappointed three. If none names a risk you recognize, the model is being polite and you should push it harder. The second artifact tests whether the value is legible in a single line.</p><pre>Write 3 landing-page headline + subhead pairs that sell this feature.<br>For each pair, name the one objection a skeptical user would have<br>reading it.</pre><pre>If the strongest headline still sounds generic and could describe<br>any competitor, tell me plainly: the concept isn&#39;t differentiated yet.</pre><p>If you can’t get a headline that isn’t interchangeable with a competitor’s, the concept doesn’t have a sharp enough edge, and that’s worth knowing on Day 3 rather than after the build. These two artifacts test desirability and legibility cheaply and early. They don’t replace real usability testing. That still happens, later, on the prototype, with actual users. What they do is tell you whether the direction deserves to reach that stage before you’ve spent the week. By the end of Day 3 you either green-light the build or you’ve killed the direction for a specific, nameable reason.</p><h3>The thinking exercise: run the inversion on the feature you’re avoiding</h3><p>Pick the one feature you’ve been stuck on, the one where you keep failing to write a clean problem statement. That block is usually a sign you’re problem-first on something that wants to be solution-first.</p><p>Skip the statement entirely. Run the Day-1 prompt on it: name the capability you have, ask for five solution directions, one per category. Read them and notice which makes you say “wow” before you’ve justified it. Then, and only then, write the sentence explaining why. You just produced a problem statement by working backward from a solution, in about fifteen minutes, on a feature that had stalled for weeks. That reversal, done on one feature, is the entire method in miniature. The scaffold is real and repeatable. It just runs in the other direction.</p><h3>What actually replaced the process</h3><p>The PM who dropped a prototype into the channel on Monday wasn’t skipping the process. They were running a faster one and hadn’t named it. That’s the part Wen’s “trust yourself” leaves implicit: trusting yourself only works if there’s a method under the self. Pure intuition with no scaffold is just confidence, and confidence ships incoherent products.</p><p>The four artifacts you produced are the proof that you didn’t abandon process. You replaced it. Solutions came before the problem statement. Intuition got synthesized from real feedback instead of guessed. Desirability got tested before the build instead of hoped for after it. Three days, not five. That’s not the absence of a sprint. It’s the sprint redrawn for the tools you actually have.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2ee840e353e8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Cursor Rules File Intercom’s Designers Use to Ship Code Without Breaking Things]]></title>
            <link>https://medium.com/design-bootcamp/the-cursor-rules-file-intercoms-designers-use-to-ship-code-without-breaking-things-d3edb74c0e4a?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/d3edb74c0e4a</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[cursor]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Wed, 10 Jun 2026 22:53:32 GMT</pubDate>
            <atom:updated>2026-06-10T22:53:32.338Z</atom:updated>
            <content:encoded><![CDATA[<p>The Cursor Rules File That Lets Designers Ship Code Safely ⬇</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*czWKgVhi-pV5Da8tpJDAWw.png" /></figure><blockquote>The non-destructive guardrail file Intercom’s designers used, but never showed you.</blockquote><p>~9 min read. For product designers with access to a company frontend repo who want to ship one safe production frontend fix this week using Cursor. No engineering background assumed. By the end you’ll have a committed .cursor/rules file you can paste today, a rule for scoping your first change so the file can actually protect you, and a PR template engineering can approve in two minutes.</p><p>You watched the Intercom talk, or a clip of it. Emmet Connolly gets up and says that every one of their roughly 30 product designers shipped a production pull request in one quarter, against his own prediction of “maybe two or three.” The word Cursor comes up. The phrase “non-destructive guardrails” comes up. A designer named Ellie gets a mention for writing a rules file that told the AI not to wander into the backend. Then the talk moves on.</p><p>So you open Cursor on the real product repo. You type something like: “the spacing on this card is wrong, fix it.” The agent processes for a few seconds, then starts generating. You watch the diff. It has touched a route handler. Then an API helper. Now it’s proposing a change to an auth utility you have never opened.</p><p>That is not a spacing fix. That is the agent doing what agents do when nobody told them not to: treating the entire codebase as fair game.</p><p>The talk showed you the result and withheld the one thing that produced it. By the end of this article you’ll have three concrete outputs: the .cursor/rules file with the actual non-destructive guardrails (paste it today), a first-change scoping rule for picking the right edit to start with, and a PR-handoff template your engineer can review in under two minutes.</p><h3>Why “Just Be Careful in Cursor” Breaks on a Real Product Repo</h3><p>The naive approach is to open the repo, describe the change you want, and trust that the word “just” will contain the agent. “Just fix the spacing.” “Just change this color.” The problem is that “just” is a human concept the model does not hold.</p><p>A real product codebase is a graph. Components import hooks. Hooks call API functions. API functions reference environment variables and authentication middleware. When you ask the agent to change something visual, it follows that graph in both directions. Sometimes because it thinks it is being helpful (fixing related issues it noticed), sometimes because it genuinely cannot tell where the UI ends and the logic begins without being explicitly told.</p><p>The blast radius (the surface of code the agent is willing to touch in a single session) is the whole repo by default. Routes, handlers, database migrations, .env references, auth layers. None of these are labeled &quot;off limits&quot; unless you label them.</p><p>Cursor is working as intended. An engineering agent with no constraints does exactly this. Engineers writing their own cursor rules files restrict the agent’s scope all the time. The gap is that most published designer-focused Cursor content assumes guardrails are something you say in a prompt each time. And that is exactly where the approach leaks.</p><h3>The Prompt-by-Prompt Fix Everyone Teaches, and Why It Leaks</h3><p>Builder.io’s “Cursor for Designers” tutorial series addresses this directly and correctly. The recommended approach is three prompt patterns you add to your request: “keep logic intact,” “minimal diff,” “reuse existing components and tokens.” They also document recovery prompts for when the agent over-reaches: “Undo the refactor: apply only minimal visual changes.”</p><p>These prompts work. The problem is that they are per-message and forgettable.</p><p>A Cursor session has a context window. When that window resets (when you start a new chat, when the session gets long, when you switch tasks) the guardrails you pasted at the start of the conversation are gone. You have to remember to paste them again. Then again. Then again after your next break.</p><p>Vigilance is not a workflow. It fails under deadline pressure, which is exactly when you most need the guardrails to hold.</p><p>The durable version of Builder.io’s three prompts is a committed .cursor/rules file that applies on every turn, survives context resets, and travels with the repo. You write the guardrails once. Every Cursor session in that repo picks them up automatically. The agent sees them before it sees your first message.</p><h3>The File: A Non-Destructive .cursor/rules for Designers (Paste This)</h3><p>One format note before the file: .cursorrules (a single file at the repo root) is the legacy format and still works in most Cursor versions. The current format is a .cursor/rules/ directory containing .mdc files with YAML frontmatter. The spencergoldade/cursor-designer project on GitHub (2025) confirms the directory format and the frontmatter fields. Use the directory format: it is what Cursor&#39;s settings UI now reads, and it is what the frontmatter below targets. AGENTS.md is a separate convention for OpenAI&#39;s Codex agent; it is not the same thing and does not apply here.</p><p>Create the file at .cursor/rules/designer-safe.mdc in the repo root. Commit it.</p><pre>---<br>description: Non-destructive guardrails for designer-authored frontend changes. Prevents AI from touching backend, API, auth, or logic layers.<br>globs: [&quot;**/*.tsx&quot;, &quot;**/*.ts&quot;, &quot;**/*.css&quot;, &quot;**/*.scss&quot;, &quot;**/*.module.css&quot;]<br>alwaysApply: true<br>---</pre><pre># Designer safety rules</pre><pre>You are helping a product designer make a specific, scoped frontend change.<br>Your job is to make exactly the visual change described — nothing more.</pre><pre>## What you may touch<br>- React component files (*.tsx, *.jsx)<br>- Stylesheet files (*.css, *.scss, *.module.css, tailwind classes inline)<br>- Static copy and microcopy strings inside component files<br>- Design tokens as already defined in the codebase (do not invent new ones)</pre><pre>## What you must not touch<br>- Route definitions or route handlers (any file in /routes/, /pages/api/, /api/, /server/)<br>- Database queries, ORM calls, migrations<br>- Authentication and authorization files (auth/, middleware/, session/)<br>- Environment variable references (.env, process.env)<br>- API client files or fetch/axios call definitions<br>- Global state management files (store/, context/ — unless the change is purely display logic)<br>- Package.json — do not add or remove dependencies</pre><pre>## How you must make changes<br>- Minimal diff: change only the lines required to produce the described visual output<br>- Reuse existing components — do not create new ones unless the task explicitly requires it<br>- Reuse existing design tokens — do not introduce new color values, spacing values, or font sizes<br>- If you cannot make the described change without touching a restricted file, stop and explain why instead of proceeding</pre><pre>## After every change<br>List two things:<br>1. What you changed (file name, line range, and what it does)<br>2. What you deliberately left untouched that was adjacent to the change (and why)</pre><pre>This second list is required. It is how the designer verifies scope and writes the PR description.</pre><p>The alwaysApply: true frontmatter is what makes this apply to every Cursor session in the repo without the designer having to invoke it. The globs field scopes it to frontend file types. The forbidden-path list covers the five layers that cause real damage: routes, database, auth, environment, and API. The final instruction (list what you changed AND what you left untouched) is what makes the PR description write itself.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oSTM1W35Oy893BOewchieQ.png" /></figure><p>The agent’s required post-change summary: what it touched, what it didn’t — and why. This becomes your PR description. ⬇</p><h3>The File Is Layer One, Not a Sandbox</h3><p>Cursor rules are guidance, not enforcement. The model reads them and weighs them against your prompt and the codebase context. In practice, a well-written rules file meaningfully reduces the probability that the agent touches restricted files. It does not reduce it to zero.</p><p>A smart skeptic will point this out. They are correct.</p><p>The honest answer is that safety here is a four-layer stack, not a single artifact:</p><p><strong>Layer 1: The committed rules file.</strong> Reduces the blast radius probabilistically before the session starts. The file’s job is to make the other three layers cheap. Not to replace them.</p><p><strong>Layer 2: A scoped prompt.</strong> Even with the rules file active, be specific about what you are changing and why. “Change the padding on the &lt;ProductCard&gt; component from 16px to 24px to match the updated spacing scale&quot; gives the agent less room to interpret than &quot;fix the card layout.&quot; The scoped prompt is the rules file&#39;s second line of defense.</p><p><strong>Layer 3: Reading the diff.</strong> Before you accept any change, read the diff. This is non-negotiable. You do not need to understand every line of TypeScript. You need to check that the changed files are all on the allowed list from the rules file. If .cursor/rules/designer-safe.mdc says do not touch /api/, and the diff contains a file in /api/, reject the change and restart with a narrower prompt. The diff review is the only thing that catches a rules violation before it becomes a commit.</p><p><strong>Layer 4: The engineer PR gate.</strong> Intercom’s practice (confirmed in Connolly’s 2025 talk and the Intercom blog) is that designers ship to production after an engineer approves a quick code review, not direct-merge. Builder.io’s 2025 guide argues the same point: designers should always create PRs, never direct-merge. The PR gate is the final catch, and the layer that protects the trust relationship with engineering, which is the real risk if this workflow goes wrong.</p><p>The four layers together make the workflow safe. The rules file makes the other three layers faster and cheaper to run. That is its actual value: not a sandbox, but a pre-filter that means your diff review is usually short and your engineer’s PR review is usually fast.</p><h3>Scope the First Change So the File Can Actually Protect You</h3><p>The rules file handles blast radius. You still need to handle scope.</p><p>The heuristic for your first change: pick something where the visual output and the code change are so tightly coupled that there is no reasonable route to the backend. The agent cannot accidentally refactor a database query when the task is “change this hex color.”</p><p><strong>Good first changes:</strong></p><ul><li>A spacing or padding fix on a specific component (change p-4 to p-6 in a Tailwind class, or a pixel value in a CSS file)</li><li>A microcopy edit: button label, empty state text, error message copy</li><li>A hover or focus state that is missing or visually wrong</li><li>A color value that drifted from the design token (replacing a hardcoded hex with the correct token reference)</li></ul><p><strong>Not yet:</strong></p><ul><li>Anything that conditionally renders based on user state or data</li><li>Any change that touches a component which also handles form submission or data fetching</li><li>Layout changes that involve a component you have not read in full</li><li>Anything described as “it’s just a small change to how the data displays”</li></ul><p>The “not yet” category is not permanent. It is for the first change while you are still calibrating how the agent behaves in this specific repo with this specific rules file. Once you have shipped one clean PR and read one clean diff, you have real information about the file’s behavior. Start there.</p><p><strong>Thinking exercise:</strong> Open the repo and list three changes you could realistically ship this week. Sort them into two columns: “the file can protect me here” (visible, low-logic, no data-flow dependency) and “not yet” (anything that touches state, data, or routing). The first column is your starting queue.</p><h3>Write the PR So Engineering Approves It in Two Minutes</h3><p>The rules file already did most of the work here. The agent’s required output (the list of what it changed and what it deliberately left untouched) becomes the body of the PR description.</p><p>Copy the agent’s post-change summary into the PR. Then add three things:</p><pre>## What changed<br>[Paste the agent&#39;s &quot;what I changed&quot; list here: file name, line range, what it does]</pre><pre>## What stayed intact<br>[Paste the agent&#39;s &quot;what I deliberately left untouched&quot; list here]</pre><pre>## What to review<br>- [ ] Check that the changed files are only in [list the component files you touched]<br>- [ ] Visual diff: before screenshot / after screenshot below<br>- [ ] No new dependencies (package.json unchanged)</pre><pre>[Before screenshot]<br>[After screenshot]</pre><p>The before and after screenshots are not optional decoration. They are how the engineer reviews a visual change in 90 seconds without pulling the branch. They are also how you document what you intended, which protects you if something unexpected surfaces in QA.</p><p>The real risk in this workflow is not a bad commit. It is eroding engineering’s trust by making them clean up after agent-authored changes they could not review quickly. A PR that is self-documenting, scoped to a visible change, and accompanied by screenshots does the opposite: it makes the engineer’s review faster than reviewing a hand-coded change, because the scope is explicit and the before/after is obvious.</p><p>One PR like this builds a track record. The track record is what eventually earns you the autonomy to take on the “not yet” changes.</p><h3>The Unlock Was Never Learning to Code</h3><p>Connolly’s number is 100% of ~30 designers shipping a production PR in one quarter. It sounds like the result of courage or a specific tool or an internal workshop. The actual load-bearing factor was a file Ellie wrote that told the agent which files it was forbidden to touch. Courage and Cursor were already present. The missing ingredient was the constraint.</p><p>That constraint is now a file you can paste.</p><p>A solo designer with no Ellie and no internal workshop can have the same starting condition Intercom’s designers had: a rules file committed to the repo, a diff habit, and a PR template engineering can scan in two minutes. The workflow is not at Intercom. It is in .cursor/rules/designer-safe.mdc.</p><p>The two-hour dev environment setup that Connolly mentioned? That part is on you and your engineering team. But the guardrail file that determines whether those two hours lead to a safe production change or an accidental auth refactor: that part you now have.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d3edb74c0e4a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/the-cursor-rules-file-intercoms-designers-use-to-ship-code-without-breaking-things-d3edb74c0e4a">The Cursor Rules File Intercom’s Designers Use to Ship Code Without Breaking Things</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[Chapter a Design Walkthrough Video in 90 Seconds With One Prompt (No Paid Loom AI)]]></title>
            <link>https://sumeeeet.medium.com/chapter-a-design-walkthrough-video-in-90-seconds-with-one-prompt-no-paid-loom-ai-12ab9bea0c6f?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/12ab9bea0c6f</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[design-walkthroughs]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Wed, 10 Jun 2026 19:36:24 GMT</pubDate>
            <atom:updated>2026-06-10T19:36:24.670Z</atom:updated>
            <content:encoded><![CDATA[<p>Summarize &amp; Chapter a Design Walkthrough Video With AI in 90 Seconds</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CjbBQGEZFNYU4YenAgVGwA.png" /></figure><blockquote>One LLM prompt over your screen-recording transcript turns an ignored handoff video into a packaged one. No paid Loom AI needed.</blockquote><p><em>~9 min read. For product designers who record async Figma handoff and design-critique walkthroughs in Loom, QuickTime, or OBS and aren’t on Loom’s paid AI tier. By the end you’ll have one LLM prompt that turns any screen-recording transcript into a ready-to-paste share package: a decision-stating title, a two-line why-watch, timestamped problem/current/proposed/rationale/asks chapters, and a TL;DR of decisions and open asks, runnable this afternoon on a recording you already have.</em></p><h3>The 12-minute walkthrough nobody watched</h3><p>The file was named Recording 2026-05-12.mov. You dropped the Loom link into the #design channel with a one-liner: &quot;Here&#39;s my handoff for the checkout flow redesign.&quot; No title in the Loom field. No description. No chapters. Twelve minutes of careful screen recording, gone quiet.</p><p>Three days later, two people had opened it. Neither made it past the two-minute mark.</p><p>The naive packaging fails in four compounding ways. First, Recording 2026-05-12.mov tells a PM or engineer exactly nothing. They cannot judge whether your video is the one they need to watch before the sprint ends or the one that can wait until next week. Second, no description means no context for a viewer who is already in four other Slack threads: your recording goes in the &quot;I&#39;ll get to it later&quot; pile, which is the same pile as the never pile. Third, no chapters means even a motivated viewer has no way to jump to the part that&#39;s relevant to them: the eng lead wants to see the proposed API call structure; the PM wants to see the asks. Without chapters, they&#39;d have to sit through the whole thing, and they won&#39;t. Fourth, a video with no metadata reads as careless. Christina Nguyen White, Loom&#39;s VP of Design at Atlassian, put it plainly in her 2024 keynote: videos shared without context &quot;weren&#39;t viewed... seen as careless, rushed, or suspicious.&quot;</p><p>All four failures come from the same source: you shipped the recording naked.</p><p>The recording itself was the easy 12 minutes. The 90 seconds of packaging is what decides whether anyone watches, and it’s the part most designers skip. By the end of this article you’ll have an LLM-powered packaging workflow: a single prompt that takes your transcript and returns a decision-stating title, a two-line why-watch, timestamped design-walkthrough chapters, and a TL;DR of decisions and open asks, ready to paste into your Loom share or Slack message. It runs on any recording tool. It costs nothing.</p><h3>Why a context-less design video reads as careless</h3><p>Creators rank packaging last. White’s keynote framed it as “icing on the cake,” something nice to add if you have time, but optional compared to the recording itself. That creator intuition is backwards.</p><p>For the viewer, packaging is the primary signal. When a video arrives in Slack with no title and no description, the viewer does not think “the designer was busy.” They think “this is low-effort” or “I’m not sure this is for me.” White’s 2024 keynote finding: those videos went unwatched, and were treated as careless or suspicious. Not because the content was bad, but because the wrapper said nothing about its value.</p><p>There’s a useful irony in citing White here. She runs design at Atlassian, the company that sells the auto-packaging button for Loom. She knows the viewer’s experience of a context-free video better than almost anyone. And her finding is not “turn on auto-chapters.” Her framing was about designers internalizing the viewer’s decision point and automating the etiquette that makes sharing actually work.</p><p>Packaging is not polish. It’s the part that determines whether your careful 12-minute walkthrough gets watched or silently skipped. The recording preserved the decision-context that a static mockup would have lost. According to the Microsoft Engineering Playbook on async design reviews, screen-recording walkthroughs carry the reasoning that people unfamiliar with the design tooling can follow. That preserved reasoning is useless if nobody opens the video.</p><p>So: the skip rate problem is a packaging problem, not a recording problem. Fix the package.</p><h3>“Just pay for Loom AI”: why that’s the wrong fix</h3><p>The obvious response is: turn on Loom’s auto-titles, auto-summaries, and auto-chapters. It’s a real feature. But before you reach for it, know exactly what it is and what it isn’t.</p><p>Per Loom’s own support documentation (accessed May 2026), the feature is:</p><ul><li><strong>Paywalled.</strong> Available on Business + AI and Enterprise plans only. Free-tier and Starter users don’t have access.</li><li><strong>Post-purchase only.</strong> It won’t run on recordings you made before you upgraded. If you’ve been on a free plan for the past year, none of your existing recordings are eligible.</li><li><strong>Tool-locked.</strong> If you record with QuickTime, OBS, or any other tool and then upload the file, auto-chapters won’t run on it. It only processes recordings made natively in Loom.</li><li><strong>Speech-dependent.</strong> Recordings with no speech, or sections without it, are excluded from the auto-chapter feature.</li><li><strong>Transcript-dependent.</strong> The feature requires a transcript. That transcript goes to OpenAI. Loom’s own docs describe it as “automatically generated based on context from the video transcript using OpenAI.”</li></ul><p>The last point matters most: there is no proprietary magic in Loom’s packaging feature. It is a transcript sent to a language model. You can build the same pipeline yourself, for free, on any recording tool. Because you’re writing the prompt yourself, you can give it something Loom’s generic output doesn’t have: a design-walkthrough-specific chapter schema.</p><p>Loom’s output is generic: it produces chapters based on topic shifts in the transcript, not on the structure of a design review. It doesn’t know that a PM wants to jump straight to the proposed change, or that the eng lead needs to find the open asks quickly. A custom prompt built on the right schema does.</p><h3>Get the transcript first (Loom .vtt, or QuickTime + Whisper)</h3><p>The architecture decision that makes this work is treating the LLM as a text processor, not a transcription engine. That principle is well-established in the transcript-first workflow documented by VideoToTextAI in April 2026. You are not asking the LLM to “watch” the video. You are giving it a timestamped text file and asking it to produce structure from that text. That distinction is what makes the output reliable.</p><p>Two paths to get the transcript, depending on your recording tool:</p><p><strong>Path A: Loom</strong></p><ol><li>Open your recording in Loom.</li><li>Click the transcript panel on the right side.</li><li>Export as .vtt (the option appears in the transcript menu). The .vtt file includes your timestamps in 00:00:00.000 --&gt; 00:00:05.000 format, followed by the spoken text.</li></ol><p>The .vtt is what you&#39;ll paste into the prompt.</p><p><strong>Path B: QuickTime, OBS, or any screen recording file</strong></p><p>Use a local Whisper tool. MacWhisper (available on the Mac App Store) and Whisper Transcription both process any .mov, .mp4, or .m4v file entirely on-device, no cloud upload, no account. Simon Willison documented in a 2024 TIL post that MacWhisper produces a local transcript in seconds. Both apps export .srt or .vtt with timestamps.</p><ol><li>Drag your recording into MacWhisper or Whisper Transcription.</li><li>Let it transcribe on-device (typically 1–3 minutes for a 12-minute recording on Apple Silicon).</li><li>Export as .vtt or .srt.</li></ol><p>A transcript chunk looks like this:</p><pre>00:01:42.000 --&gt; 00:01:49.000<br>So the current checkout flow has three screens, and the problem we kept hitting<br>in research was users couldn&#39;t find the discount code field before they paid.</pre><pre>00:01:49.000 --&gt; 00:02:05.000<br>What I&#39;m proposing here is a persistent order summary sidebar that keeps that<br>field visible throughout. Let me show you the current state first.</pre><p>That chunk is what the LLM reads. Your entire transcript, pasted into the prompt.</p><h3>The packaging prompt, built for the shape of a design walkthrough</h3><p>This is the prompt. Copy it, paste your transcript where indicated, and run it in ChatGPT, Claude, or any LLM with a large context window.</p><p>The design-walkthrough schema here (problem / current state / proposed change / rationale / asks and decisions needed) is validated by two sources: Microsoft’s Engineering Playbook on async design reviews, and Spinach’s 2024 guide on how to summarize a design review for reviewers. A design review without these structural markers forces a PM or engineer to watch sequentially to find what they need. Chapters built on this schema let them jump directly to the proposed change or the open asks. That jumpability is the moat over Loom’s generic topic-based chapters.</p><pre>You are a design-ops assistant. I&#39;m going to paste the full transcript of an async<br>design walkthrough screen recording. Your job is to produce a share package for<br>this recording with exactly four outputs.</pre><pre>INPUTS:<br>- Below is the complete transcript with timestamps in [HH:MM:SS] format.<br>- The recording is a design walkthrough — it explains a design problem, shows the<br>  current state, walks through the proposed change, gives the rationale, and<br>  identifies decisions needed or asks for reviewers.</pre><pre>OUTPUTS — produce all four, in this order:</pre><pre>1. DECISION-STATING TITLE (one sentence, max 12 words)<br>   Format: &quot;[Outcome verb] [what changed] for [who / context] — [key decision if<br>   there is one]&quot;<br>   The title must state what decision was made or what change is proposed.<br>   It is aimed at a PM or engineering lead who needs to decide whether this<br>   recording is relevant to them today.<br>   Do NOT use: vague descriptors (&quot;walkthrough of,&quot; &quot;review of,&quot; &quot;update on&quot;).<br>   DO use: outcome verbs (&quot;Redesigned,&quot; &quot;Removed,&quot; &quot;Proposed,&quot; &quot;Resolved&quot;).</pre><pre>2. WHY-WATCH (two sentences only)<br>   Sentence 1: The problem this recording addresses.<br>   Sentence 2: What the viewer will be able to decide or do after watching.</pre><pre>3. TIMESTAMPED CHAPTERS (design-walkthrough schema)<br>   Use exactly these five chapter labels where the content appears:<br>   - Problem<br>   - Current State<br>   - Proposed Change<br>   - Rationale<br>   - Asks &amp; Decisions Needed<br>   Format each chapter as: [MM:SS] Label — one-sentence description of what<br>   happens in that section.<br>   STRICT RULE: Only use timestamps that appear verbatim in the transcript.<br>   If a section has no clearly identifiable timestamp in the transcript, omit<br>   that chapter rather than guess. Do not invent or approximate timestamps.</pre><pre>4. DECISIONS + ASKS TL;DR (bullet list, max 8 bullets)<br>   Two sub-sections:<br>   - Decisions made: what was resolved in this recording<br>   - Open asks: what the viewer needs to respond to or approve</pre><pre>TRANSCRIPT:<br>[PASTE YOUR FULL TRANSCRIPT HERE]</pre><p>Why the output shape matters: a PM opening the Loom link scans the title to confirm this is the checkout redesign, reads the why-watch to understand whether they need to watch now or later, and jumps directly to “Asks &amp; Decisions Needed” to see what requires their input. What used to mean watching 12 minutes to extract two questions now means reading four bullets. The same information, in the shape that actually fits a reviewer’s workflow.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zTQlIvT8j8uck0e-JeE2OQ.png" /></figure><p>Claude turns a raw .vtt transcript into a decision-stating title, why-watch, and timestamped design-walkthrough chapters in ~20 seconds. ⬇</p><h3>The one rule that keeps the LLM from inventing timestamps</h3><p>There is one failure mode that breaks the entire package: hallucinated timestamps.</p><p>LLMs do not watch videos. They read text. When the prompt asks for timestamped chapters, a model without explicit guardrails will sometimes generate timestamps that feel plausible but don’t match anything in the transcript. The chapter says [04:30] Proposed Change, but when a reviewer clicks to jump to 4:30 in Loom, they land in the middle of a different section, or silence. Trust in the package evaporates immediately.</p><p>Existing prompt scaffolds for transcript formatting, including the detailed 8-part schema from mxmoritz (2024), don’t include an explicit anti-hallucination rule on timestamps. That omission is the gap this article fills.</p><p>The fix is already built into the prompt above. This specific line:</p><pre>STRICT RULE: Only use timestamps that appear verbatim in the transcript.<br>If a section has no clearly identifiable timestamp in the transcript, omit<br>that chapter rather than guess. Do not invent or approximate timestamps.</pre><p>This is the timestamp anchor: a prompt instruction that pins the LLM’s output to the literal timestamp tokens present in the .vtt or .srt file. &quot;Omit rather than guess&quot; is the key phrase. A missing chapter is recoverable; a wrong chapter destroys confidence in the package.</p><p>After the LLM returns the chapters, run a 10-second verify: open the .vtt file you exported, search for each returned timestamp (e.g. 04:30), and confirm the corresponding text aligns with the chapter label. On a 12-minute recording with five chapters, this takes under a minute.</p><p>One additional edge case to handle: Loom’s own auto-chapter feature won’t run on recordings with no speech, or on silent sections. The same applies here. If your recording has a long screen-only section with no narration, the transcript will have a gap. The LLM will either omit those sections correctly (with the strict rule in place) or flag them in the output. Either outcome is fine; what you want to avoid is a chapter label assigned to a silent segment.</p><h3>Paste it back: the package on the actual share</h3><p>The output arrives in about 20 seconds. Here is what you do with it:</p><p><strong>In Loom:</strong> Paste the decision-stating title into the Loom title field (the one that defaults to the filename). Paste the why-watch + chapters into the description field. Pin the decisions + asks TL;DR as the first comment in the thread.</p><p><strong>In Slack:</strong> Post the Loom link with the title as your message text. Immediately follow with the why-watch and the chapters in the thread. Pin the TL;DR.</p><p><strong>In Linear:</strong> Add the title to the attached link text. Drop the chapters and TL;DR into the issue description alongside the video.</p><p>The same recording that shipped as Recording 2026-05-12.mov with no context now looks like this when it lands:</p><p><strong>Redesigned checkout summary sidebar to surface discount code field (requires PM sign-off on layout)</strong></p><p><em>The current three-screen checkout flow buries the discount code field below the fold, causing drop-off before purchase. Watch this to decide whether the proposed sidebar layout is ready for engineering handoff.</em></p><p><strong>Chapters:</strong></p><ul><li>[00:32] Problem: discount code field discovery issue from research</li><li>[01:49] Current State: existing three-screen flow walkthrough</li><li>[03:15] Proposed Change: persistent sidebar with summary + discount field</li><li>[06:44] Rationale: conversion data from comparable patterns</li><li>[09:20] Asks &amp; Decisions Needed: sidebar layout sign-off, mobile breakpoint approach</li></ul><p><strong>Decisions Made:</strong> Sidebar layout chosen over accordion pattern; mobile TBD. <strong>Open Asks:</strong> PM sign-off on layout before engineering handoff. Confirm mobile breakpoint approach with eng.</p><p>The thinking exercise: pull up the last walkthrough you dropped in Slack or Linear. Look at the title you shipped. Now run the packaging prompt on its transcript. Compare the title the LLM writes to the filename you actually sent. That gap, in one example, is the gap between a viewed handoff and an ignored one.</p><h3>The leverage was never the recording</h3><p>The recording is always the easy part. Twelve minutes of screen capture is within reach of any designer, any recording tool, any afternoon. The hard part has always been the 90 seconds afterward: naming what you built, framing why it matters, showing a reviewer where to jump.</p><p>That 90-second job is also exactly what an LLM does well off a transcript: pattern-match to a schema, produce structured output from unstructured input, format a package that fits a viewer’s workflow rather than a creator’s convenience.</p><p>The skill that compounds here is not learning to record better walkthroughs. It’s owning the prompt that packages them, on any tool, for any recording, for free. Run it once on a recording you already have. The gap between what shipped and what could have shipped will make the argument better than this article can.</p><p>If this was useful, I’m writing more workflows like it: the design-ops prompts I actually run (handoff-doc generator, critique-summary, standup-recap). Join the list and I’ll send the next one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=12ab9bea0c6f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Turn a Folder of Interviews Into Cited Personas With Claude Code: Zero Invented Quotes]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://sumeeeet.medium.com/turn-a-folder-of-interviews-into-cited-personas-with-claude-code-zero-invented-quotes-c7f6411abcf2?source=rss-44260e16fd53------2"><img src="https://cdn-images-1.medium.com/max/2400/1*xlXiR4MQBEBSDlEngHIJZg.png" width="2400"></a></p><p class="medium-feed-snippet">A staged Claude Code workflow that turns a folder of raw interviews into personas, a journey map, and a PRD, with a guardrail that&#x2026;</p><p class="medium-feed-link"><a href="https://sumeeeet.medium.com/turn-a-folder-of-interviews-into-cited-personas-with-claude-code-zero-invented-quotes-c7f6411abcf2?source=rss-44260e16fd53------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sumeeeet.medium.com/turn-a-folder-of-interviews-into-cited-personas-with-claude-code-zero-invented-quotes-c7f6411abcf2?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/c7f6411abcf2</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[ai-workflow]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-product-management]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Sun, 07 Jun 2026 20:04:12 GMT</pubDate>
            <atom:updated>2026-06-07T20:04:12.423Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Stop Re-Prompting Flaws Nobody Notices: A 3-Axis Triage for AI Design Assets]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://sumeeeet.medium.com/stop-re-prompting-flaws-nobody-notices-a-3-axis-triage-for-ai-design-assets-195890bc840b?source=rss-44260e16fd53------2"><img src="https://cdn-images-1.medium.com/max/2400/1*Vrn5_EUfdphZz8NlDAnQjw.png" width="2400"></a></p><p class="medium-feed-snippet">Stop re-prompting flaws nobody will notice. Run a three-axis triage that tells you what to fix, ignore, and never fix.</p><p class="medium-feed-link"><a href="https://sumeeeet.medium.com/stop-re-prompting-flaws-nobody-notices-a-3-axis-triage-for-ai-design-assets-195890bc840b?source=rss-44260e16fd53------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sumeeeet.medium.com/stop-re-prompting-flaws-nobody-notices-a-3-axis-triage-for-ai-design-assets-195890bc840b?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/195890bc840b</guid>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[ai-design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ai-prompts]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Sat, 06 Jun 2026 09:01:09 GMT</pubDate>
            <atom:updated>2026-06-06T09:01:09.960Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[3 Figma Directions From One Brief: The 2 Files That Kill the Generic AI Look]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/design-bootcamp/3-figma-directions-from-one-brief-the-2-files-that-kill-the-generic-ai-look-1d67d2ecea7e?source=rss-44260e16fd53------2"><img src="https://cdn-images-1.medium.com/max/2400/1*gMOim1973XI06P92S7bNOw.png" width="2400"></a></p><p class="medium-feed-snippet">The two markdown files that stop AI-generated Figma screens from coming out generic and drifting between directions.</p><p class="medium-feed-link"><a href="https://medium.com/design-bootcamp/3-figma-directions-from-one-brief-the-2-files-that-kill-the-generic-ai-look-1d67d2ecea7e?source=rss-44260e16fd53------2">Continue reading on Bootcamp »</a></p></div>]]></description>
            <link>https://medium.com/design-bootcamp/3-figma-directions-from-one-brief-the-2-files-that-kill-the-generic-ai-look-1d67d2ecea7e?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/1d67d2ecea7e</guid>
            <category><![CDATA[ai-in-design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Thu, 04 Jun 2026 21:45:29 GMT</pubDate>
            <atom:updated>2026-06-04T21:45:29.973Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Build a Cited Evidence Table From 10 User Interviews in an Afternoon — No Dovetail]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://sumeeeet.medium.com/build-a-cited-evidence-table-from-10-user-interviews-in-an-afternoon-no-dovetail-93c4b3e2611b?source=rss-44260e16fd53------2"><img src="https://cdn-images-1.medium.com/max/2400/1*w1Inq7s4Bv2YdcVzxLwX7Q.png" width="2400"></a></p><p class="medium-feed-snippet">A four-step workflow that produces a participant-ID-tagged, verbatim-quoted evidence table with every citation confirmed against your&#x2026;</p><p class="medium-feed-link"><a href="https://sumeeeet.medium.com/build-a-cited-evidence-table-from-10-user-interviews-in-an-afternoon-no-dovetail-93c4b3e2611b?source=rss-44260e16fd53------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://sumeeeet.medium.com/build-a-cited-evidence-table-from-10-user-interviews-in-an-afternoon-no-dovetail-93c4b3e2611b?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/93c4b3e2611b</guid>
            <category><![CDATA[user-interviews]]></category>
            <category><![CDATA[user-experience-design]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Thu, 04 Jun 2026 20:30:25 GMT</pubDate>
            <atom:updated>2026-06-04T20:30:25.535Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Catch Every UX String That Drifts From Your Voice Guide With a Claude Project]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://medium.com/design-bootcamp/catch-every-ux-string-that-drifts-from-your-voice-guide-with-a-claude-project-f48bdc07045a?source=rss-44260e16fd53------2"><img src="https://cdn-images-1.medium.com/max/2400/1*jSFrVaTxjYTAminVVv4x-Q.png" width="2400"></a></p><p class="medium-feed-snippet">Stop asking Claude to write your copy. Make it find every place your strings drift from your voice guide instead.</p><p class="medium-feed-link"><a href="https://medium.com/design-bootcamp/catch-every-ux-string-that-drifts-from-your-voice-guide-with-a-claude-project-f48bdc07045a?source=rss-44260e16fd53------2">Continue reading on Bootcamp »</a></p></div>]]></description>
            <link>https://medium.com/design-bootcamp/catch-every-ux-string-that-drifts-from-your-voice-guide-with-a-claude-project-f48bdc07045a?source=rss-44260e16fd53------2</link>
            <guid isPermaLink="false">https://medium.com/p/f48bdc07045a</guid>
            <category><![CDATA[ai-in-design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ai-content-generator]]></category>
            <category><![CDATA[copywriting]]></category>
            <dc:creator><![CDATA[Sumeet]]></dc:creator>
            <pubDate>Wed, 03 Jun 2026 07:40:01 GMT</pubDate>
            <atom:updated>2026-06-03T07:40:01.823Z</atom:updated>
        </item>
    </channel>
</rss>