<?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 Marcin Ukleja on Medium]]></title>
        <description><![CDATA[Stories by Marcin Ukleja on Medium]]></description>
        <link>https://medium.com/@marcinukleja?source=rss-c2dfda8c690a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*SMlQ2TN0hFfhFNX0uQgVIg.jpeg</url>
            <title>Stories by Marcin Ukleja on Medium</title>
            <link>https://medium.com/@marcinukleja?source=rss-c2dfda8c690a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 10:15:43 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@marcinukleja/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[Building LET’S TOUCH: Real-Time Digital Touch Experience]]></title>
            <link>https://medium.com/@marcinukleja/building-lets-touch-real-time-digital-touch-experience-e4b5f5ac273a?source=rss-c2dfda8c690a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e4b5f5ac273a</guid>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[apps]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[case-study]]></category>
            <dc:creator><![CDATA[Marcin Ukleja]]></dc:creator>
            <pubDate>Sat, 14 Feb 2026 21:32:55 GMT</pubDate>
            <atom:updated>2026-02-14T23:21:55.365Z</atom:updated>
            <content:encoded><![CDATA[<h3>Building LET’S TOUCH: Real-time Digital Touch Experience</h3><p>I got the idea for this project from a classic movie scene: two people are separated by a glass wall, and they press their hands against it to feel connected. There’s still a barrier, but the gesture creates a moment of closeness.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*mfWAE9SsxG_UCRdDr0PURQ.png" /></figure><p>In 2018, I built a small experiment called LET’S TOUCH for me and my wife: a <strong>digital space</strong> where you can <strong><em>touch</em></strong> someone in real time. Not a “send and wait” interaction, but something you can experience at the same moment.</p><p>This is a behind-the-scenes write‑up of how I turned that idea into LET’S TOUCH — a small real-time web experiment for sharing touch gestures with one other person.</p><blockquote>If you want to try it first, it’s live at <a href="https://letstouch.app/"><strong>letstouch.app</strong></a>.</blockquote><p>If you want the full story, here’s how this post is structured:</p><ol><li>Theory</li><li>Digital context</li><li>Design</li><li>Next</li><li>How to use it</li></ol><h3>1. Theory</h3><p>Touch is a huge topic, so I narrowed it down to <strong>touch as communication</strong>. I read articles, skimmed research, and talked to a few people who know more than I do. My goal wasn’t to become an academic expert. I just wanted a clear mental model before designing anything.</p><h4>Level 1: Verbal vs. Non‑verbal</h4><p>We communicate in two broad ways:</p><ul><li><strong>Verbal</strong>: spoken or written words</li><li><strong>Non‑verbal</strong>: gestures, facial expressions, eye contact, tone, and touch</li></ul><p>One difference that matters a lot here is <strong>simultaneity</strong>. Spoken conversation is mostly turn‑taking. Non‑verbal signals can overlap. Two people can smile, gesture, and touch at the same time without “interrupting” each other.</p><h4>Level 2: Types of non‑verbal communication</h4><p>Non‑verbal communication includes many channels:</p><ul><li><strong>Kinesics</strong> (body language)</li><li><strong>Haptics</strong> (touch)</li><li><strong>Oculesics</strong> (eye contact)</li><li><strong>Paralanguage</strong> (tone, rhythm, intensity)</li><li><strong>Proxemics</strong> (use of space)</li></ul><p>My focus is <strong>haptics</strong>. Still, seeing the bigger picture helped me avoid designing “touch” in isolation.</p><h4>Level 3: Haptics</h4><p>Touch can mean a lot of things depending on context: a tap, a nudge, a handshake, holding hands, a hug. It can be friendly, formal, comforting, playful, or intimate.</p><p>I was most interested in <strong>positive, affectionate touch</strong>, and in what makes it feel special.</p><p>Two properties stood out:</p><ol><li><strong>Simultaneity</strong>: if you touch someone, you’re also being touched.</li><li><strong>Interdependence</strong>: both sides influence the experience, even if only one initiates.</li></ol><p>These 2 properties are what I wanted to capture in a digital product. They’re also what makes touch different from other non‑verbal channels, and from verbal communication.</p><h3>2. Digital context</h3><p>Touch exists in physical products (doorbells, keyboards) and in digital ones (touchscreens, trackpads). But I’m interested in touch as a <strong>communication primitive</strong> in digital products.</p><h4>Messaging</h4><p>Most messaging apps converged on a similar set of features. What’s interesting is the direction of travel: from pure text toward richer signals.</p><ol><li><strong>SMS</strong> (1992) was basically verbal communication: plain text with a hard limit.</li><li><strong>Emoticons and emoji</strong> added a hint of non‑verbal intent.</li><li><strong>Read receipts</strong> improved feedback. This maps nicely to Jakob Nielsen’s “Visibility of system status”: the interface should tell you what’s going on.</li><li><strong>Typing indicators</strong> made it feel more live.</li><li><strong>Rich media</strong> (photos, GIFs, voice, video) expanded what you can send, but didn’t change the underlying interaction model much.</li></ol><p>One category that still feels personal is <strong>sketching</strong>. It’s not “touch” in the physical sense, but it’s a touch-driven creation you can share.</p><h4>Apple Watch</h4><p>Wearables are interesting because they’re always on you and physically close. Apple’s “Digital Touch” explored that with:</p><ul><li><strong>Sketches</strong>: you draw and the other person sees the drawing appear.</li><li><strong>Taps</strong>: a small haptic signal (a vibration) on the other wrist.</li><li><strong>Heartbeat</strong>: using sensors to send something real.</li></ul><p>What I missed there is <strong>simultaneity</strong>. Many of these interactions are still turn‑based: make → send → receive.</p><h4>Figma and FigJam</h4><p>This one surprised me. Collaboration tools aren’t “intimate”, but some of them get <strong>real-time, simultaneous interaction</strong> right.</p><p>Figma’s multiplayer presence (live cursors), observing mode, and cursor chat make a digital space feel genuinely shared. FigJam goes further with lightweight gestures like emotes, stamps, and the <strong>high‑five</strong> interaction.</p><p>That combination — shared space + real time + non‑verbal signals — was a useful reference while designing LET’S TOUCH.</p><h3>3. Design</h3><p>This was the most important part for me. This is where LET’S TOUCH stopped being an idea and became a set of constraints I could actually build.</p><p>The process wasn’t clean. It was iterative, sometimes chaotic, and full of small experiments that didn’t make it into the final product. But a lot of concrete design decisions did get made.</p><p>The idea was simple: create a private space for two people where the experience is:</p><ol><li><strong>Touch‑based</strong>: you can send and receive a single touch.</li><li><strong>Real‑time</strong>: it has to happen now, not in turns.</li><li><strong>Intimate</strong>: a small private space for two people only.</li><li><strong>Unique</strong>: one small moment should feel surprisingly good, delightful.</li><li><strong>Simple</strong>: one view, minimal UI.</li></ol><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C_Bnx4IE6NKukZUjVgHbYA.png" /><figcaption>5 design principles</figcaption></figure><p>Everything else in this post exists to support these constraints.</p><h4>Layout</h4><p>One of the first high-level decisions was the overall layout of the app.</p><p>The most important element is the touch area itself — the space where we’re going to <em>touch</em>.</p><p>To stay true to <strong>simplicity</strong>, I narrowed it down to two options:</p><ul><li><strong>Full screen</strong>: the entire view is the touch area.</li><li><strong>Defined area</strong>: a dedicated (but subtle) touch area.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QNJI4NfobKFWvcNgNwGBMg.png" /></figure><p>Full screen was tempting, and I gave it a solid try. But in a two-person experience, screen geometry matters. Exchanging raw pixel coordinates works only when both people have similar screens, orientations, and safe-area insets.</p><p>I could have normalized everything behind the scenes, but it quickly got messy — especially for reliable “mutual touch” detection (covered later).</p><p>So I went with a responsive <strong>square</strong> touch area, subtly indicated in the UI:</p><ul><li>It gives both people the same aspect ratio.</li><li>It makes “mutual touch” detection consistent.</li></ul><p>The rest of the layout stays minimal: a short action prompt at the top and a status line at the bottom.</p><h4>Palette</h4><p>One of the decisions I had to make was the palette.</p><p>I started with the <strong>accent</strong>. I considered a few accent colors, and I briefly played with going fully monochrome. In the end, I chose one <strong>pink</strong>.</p><p>It felt unique, and it carried a subtle <strong>erotic</strong> connotation, which fit the potential nature of the interaction.</p><p>This accent color was meant to be applied to the touch indicators — to visualize both the user’s and their friend’s touch.</p><p>Once the accent direction was clear, I still had to decide on the rest of the palette. I ended up with 3 options:</p><ul><li><strong>Light</strong></li><li><strong>Dark</strong></li><li><strong>Tinted</strong></li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1ljW0uOfIxj0jyXev_71yA.png" /></figure><p>I ruled out light mode almost immediately. It felt common and a bit exposed — too bright, too generic for something that’s supposed to feel private and unique.</p><p>Tinted version was tempting, but it didn’t help me emphasize the view states that depend on touch. I’ll cover those states later.</p><p>In the end, I went with a typical neutral dark mode, without any tinting. It played well and gave the pink accent room to shine.</p><h4>Typography</h4><p>Another decision I had to make was typography.</p><p>It had to support the same design principles as everything else, but I didn’t want it to stand on its own. It needed to be a subtle companion to the interaction.</p><p>There isn’t much text in the UI, so typography is less about reading and more about framing the space.</p><p>I treated labels as <strong>visual blocks</strong>: ALL CAPS with a bit more letter spacing. It makes short prompts feel more like graphic elements than sentences.</p><p>Obviously I had to choose a typeface. I considered three options:</p><ul><li>System font (such as <strong>SF Pro</strong>)</li><li><strong>FF DIN</strong></li><li>Generic, simple font (such as <strong>Inter</strong>)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sMqOhcdprPtcA-3uDpJ0zw.png" /></figure><p>For quite a while I stayed with the <strong>system font</strong>, mostly because it was neutral, “good enough” and didn’t pull attention.</p><p>What I really wanted was <strong>DIN</strong> — my all‑time favorite — but I didn’t have a web use license for it, so I ruled it out.</p><p>I landed on <strong>Inter</strong>. It’s neutral, readable, and it’s also the typeface I already use in my other branding materials, so it kept the project consistent, without drawing attention to itself.</p><h4>View states</h4><p>LET’S TOUCH needs to support a few different states, but I wanted them to feel private, clear, and simple.</p><p><strong>Wait</strong>: You’re alone in the space. The UI prompts you to share the link, and a small waiting indicator keeps the screen feeling alive while you’re waiting for your friend to join.</p><p><strong>Joined</strong>: Your friend connects to the same room. The “invite” prompt goes away, and the interface shifts from “waiting” to “this is a shared touch surface”.</p><p><strong>Touch</strong>: One or both of you is touching, but your touches aren’t overlapping. Touches show up as simple circles and fade out after release, which makes taps feel crisp. Swipes work too, and that ended up being surprisingly satisfying.</p><p><strong>Mutual</strong>: Your touches overlap. This is the key moment: the whole screen slowly fills with pink, giving you a shared moment of delight and satisfaction.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pm-TN0LXVcIvORAZOwV3xg.png" /></figure><p>Obviously, I tested many options, but this one seemed to play well both on design and implementation fronts.</p><h3>4. Next</h3><p>This is still an experiment, but I don’t actively develop it.</p><p>If I ever return to it, these are the 4 improvements I’d start with:</p><ol><li>More <strong>expressive visuals</strong>: some light creative-coding effects for swipes, and a richer “mutual touch” moment.</li><li><strong>Customization</strong> options: colors, touch indicator styles, maybe even a “skin” for the whole app.</li><li>Easier <strong>sharing</strong>: using the Web Share API so the share moment doesn’t require app‑switching and copy‑pasting</li><li>Exploring lightweight <strong>integrations</strong> with popular DM apps.</li></ol><h3>5. How to use it</h3><p>You can try LET’S TOUCH at <a href="https://letstouch.app/">letstouch.app</a>. It’s live as of 2026, but it’s still a side project, so expect rough edges.</p><ol><li>Open <a href="https://letstouch.app/">letstouch.app</a>.</li><li>Your URL will include a <em>room</em> ID (for example: letstouch.app/fuba1234).</li><li>Share that exact link with your friend.</li><li>Wait until they join.</li><li>Start tapping and swiping. Try to touch the same spot at the same time.</li></ol><p>This project was a fun way to explore the design space of touch as a communication primitive. I’m proud of the final product, and the fact I use it myself to enhance everyday digital interactions.</p><p>I hope this write-up gives you a clear picture of the design and implementation process I went through. And I hope you will give LET’S TOUCH a try with someone you care about.</p><p>Happy touching!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e4b5f5ac273a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FigLint UI3 Icons Update (Part 3/3): Icon Design]]></title>
            <link>https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-3-3-icon-design-1c13ecb9606b?source=rss-c2dfda8c690a------2</link>
            <guid isPermaLink="false">https://medium.com/p/1c13ecb9606b</guid>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[figma-plugin]]></category>
            <category><![CDATA[icons]]></category>
            <dc:creator><![CDATA[Marcin Ukleja]]></dc:creator>
            <pubDate>Fri, 13 Feb 2026 09:54:42 GMT</pubDate>
            <atom:updated>2026-02-13T09:54:42.200Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Series cover showing three parts: Part 1 (Figma Plugin UI Kit), Part 2 (Figma‑to‑Code Script), and Part 3 (Icon Design) highlighted" src="https://cdn-images-1.medium.com/max/1024/1*3f903SYkrWCLxDaXv1_EtA.png" /></figure><p><a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-1-3-figma-plugin-ui-kit-67eb92a0c9f7">Part 1. Figma Plugin UI Kit</a><br><a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-2-3-figma-to-code-script-5f20e454ebba">Part 2. Figma‑to‑Code Script</a><br><strong>Part 3. Icon Design</strong></p><p>This is <strong>Part 3</strong> of a <strong>3‑part series</strong> on updating “just” the icons in my Figma plugin, <strong>FigLint</strong>, to match Figma’s design language, <strong>UI3</strong>. The work itself happened a while ago — early in <strong>UI3</strong>’s rollout — and what began as a small cleanup grew into refining my design library, building a Figma‑to‑Code pipeline, and refreshing the plugin UI.</p><figure><img alt="Banner: FigLint — Check your designs for common issues, layer‑by‑layer" src="https://cdn-images-1.medium.com/max/1024/1*X4SmG3ITF9sia8VZ8SSKJQ.png" /><figcaption>Try <a href="https://www.figma.com/community/plugin/1323794044088972088/figlint"><strong>FigLint</strong> on Figma Community</a></figcaption></figure><p>This series is dedicated to craft — clear systems, careful icon work, and practical plugin development — rather than the latest powerful AI workflows. If that resonates, you’ll enjoy it.</p><p>In <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-1-3-figma-plugin-ui-kit-67eb92a0c9f7">Part 1</a>, I covered how I retrieved, structured, and normalized the icon components in my <strong>Figma Plugin UI Kit</strong>. In <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-2-3-figma-to-code-script-5f20e454ebba">Part 2</a>, I showed the workflow I built to keep those icons <strong>synchronized</strong> between Figma and code.</p><p>This final part is about the design work itself: what I changed (and why) to make FigLint’s iconography feel at home in <strong>UI3</strong>.</p><figure><img alt="Grid of various icons in the FigLint plugin" src="https://cdn-images-1.medium.com/max/1024/1*D-6W9Em0KFKxpOHLp67bZw.png" /><figcaption><em>Some of </em><strong><em>FigLint</em></strong><em> icons after the UI3 update</em></figcaption></figure><p>To keep it practical, I’ll walk through five areas where icon decisions mattered most:</p><ol><li>Resize handle</li><li>Issue groups</li><li>Layers</li><li>Ignored elements</li><li>FigLint icon</li></ol><h3>1. Resize handle</h3><p>Figma plugins <strong>do not support resizing</strong> their window out of the box, so developers rely on small tricks to add it. My favorite is simple: show a subtle resize handle in the bottom‑right corner and add basic interactivity so the window can be resized.</p><p>This feature has been in my FigLint plugin since the start. Before UI3, the plugin window had almost sharp corners (1px radius), so my original handle had no corner radius. With UI3, plugin windows now have much rounder corners (13px), so the old handle looked out of place.</p><figure><img alt="Illustration of 3 different cases of resize handle icon: Old UI — Old icon, UI3 — Old icon, UI3 — New icon" src="https://cdn-images-1.medium.com/max/1024/1*U1VquLyxCS3uOhHsab16EQ.png" /><figcaption><em>Old icon looked off with more rounded corners in UI3</em></figcaption></figure><p>This icon is a special case — it doesn’t follow the usual 16×16 icon sizing rules. Its only job is to communicate “resize”, and it never appears elsewhere in the UI.</p><p>The resize handle icon sits in the rounded bottom‑right corner. As you might know, nested radii should be <strong>concentric</strong>, meaning they should share the same center point to maintain consistent curvature. This also means that the inner radius is always smaller than the outer radius by exactly the amount it’s offset inward. Simple illustration might help:</p><figure><img alt="Illustration showing zoomed‑in view of the resize handle icon, with many dimensions, showing two concentric radii: the outer radius of 13px and the inner radius of 9px, with a 4px offset between them" src="https://cdn-images-1.medium.com/max/1024/1*E_OtkjODllRO-BQOmoE3DQ.png" /><figcaption><em>Concentric nested radii keep curvature consistent</em></figcaption></figure><p>I experimented with different <strong>offsets</strong> and found that 4px of space between the outer edge of the glyph and the corner works best, resulting in a 9px radius for the outer glyph line.</p><p><strong>The handle isn’t just a quarter circle </strong>— it has a subtle straight extension (3px) that helps it look right and let me smooth the corners a bit.</p><p>One last detail: <strong>rounded caps</strong>. At 1px line width, this just makes the line ends smoother, matching Figma’s UI3 style.</p><h3>2. Issue groups</h3><p>FigLint’s main view divides issues into <strong>2 categories</strong> (Styles and Variables), and then into <strong>groups</strong> within each category. Every group has its own icon — custom-designed, but always based on Figma’s native icons for the relevant issue type.</p><figure><img alt="Screenshot of the FigLint plugin showing two categories of issues: Styles and Variables, each with a list of issue groups, each group having its own icon" src="https://cdn-images-1.medium.com/max/1024/1*0PDCt1Xa2v9SZn3zKve8ow.png" /><figcaption><em>Part of FigLint’s </em><strong><em>main view</em></strong></figcaption></figure><p>Native Figma icons for different <strong>Styles</strong> are hard to spot in the UI, but they changed quite a bit in UI3.</p><figure><img alt="Old and new Figma icons for Text, Color, Effect and Layout guide styles" src="https://cdn-images-1.medium.com/max/1024/1*dMEqJB5AsXT5gWQHL5Fz3w.png" /></figure><p>Some icons for the <strong>Variables</strong> category had to be recreated manually, since they’re based on variable-scope icons that still haven’t been updated to UI3 (as of February 2026).</p><figure><img alt="Screenshot of Figma’s native icons for variable scopes, showing that they still use the old UI2 style" src="https://cdn-images-1.medium.com/max/1024/1*1TtY--yNun3GVM_zaHYsIw.png" /><figcaption><em>Figma’s native variable scoping view with old UI2 icons</em></figcaption></figure><p>Currently, FigLint reports issues about missing styles and variables (for example, <em>No text style</em>, <em>No color variable</em>, <em>No padding variable</em>). I decided to visualize these with Figma’s <strong>native icons</strong> for the relevant style/variable type, but with a <strong>crossing-out line</strong> to indicate the issue.</p><p>I experimented with different ways to show the crossing-out. I tried variations like changing the slash direction, using no masking, masking only on top, or masking on both sides. I tested this on the old UI2 icons first, but the approach translated well to UI3.</p><figure><img alt="Different variations of crossing-out line on top of a Figma text icon, showing different directions and masking approaches" src="https://cdn-images-1.medium.com/max/1024/1*XjbxLSU0ZbIsmXPQBAVxNQ.png" /><figcaption><em>I actually tested it on every issue group icon</em></figcaption></figure><p>Eventually, I settled on these rules:</p><ol><li>The line crosses out the icon from top‑left to bottom‑right (very common pattern).</li><li>The line is quite long (extending beyond the typical safe area). This makes it more distinctive and less likely to be confused with the main icon glyphs.</li><li>The line is 1px thick, but it also masks the icon glyph with an extra 1px of space below the line.</li></ol><p>These rules were straightforward, but when I applied them to some icons, the result didn’t always look right, so I had to make some minor <strong>manual adjustments</strong>.</p><figure><img alt="Final icons for issue groups, showing the crossing-out line applied to Figma’s native icons for styles and variables" src="https://cdn-images-1.medium.com/max/1024/1*-XIihdAEiBfOXjXMk2BU1A.png" /><figcaption><em>Final icons for Styles and Variables issues</em></figcaption></figure><p>Honestly, I’m not completely satisfied with some icons, but I’ve decided to keep them for now and not let perfectionism delay the update. I can always revisit them later.</p><h3>3. Layers</h3><p>Layer icons in FigLint indicate the type of layer each issue relates to. You’ll see them in the layers list within the <strong>details view</strong> for each issue group.</p><p>Naturally, these icons are based on Figma’s native layer icons from the <strong>Layers</strong> panel, so extracting them from the Figma web app was straightforward (see <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-1-3-figma-plugin-ui-kit-67eb92a0c9f7">Part 1. Figma Plugin UI Kit</a> for the workflows I used).</p><figure><img alt="Screenshot of Figma’s Layers panel and screenshot of the details view in FigLint showing the list of layers with their icons" src="https://cdn-images-1.medium.com/max/1024/1*HNp_k_ay490tDlOwL1kq4g.png" /><figcaption><em>Figma’s </em><strong><em>Layers</em></strong><em> panel and FigLint’s </em><strong><em>details view</em></strong></figcaption></figure><p>The set of layer icons is surprisingly large — or at least larger than I expected. Some common layer types are simple, like Frame, Text, or Component. But things get more complex with auto layout frames. Figma considers basic properties of the auto layout frame, such as <em>direction</em> and <em>alignment</em>, so there are now 10 different icons for auto layout frames:</p><ul><li>6 for the default direction/alignment combinations (vertical: left, center, right; horizontal: top, center, bottom)</li><li>3 for wrapped horizontal layouts (left, center, right)</li><li>1 for the new grid layout</li></ul><figure><img alt="All 10 auto layout icons, showing different combinations of direction and alignment" src="https://cdn-images-1.medium.com/max/1024/1*UdeUQ7oURpTpf8cZk5A_1Q.png" /><figcaption><em>Layer icons with different </em><strong><em>direction</em></strong><em> and </em><strong><em>alignment</em></strong><em> layout combinations</em></figcaption></figure><p>To display the correct icons in the layers list, I had to implement quite a few rules in the plugin code. I learned a lot about the Figma API along the way.</p><h3>4. Ignored elements</h3><p>At first glance, each issue in FigLint seems straightforward. In practice, there are plenty of <strong>edge cases</strong>, and most of them fall into a set of rules for elements the plugin should ignore to avoid false positives.</p><p>You’ll find all these rules listed at the very top of the details view for each issue group.</p><p><strong>Spoiler alert</strong>: For now, these rules are hard‑coded in the plugin, but I plan to make them configurable in the future.</p><p>In earlier versions of FigLint, the ignored elements section didn’t use any icons — it was just a bulleted list of rules. That was a conscious MVP decision, but I always intended to improve it. The UI3 update finally made this a priority.</p><figure><img alt="Screenshot of the ignored elements section in the details view, showing a bulleted list of rules without icons, and a screenshot of the same section after the update, showing the new icons next to each rule" src="https://cdn-images-1.medium.com/max/1024/1*en1oYxyShpctXbIwobmHYg.png" /><figcaption><em>Before and after the UI3 update for the </em><strong><em>Ignored elements</em></strong><em> section</em></figcaption></figure><p>Some rules repeat across different issue groups, while others are unique to a specific group.</p><p>There are 20 rules in total, but since some share the same icon, I ended up with 16 unique icons for ignored elements.</p><p>I tried to reuse Figma’s native icons wherever possible, but clarity always came first — so I created a few custom icons as well.</p><figure><img alt="Examples of native and custom icons for ignored elements, showing a mix of Figma’s native icons (like the eye icon for hidden layers) and custom-designed icons for specific rules" src="https://cdn-images-1.medium.com/max/1024/1*3N2-GT8D75mB07kVsiMq0A.png" /><figcaption><em>All icons for </em><strong><em>Ignored elements</em></strong><em> section</em></figcaption></figure><p>This update made the section much more visually appealing, and it helps users quickly understand which rules apply to the issues they see in the plugin.</p><h3>5. FigLint icon</h3><p>There was one more element that needed an update — the <strong>FigLint icon</strong> itself. From the very beginning, I wanted the entire plugin to feel like a natural part of Figma’s UI. I didn’t want to introduce a new design language. For all my plugin icons, I used the Figma <strong>brand color</strong> (for light mode), and the icon followed the same rules as Figma’s icons — just at a larger scale.</p><p>At first, I explored more meaningful icons that might capture the essence of the plugin. In the end, though, I chose a very generic <strong>checkmark icon</strong> — the same kind you see in the details view when there are no issues found for a particular group. <strong>That’s the goal</strong>, after all.</p><figure><img alt="Screenshot of the details view in FigLint showing the checkmark icon next to the message “Well done! No layers with this issue”" src="https://cdn-images-1.medium.com/max/1024/1*b_WJEUIWXm5ZgTkTSDakQQ.png" /><figcaption><em>Most desirable view in the FigLint plugin: no issues found!</em></figcaption></figure><p>The checkmark icon in Figma’s UI has an <strong>acute angle</strong>, which works well at smaller sizes. That’s why I used it for the success screen. But for the plugin icon, I wanted something a bit more symbolic and geometric, so I changed the angle to 90°. As with most shapes like this, there was some <strong>trial‑and‑error</strong>with positioning and sizing, but I think it turned out well.</p><p>All these decisions were made even before the UI3 update. So, the only thing I had to do was update the line caps to be rounded — just like all the other icons in UI3.</p><figure><img alt="FigLint plugin icon before the UI3 update, and with rounded line caps after the update, showing a more polished and consistent look" src="https://cdn-images-1.medium.com/max/1024/1*Hra68vI_tzGTHyPdLcCbPw.png" /><figcaption><em>Just a gentle update of the line caps</em></figcaption></figure><p>I didn’t realize how many decisions were hiding inside a seemingly small icon update. But I think it was worth it: the plugin now looks fresher and more consistent with Figma UI3, which was always my goal.</p><p>This <em>small exercise</em> helped me understand UI3 better, appreciate the craft behind Figma’s iconography (kudos to <a href="https://medium.com/u/e38bd7313673">Tim Van Damme</a> and the <a href="https://medium.com/u/bf1152b11387">Figma</a> team), and explore new ways to use the Figma API to keep design and code in sync.</p><blockquote>And, of course, I encourage you to try out the <a href="https://www.figma.com/community/plugin/1323794044088972088/figlint"><strong>FigLint</strong></a> plugin if you haven’t already.</blockquote><p>If you have any questions, suggestions, or feedback — about the icons update or the plugin in general — feel free to reach out.</p><p>Thank you for reading. I hope you found this article useful!</p><p>Happy designing!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1c13ecb9606b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FigLint UI3 Icons Update (Part 2/3): Figma-to-Code Script]]></title>
            <link>https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-2-3-figma-to-code-script-5f20e454ebba?source=rss-c2dfda8c690a------2</link>
            <guid isPermaLink="false">https://medium.com/p/5f20e454ebba</guid>
            <category><![CDATA[icons]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[figma-plugin]]></category>
            <dc:creator><![CDATA[Marcin Ukleja]]></dc:creator>
            <pubDate>Thu, 12 Feb 2026 09:14:43 GMT</pubDate>
            <atom:updated>2026-02-12T09:14:43.580Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Series cover showing three parts: Part 1 (Figma Plugin UI Kit), Part 2 (Figma‑to‑Code Script) highlighted, and Part 3 (Icon Design)" src="https://cdn-images-1.medium.com/max/1024/1*7aTJChzHtMta112sWINRfA.png" /></figure><p><a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-1-3-figma-plugin-ui-kit-67eb92a0c9f7">Part 1. Figma Plugin UI Kit</a><strong><br>Part 2. Figma‑to‑Code Script</strong><br><a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-3-3-icon-design-1c13ecb9606b">Part 3. Icon Design</a></p><p>This is <strong>Part 2</strong> of a <strong>3‑part series</strong> on updating “just” the icons in my Figma plugin, <strong>FigLint</strong>, to match Figma’s design language, <strong>UI3</strong>. The work itself happened a while ago — early in <strong>UI3</strong>’s rollout — and what began as a small cleanup grew into refining my design library, building a Figma‑to‑Code pipeline, and refreshing the plugin UI.</p><figure><img alt="Banner: FigLint — Check your designs for common issues, layer‑by‑layer" src="https://cdn-images-1.medium.com/max/1024/1*X4SmG3ITF9sia8VZ8SSKJQ.png" /><figcaption>Try <a href="https://www.figma.com/community/plugin/1323794044088972088/figlint"><strong>FigLint</strong> on Figma Community</a></figcaption></figure><p>This series is dedicated to craft — clear systems, careful icon work, and practical plugin development — rather than the latest powerful AI workflows. If that resonates, you’ll enjoy it.</p><p>In <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-1-3-figma-plugin-ui-kit-67eb92a0c9f7">Part 1</a>, I described retrieving, structuring, and normalizing the icons in my <strong>Figma Plugin UI Kit</strong>. While many icons remain static, the design and development process often requires tweaking existing icons, adding new ones, or removing them. To manage updates efficiently, I built a script to keep the icons in my codebase <strong>synchronized</strong> with the Figma library.</p><p>The process required multiple steps to handle correctly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*O76ozO84RllKO3rQjxolhA.png" /></figure><p>Whenever I need to update the icons in my codebase, I run a script that performs the following steps:</p><ol><li>Authorizing</li><li>Fetching</li><li>Normalizing</li><li>Saving</li><li>Subsetting</li><li>Reporting</li></ol><blockquote><strong>Note:</strong> The code shown below is <strong>pseudo‑code</strong> for illustration purposes. The actual implementation is more complex, utilizing multiple libraries and bundlers, and includes additional error handling and validation.</blockquote><h3>1. Authorizing</h3><p>Before the script can access the Figma file, it must first be authorized. The script initializes with an <em>environment</em> configuration containing 2 variables: <strong>file ID</strong> and <strong>access token</strong>.</p><p>In addition, one of the first steps is to set up a <em>client</em> to <em>talk</em> to the Figma API. I used <strong>Axios</strong> for that.</p><pre>// Define type for environment variables<br>type EnvConfig = {<br>  fileId: string;<br>  accessToken: string;<br>};<br><br>// Get file ID and Access Token<br>// In real code this uses secure environment variables<br>const envConfig: EnvConfig = getEnvConfig();<br><br>// Get file using Figma API<br>// In real code this is more complex, and uses Axios and Figma REST API<br>const file = getFile(envConfig);</pre><h3>2. Fetching</h3><p>Once the script has access to the Figma file, it begins <strong>scanning for icons</strong>. The first step locates the page containing all icons by matching the page name: Icons.</p><pre>// Get the icons page<br>const iconsPage = file.document.children.find((page) =&gt; page.name === &quot;Icons&quot;);</pre><p>Next, it scans the page’s <strong>child nodes</strong> to find components — these are the actual icons to import.</p><p>The script <strong>filters out</strong> components and containers whose names begin with _ or ., following a convention similar to Figma&#39;s component publishing settings.</p><p>The script also tracks the <strong>parent container node</strong> (either a section or a frame) to establish the folder structure, and normalizes names to make them code‑friendly (very similar to <em>kebab-case</em> style). For example, Medium / Chevron becomes medium/chevron, and Component set becomes component-set.</p><pre>// Define type for icon object<br>type Icon = {<br>  parentPath: string; // derived from the single container name<br>  name: string;<br>  svgContent: string; // SVG content as string<br>};<br><br>// Array to hold all icons<br>const icons: Icon[] = [];<br><br>// Helper to check if node should be excluded<br>const isHidden = (name: string) =&gt; name.startsWith(&quot;_&quot;) || name.startsWith(&quot;.&quot;);<br><br>// Collect icons (each icon is a component nested within a container)<br>iconsPage.children.forEach((container) =&gt; {<br>  if (isHidden(container.name)) return;<br>  container.children.forEach((component) =&gt; {<br>    if (isHidden(component.name)) return;<br>    // Get SVG content for each icon (component) using Figma API<br>    const svgContent = getSvgContent(envConfig, component.id);<br>    icons.push({<br>      parentPath: normalizePath(container.name),<br>      name: toKebabCase(component.name),<br>      svgContent: svgContent,<br>    });<br>  });<br>});</pre><h3>3. Normalizing</h3><p>Once the script retrieves all the icons, structures them, and renames them, it can start normalizing and optimizing their <strong>content</strong> — which is basically an SVG file.</p><pre>&lt;svg width=&quot;16&quot; height=&quot;16&quot; viewBox=&quot;0 0 16 16&quot; fill=&quot;none&quot; xmlns=&quot;http://www.w3.org/2000/svg&quot;&gt;<br>  &lt;path<br>    fill-rule=&quot;evenodd&quot; clip-rule=&quot;evenodd&quot;<br>    d=&quot;M13.8536 4.64645C14.0488 4.84171 14.0488 5.15829 13.8536 5.35355L7.35355 11.8536C7.15829 12.0488 6.84171 12.0488 6.64645 11.8536L2.64645 7.85355C2.45118 7.65829 2.45118 7.34171 2.64645 7.14645C2.84171 6.95118 3.15829 6.95118 3.35355 7.14645L7 10.7929L13.1464 4.64645C13.3417 4.45118 13.6583 4.45118 13.8536 4.64645Z&quot;<br>    fill=&quot;#CB0B96&quot;/&gt;<br>&lt;/svg&gt;</pre><blockquote>There are ready‑made libraries for optimizing SVG files, such as <strong>SVGO</strong>, but I didn’t need that level of complexity.</blockquote><p>At this step, the script <strong>removes the colors</strong> applied in Figma and replaces all fill attributes with currentColor. This allows icons to inherit their color from the parent element at runtime, a standard practice in web development.</p><p>Additionally, the script applies the proper <strong>class</strong> to the glyph layer based on its <strong>id</strong> (which corresponds to the Primary or Secondary layer name from Figma). This is recommended to ensure duotone icons can receive the correct colors later.</p><pre>// Function to normalize SVG content<br>function normalizeSvg(svgContent: string): string {<br>  // In real code this uses a DOM parser<br>  const svgElement = parseSvg(svgContent);<br>  const allElements = svgElement.getElementsByTagName(&quot;*&quot;);<br><br>  for (const el of allElements) {<br>    // Replace any fill color with currentColor<br>    if (el.hasAttribute(&quot;fill&quot;)) {<br>      el.setAttribute(&quot;fill&quot;, &quot;currentColor&quot;);<br>    }<br>    // Convert special IDs to CSS classes<br>    if (el.id === &quot;Primary&quot;) {<br>      el.removeAttribute(&quot;id&quot;);<br>      el.classList.add(&quot;primary&quot;);<br>    } else if (el.id === &quot;Secondary&quot;) {<br>      el.removeAttribute(&quot;id&quot;);<br>      el.classList.add(&quot;secondary&quot;);<br>    }<br>  }<br>  return svgElement.toString();<br>}<br><br>// Iterate over all icons and normalize their SVG content<br>for (const icon of icons) {<br>  icon.svgContent = normalizeSvg(icon.svgContent);<br>}</pre><h3>4. Saving</h3><p>After the icons are normalized and optimized, they are ready to be saved to the codebase. The script creates a <strong>folder structure</strong> based on the icons’ structure in Figma and saves each icon as an <strong>individual file</strong>.</p><pre>// Iterate over all icons and save them to the codebase<br>icons.forEach((icon) =&gt; {<br>  const iconsPath = `/absolute/path/to/icons`;<br>  const fullPath = `${iconsPath}/${icon.parentPath}/${icon.name}.svg`;<br>  // In real code this uses fs module to write files to the filesystem<br>  saveSvgToFile(icon.svgContent, fullPath);<br>});</pre><h3>5. Subsetting</h3><p>After importing, normalizing, and saving the icons, one additional step remains. Most plugins don’t require the entire icon library — only specific subsets, primarily for <strong>performance optimization</strong>.</p><p>Reusable subsets are defined to map logical groupings of icons for convenient code imports. For example, the layers subset groups all icons representing layer types, such as Frame, Text, or Component.</p><p>Subsets can be defined either by listing <strong>specific icons</strong> or by referencing <strong>entire folders</strong>. This flexibility allows for efficient management of icons based on the plugin’s needs.</p><pre>// Subset configuration<br>const iconSubsets = {<br>  // Selection of specific icons from different folders<br>  navigation: {<br>    icons: [<br>      &quot;medium/common/menu.svg&quot;, // hamburger menu<br>      &quot;medium/chevron/left.svg&quot;, // back navigation<br>      &quot;medium/symbol/x.svg&quot;, // close icon<br>    ],<br>  },<br>  // All icons from a specific folder<br>  layers: {<br>    folder: &quot;small/layer&quot;, // all icons representing layer types<br>  },<br>};<br><br>// Build maps from the subsets (implementation defined elsewhere)<br>generateIconMaps(iconSubsets);</pre><p>The <strong>categorized icon structure</strong> established in Figma library (see <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-1-3-figma-plugin-ui-kit-67eb92a0c9f7">Part 1. Figma Plugin UI Kit</a>) provides immediate value here. Subsets can reference entire folders — such as the layers folder – that map directly to Figma&#39;s organizational structure, making it straightforward to import only the icons needed for each component or feature.</p><h3>6. Reporting</h3><p>The script <strong>runs in the terminal</strong> as independent code (Node.js), separate from Figma. To track what occurred during execution, the script generates a <strong>detailed report</strong> showing which icons were processed and any issues encountered.</p><figure><img alt="Screenshot of a terminal showing clear, structured, and color-coded output of a script execution, reporting steps including authorizing, fetching, normalizing, saving, subsetting, and reporting results: 448 icons processed, with 2 added, 1 updated, 1 deleted, 445 skipped" src="https://cdn-images-1.medium.com/max/1024/1*MhXRQIxaPmxQVu-6glLjoQ.png" /><figcaption><em>Terminal output structured and styled for clear, readable reporting</em></figcaption></figure><p>I have to admit, transforming raw terminal logs into something more user‑friendly, ultimately useful, and beautiful is a satisfying <strong>intersection of design and development</strong> for me.</p><p>This automated workflow ensures that whenever icons are updated in Figma, the latest versions can be retrieved and integrated into the codebase <strong>without manual exporting</strong>, keeping design and code <strong>synchronized</strong>.</p><p>Thank you for reading! In <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-3-3-icon-design-1c13ecb9606b">Part 3</a>, I’ll dive into the <strong>design decisions</strong> and reasoning behind updating each icon set in FigLint to match Figma’s UI3 design language.</p><blockquote>And, of course, I encourage you to try out the <a href="https://www.figma.com/community/plugin/1323794044088972088/figlint"><strong>FigLint</strong></a> plugin if you haven’t already.</blockquote><p>Happy coding!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5f20e454ebba" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[FigLint UI3 Icons Update (Part 1/3): Figma Plugin UI Kit]]></title>
            <link>https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-1-3-figma-plugin-ui-kit-67eb92a0c9f7?source=rss-c2dfda8c690a------2</link>
            <guid isPermaLink="false">https://medium.com/p/67eb92a0c9f7</guid>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[icons]]></category>
            <category><![CDATA[figma-plugin]]></category>
            <dc:creator><![CDATA[Marcin Ukleja]]></dc:creator>
            <pubDate>Thu, 12 Feb 2026 09:14:14 GMT</pubDate>
            <atom:updated>2026-02-12T09:14:14.611Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="Series cover showing three parts: Part 1 (Figma Plugin UI Kit) highlighted, Part 2 (Figma‑to‑Code Script), and Part 3 (Icon Design)" src="https://cdn-images-1.medium.com/max/1024/1*Ydj4hU1KYLYGKSGY6U2RgA.png" /></figure><p><strong>Part 1. Figma Plugin UI Kit<br></strong><a href="http://marcinukleja.com/">Part 2. Figma‑to‑Code Script</a><br><a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-3-3-icon-design-1c13ecb9606b">Part 3. Icon Design</a></p><p>This is <strong>Part 1</strong> of a <strong>3‑part series</strong> on updating “just” the icons in my Figma plugin, <strong>FigLint</strong>, to match Figma’s design language, <strong>UI3</strong>. The work itself happened a while ago — early in <strong>UI3</strong>’s rollout — and what began as a small cleanup grew into refining my design library, building a Figma‑to‑Code pipeline, and refreshing the plugin UI.</p><figure><img alt="Banner: FigLint — Check your designs for common issues, layer‑by‑layer" src="https://cdn-images-1.medium.com/max/1024/1*X4SmG3ITF9sia8VZ8SSKJQ.png" /><figcaption>Try <a href="https://www.figma.com/community/plugin/1323794044088972088/figlint"><strong>FigLint</strong> on Figma Community</a></figcaption></figure><p>This series is dedicated to craft — clear systems, careful icon work, and practical plugin development — rather than the latest powerful AI workflows. If that resonates, you’ll enjoy it.</p><p>When I started updating FigLint (and other plugins), I usually began in Figma, designing the key plugin views (I now do both design and development in code, which isn’t relevant for this article). But the <strong>Figma Plugin UI Kit</strong> I created back then is still useful: it now includes most UI3 components and over 300 icons, and I use it for educational purposes and illustrations for articles like this one.</p><figure><img alt="Figma Plugin UI Kit library cover with various UI3 components" src="https://cdn-images-1.medium.com/max/1024/1*ZxsdXDwLkl9SfN87GWFCog.png" /><figcaption><em>Self‑made </em><strong><em>Figma Plugin UI Kit</em></strong><em> library with UI3 components and 300+ icons</em></figcaption></figure><p>In this part, I’ll share how I rebuilt the icon components in the library — from retrieving icons from Figma’s interface to structuring and normalizing them for seamless use in both Figma and code.</p><ol><li>Retrieving the icons</li><li>Defining icon sizes</li><li>Structuring the icon set</li><li>Normalizing the icons</li></ol><h3>1. Retrieving the icons</h3><blockquote>With no <a href="https://www.figma.com/community/file/1486123838948777078/ui3-figmas-ui-kit">UI3: Figma’s UI Kit</a> available at the time, I had to choose my own workflow to extract the icons. Now, the process would be much simpler.</blockquote><h4>Batch extraction</h4><figure><img alt="Batch extraction flow: HTML (Source code of Figma app) →  AI script (Simple prompt for extracting SVGs) →ZIP file (SVG files of all icons from HTML)" src="https://cdn-images-1.medium.com/max/1024/1*VQwJncEDuAdBoJb0YghQKw.png" /></figure><p>First, I wanted to gather as many icons as possible from Figma’s interface in one go. All the icons in Figma’s UI are <strong>in‑line SVG assets</strong>, so I copied the entire web app using dev tools, pasted it into ChatGPT, and asked it to extract all the SVG icons. After a few seconds, I got a zip file with over 50 unique icons.</p><p>That still wasn’t the complete set, since many icons weren’t visible when I captured it. I repeated the process for different states, but still missed a lot.</p><p>For smaller batches from menus or dropdowns, I wrote a <strong>short script</strong> to grab all SVG elements from copied HTML and save them as individual files. I turned it into a <strong>Raycast Script Command</strong>, which made the process much faster.</p><blockquote>If you don’t know <a href="https://raycast.com/"><strong>Raycast</strong></a> — a handy launcher app like Spotlight for macOS — I highly recommend checking it out.</blockquote><h4>Manual extraction</h4><figure><img alt="Manual extraction flow: SVG element (Selected in dev tools) → Copy (Actual SVG code) → Paste (SVG code pasted in Figma as vector)" src="https://cdn-images-1.medium.com/max/1024/1*5g5HM4dC6Yzut-UO5v50AA.png" /></figure><p>For some individual icons, I switched to the manual <em>copy‑paste</em> method. It’s not very efficient, but it’s straightforward:</p><ol><li>Select the icon using dev tools.</li><li>Copy the SVG element from the DOM tree.</li><li>Command+V in Figma.</li></ol><p>It’s definitely not practical for getting a large number of icons, but I found inspecting the code to be a surprisingly insightful experience.</p><h4>Custom creation</h4><figure><img alt="Custom creation flow: Custom-made (Icon made using Figma tools)" src="https://cdn-images-1.medium.com/max/1024/1*iCdhvwRfGd_9pkc4zCV9ZA.png" /></figure><p>Existing Figma icons are very useful for the universal Plugin UI Kit, but the FigLint plugin also uses some <strong>custom icons</strong>, so I had to create them manually. The rules that Figma follows for their iconography aren’t rocket science, so it was quite easy to jump‑in.</p><p>I have a lot of respect for Figma’s iconography, mainly designed by <a href="https://medium.com/u/e38bd7313673">Tim Van Damme</a>. Creating a set like this takes real skill and experience.</p><blockquote>If you’re interested in the FigLint icon design itself, check out <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-3-3-icon-design-1c13ecb9606b">Part 3. Icon Design</a> of this series, where I share the design decisions behind it.</blockquote><h3>2. Defining icon sizes</h3><p>Icons in Figma’s UI appear in 3 variants:</p><ul><li><strong>24px</strong> — used as the largest icons for specific purposes, like the bottom toolbar.</li><li><strong>24px Small</strong> — the most common icons, mainly used on icon buttons; many can be found in the Design panel, for instance.</li><li><strong>16px</strong> — used in condensed contexts, like the layers list.</li></ul><blockquote>The names of the variants originate from <a href="https://www.figma.com/community/file/1486123838948777078">Figma’s official UI3 Kit</a>, which was not available when I began building my library.</blockquote><figure><img alt="Figma interface showing UI3 icons with 3 different sizes: 24px (Headers and Toolbar), 24px Small (Icon buttons and more…), 16px (Layers)" src="https://cdn-images-1.medium.com/max/1024/1*SR4Q9UrUCsu6ynyvtR-whQ.png" /><figcaption><strong><em>Three</em></strong><em> UI3 icon sizes as they appear across the Figma interface</em></figcaption></figure><p>I found the specification and naming a bit confusing. They don’t seem to pair well with the interface text size.</p><p>In my opinion, the icon size should correspond to the font size it accompanies. I typically follow this guideline: the icon’s <strong>bounding box</strong> (not the glyph) should match the text’s <strong>line height</strong>. The <strong>glyph</strong> should fit within that box with some padding, resulting in a shape that is slightly larger than the font’s <strong>cap height</strong>.</p><figure><img alt="Diagram illustrating icon size being equal to text line height" src="https://cdn-images-1.medium.com/max/1024/1*Ca9RNM2KE0wirs23mhYU-A.png" /><figcaption>Relationship between <strong>icon size</strong> and text <strong>line height</strong></figcaption></figure><p>It’s a very <strong>general guideline</strong>, but I won’t dive deeper here. Let’s focus on the adjustments I made to the icon sizes in my library.</p><h4>24px → Large</h4><p>The 24px icons in Figma UI are used mainly in the <strong>bottom toolbar</strong> and in key places like <strong>panel headers</strong>. Since I was building a UI Kit for plugin interfaces, neither of these contexts was very relevant, so I decided to <strong>drop</strong> the 24px size entirely.</p><figure><img alt="“24px” UI3 icon renamed to “Large” and hidden from general use" src="https://cdn-images-1.medium.com/max/1024/1*kDmlE2yVeg1SqD9_9c98BQ.png" /><figcaption>“<strong>24px</strong>” UI3 icons renamed to “<strong>Large</strong>” and <strong>hidden</strong> from the general use</figcaption></figure><p>Over time, I found that for educational purposes — where I recreate Figma’s UI — I still needed these icons. I kept them in the library, named them Large, <strong>hid</strong> them from publishing, and used them only in fixed elements like the bottom toolbar.</p><h4>24px Small → Medium</h4><p>The most common icon size in Figma’s UI is called 24px Small – it’s still 24×24 pixels, but the glyphs are smaller than in the 24px icons. These icons appear on many icon buttons, primarily in the right sidebar.</p><p>The 24px size is common in many interfaces, but Figma is not typical – it’s a professional design tool with dense controls and a compact layout. Typography is comparatively small: the base font size is 11px, while many interfaces use 14px, 16px, or larger.</p><p>This compactness should also be reflected in the icon size, so I decided to <strong>crop</strong> all icons to 16×16 pixels while keeping the glyphs unchanged. This still ensures 1–2‑pixel padding around the glyphs, which is usually sufficient.</p><p>This 16px size is not a coincidence; it corresponds to the line height of the default 11px font size in Figma’s UI.</p><figure><img alt="“24px Small” UI3 icon renamed to “Medium” and cropped to 16×16" src="https://cdn-images-1.medium.com/max/1024/1*xRWVIbPAbv2-VRLaH0cwmg.png" /><figcaption>“<strong>24px Small</strong>” UI3 icons renamed to“<strong>Medium</strong>” and <strong>cropped</strong> to 16×16 px</figcaption></figure><p>Since this is the most popular icon size in the interface — and it pairs with the default font size of 11px– I simply named it Medium.</p><h4>16px → Small</h4><p>Figma also uses smaller icons: 16×16 with 2–3‑pixel padding around the glyphs. They appear in the Layers panel for layer symbols and in a few other places that need more compact layouts.</p><p>These compact layouts keep the same font size of 11px – so 16×16 icons pair well. I kept them <strong>as‑is</strong>.</p><p>Since I wanted to drop numeric naming in favor of more semantic, descriptive names, I named this size Small.</p><figure><img alt="“16px” UI3 icon renamed to “Small” and kept as‑is" src="https://cdn-images-1.medium.com/max/1024/1*IZvEy9Xi1mJvdwCaQJtK_g.png" /><figcaption>“<strong>16px</strong>” UI3 icons renamed to “<strong>Small</strong>” and kept <strong>as-is</strong> (16×16 px)</figcaption></figure><p>At this point, I ended up with 3 icon sizes in my library:</p><ul><li><strong>Large</strong> — 24×24 pixels, hidden from publishing, used only in fixed elements like the bottom toolbar.</li><li><strong>Medium</strong> — 16×16 pixels, the most common size, paired with the default 11px font size.</li><li><strong>Small</strong> — 16×16 pixels, with smaller glyphs, used in compact contexts, also paired with the 11px font size.</li></ul><h3>3. Structuring the icon set</h3><p>When it comes to icons, I always face a dilemma about which approach works best: a flat or categorized structure.</p><h4>Flat</h4><figure><img alt="Icons arranged flat, without any grouping" src="https://cdn-images-1.medium.com/max/1024/1*uhhlIXGodfVMT-1ix7vjXg.png" /><figcaption><strong><em>Flat</em></strong><em> structure with no groups, just a long list of icons</em></figcaption></figure><p>A flat structure, without folders, is very easy to implement. Instead of using <em>folders</em>, icons can be grouped using - or ., creating a kind of hierarchy and better organization. The flat structure has one potential advantage in Figma: when choosing an icon, you always see the full list of available icons, which might be an easier solution for browsing in some cases.</p><p>However, I suspect most users <strong>search</strong> for icons rather than <strong>browse</strong> through them. Figma now has a really great AI‑supported search that not only matches the name or description but also analyzes the icon glyph itself.</p><h4>Categorized</h4><figure><img alt="Icons categorized into groups" src="https://cdn-images-1.medium.com/max/1024/1*uSaXLBrjaF9I0pkKRg9jtw.png" /><figcaption><em>Icons </em><strong><em>categorized</em></strong><em> into frames/sections based on their purpose and context of use</em></figcaption></figure><p>On the other hand, a categorized structure organizes icons in <em>folders</em> — either by using slashes (/) in their names or by wrapping them in frames or sections. In the Figma UI, you need to open each folder to see the icons, but you can also search for them and ignore the structure entirely.</p><p>Categories offer one clear advantage over a flat structure: they help <strong>limit the default choices</strong> when you swap an icon in a component for another. For example, if you’re changing the icon of a layer (which probably already sits in a Layer “folder”), you’ll first see only icons from the Layer “folder”. This makes picking the right icon much easier.</p><p>There’s also a technical benefit: when implementing icons in code, you usually want to import <strong>only the icons you actually use</strong> in the UI — not the whole library. Well‑structured categories let you import just the categories you need, making it much easier to manage your code and keep the bundle size down.</p><p>As you might expect, I chose the <strong>categorized structure</strong>. I’m still not completely sure about some of the groupings and names, but I can always tweak them later if needed.</p><h3>4. Normalizing the icons</h3><p>To achieve a consistent look and a uniform technical implementation, all icons should follow the same rules for <strong>naming</strong>, <strong>structure</strong>, and default visual <strong>appearance</strong>.</p><h4>Icon names</h4><p>I prefer user‑friendly names <strong>inside Figma</strong> and code‑friendly names <strong>in the code</strong>. Using lowercase for icon names reduces scannability and readability in the Figma UI. So instead of naming an icon align/horizontal-centers, I use Align / Horizontal centers. Here are the rules I follow:</p><ol><li>Capitalize the first letter of each structure level.</li><li>Separate words with spaces.</li><li>Surround slashes (/) with spaces for better readability on the canvas; later this didn’t matter, since icons are grouped in sections.</li></ol><figure><img alt="Comparison of icon name in Figma (“Align / Horizontal centers”) and in code (“align/horizontal-centers”)" src="https://cdn-images-1.medium.com/max/1024/1*dd5phOp-vxo75C-O8ZrkIw.png" /><figcaption><strong><em>Human-friendly</em></strong><em> names in Figma, </em><strong><em>code-friendly</em></strong><em> names in the codebase</em></figcaption></figure><p>Converting these to code‑friendly names is simple — I’ll cover that in the <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-2-3-figma-to-code-script-5f20e454ebba">Part 2. Figma‑to‑Code Script</a>.</p><h4>Glyph layers</h4><p>Even though I usually created custom icons from strokes, I ensured that icon glyphs were <strong>flattened</strong> into a single shape layer. Any exceptions made the icons harder to use in Figma and implement in code.</p><p>However, if you want to keep the original strokes for potential future edits, you can combine them into a single vector using <strong>boolean operations</strong> (most commonly Union), and everything should work well in Figma.</p><figure><img alt="Icon glyph drawn in 2 ways: with strokes (not recommended) and with filled shapes (recommended)" src="https://cdn-images-1.medium.com/max/1024/1*7v26ySMm2Ad-VvIJH4OfYA.png" /><figcaption><strong><em>Filled shapes</em></strong><em> are easier to work with than raw </em><strong><em>strokes</em></strong></figcaption></figure><p>A common naming pattern for the flattened vector layer is Icon, Vector, or Glyph. Some of Figma’s UI3 icons are <strong>duotone</strong>, meaning they have two layers. Therefore, I used Primary and optionally Secondary for the layer names. This approach allowed me to color both layers separately in Figma and in code.</p><figure><img alt="Layers panel showing icon with “Primary” and “Secondary” vector layers" src="https://cdn-images-1.medium.com/max/1024/1*y3Exi532yEqee7m_cOfDig.png" /><figcaption><strong><em>Two separate layers</em></strong><em> are required to handle duotone icons</em></figcaption></figure><p>With 2 layers, <strong>order matters</strong>. I ensured that Primary is always above the Secondary layer.</p><h4>Icon size</h4><p>Having all icons at 16×16 pixels didn’t cover all my use cases. I wanted icons to <strong>scale up in some contexts</strong>, such as empty states or full‑screen messages.</p><figure><img alt="Plugin low-fidelity view with the same icon used in different contexts: small icon in the list and larger icon in the empty state" src="https://cdn-images-1.medium.com/max/1024/1*VWfUvc1BV-KJ6DV8qIvhLw.png" /><figcaption><strong><em>One icon, two contexts</em></strong><em>: list item and empty state</em></figcaption></figure><p>I didn’t want to create separate icons for larger sizes, so I set <strong>constraints</strong> on all glyph layers to Scale, so they would resize proportionally when the icon frame is resized.</p><figure><img alt="Design panel with Scale constraints applied to glyph layer" src="https://cdn-images-1.medium.com/max/1024/1*QloslmKEOFatqfUT1czKVA.png" /><figcaption><strong><em>Scale constraints</em></strong><em> keep glyph proportions when resizing</em></figcaption></figure><h4>Layer colors</h4><p>First, I ensured all icons had <strong>no background</strong>. Even a hidden #FFFFFF fill counts as an issue for me, so I removed it.</p><p>For the glyph fill, I intentionally avoided using any color variables intended for final components — I wanted the icons to be <strong>context‑agnostic</strong>. This approach is similar to Text Styles, which don’t store color in the style itself; <strong>color is applied in context</strong>.</p><p>To ensure I <strong>never forget to overwrite icon color</strong> in components, I chose distinctive colors. I also wanted them to fit the library’s color palette (for my own sake), so I selected colors from the less‑used options within Figma’s palette.</p><p>Additionally, I named these utility color variables with a clear call to action: OVERWRITE ME.</p><p>For <strong>duotone icons</strong>, I used the same color for both Primary and Secondary glyphs, but gave the Secondary layer 30% opacity. Alternatively, I could control the Secondary layer’s color with its own dedicated variable, but for this library, I found a one‑color solution sufficient.</p><figure><img alt="Icon selected, and pink “OVERWRITE ME” color variable visible in “Selection colors” section" src="https://cdn-images-1.medium.com/max/1024/1*b4Qk9RWQzyvWfPifv-BhoA.png" /><figcaption><em>Utility </em><strong><em>OVERWRITE ME</em></strong><em> color variable reminds to set the final color in context</em></figcaption></figure><p>I also decided to <strong>distinguish the size</strong> of the icons by using different colors for Small (orange), Medium (pink), and Large (teal) icons. This helps me quickly identify the size of an icon when browsing through the library or swapping the icon instance, as it’s not always easy to guess the size just by looking at the glyph.</p><figure><img alt="“Choose instance” picker showing icons with different colors based on their size" src="https://cdn-images-1.medium.com/max/1024/1*88HsaJM479zwNsxI5DVd8A.png" /><figcaption><em>Color-coded icons sizes help to quickly identify the right icon</em></figcaption></figure><p>It’s worth noting that all of these normalizations could be time‑consuming if done manually, so <strong>I automated the process with a simple Figma plugin</strong> I created specifically for this purpose.</p><p>By preparing the icons in this way, I ensured they are ready for use in Figma and code. In the next part, I’ll show you how I automated the process of <strong>exporting these icons from Figma to my codebase</strong>, making it easy to keep them up to date with any future changes.</p><p>Thank you for reading! If you are interested in the methods I used to automate the export of icons from Figma to code, check out <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-2-3-figma-to-code-script-5f20e454ebba">Part 2. Figma‑to‑Code Script</a> or jump right to <a href="https://medium.com/@marcinukleja/figlint-ui3-icons-update-part-3-3-icon-design-1c13ecb9606b">Part 3. Icon Design</a> to learn about the design decisions behind the FigLint icons.</p><blockquote>And, of course, I encourage you to try out the <a href="https://www.figma.com/community/plugin/1323794044088972088/figlint"><strong>FigLint</strong></a><strong> </strong>plugin if you haven’t already.</blockquote><p>Happy designing!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67eb92a0c9f7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Text different: 5 ideas for bringing a unique experience to messaging]]></title>
            <link>https://uxdesign.cc/text-different-8611ec47dc9?source=rss-c2dfda8c690a------2</link>
            <guid isPermaLink="false">https://medium.com/p/8611ec47dc9</guid>
            <category><![CDATA[facebook-messenger]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[messaging]]></category>
            <category><![CDATA[sms]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Marcin Ukleja]]></dc:creator>
            <pubDate>Thu, 13 Sep 2018 07:41:14 GMT</pubDate>
            <atom:updated>2018-09-14T08:36:02.118Z</atom:updated>
            <content:encoded><![CDATA[<h4>My thoughts on alternative texting experience to most-known and heavy-used messaging services.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ldCB0w3yhufDmocPg3aKKg.png" /></figure><p>First SMS message was sent in 1992, so more than 25 years ago. Despite (or due to) it’s simplicity and limitations it’s available on every mobile device nowadays — no matter it’s original Nokia 3310 (the year 2000) or brand new iPhone XS Max.</p><p>Simultaneously, most of us use feature-bloated services like iMessage, Messenger or WhatsApp. They allow us to send not only (longer) text messages, but photos as well… videos, GIFs, stickers, location, money… we can customize every conversation, see the activity status of our friends and the messages we sent. And more features are still coming.</p><p>Delivering many possibilities and offering <strong>more</strong> versatility, makes our experience <strong>less</strong> distinctive, not so unique. We could simply say:</p><blockquote>More is less.</blockquote><p>Constraints are a great way to boost the uniqueness of experience and the creativity of the user. Not only SMS messages’ 160-character limit does it; so does Twitter (with its tweet limitations), Instagram (with square photos) or Snapchat. I’m going to cover more on this topic in the separate story.</p><p>Thinking of constraints, I came up with a few ideas for text messaging, that force users to behave differently than they became accustomed, which brings them an exceptional experience.</p><h4>1. Give more of yourself</h4><p>We get used to really short messages. Sometimes, they serve their purpose well; they are good when we are in a hurry or we want just to confirm something. Unfortunately, sometimes we expect to receive something more than just cold “OK”, we need an explanation, a bit of richer communication — not rarely more emotional.</p><p>The first idea seems to be straightforward — it is an inverted constraint of SMS:</p><blockquote>Your messages should be at least 160 characters long.</blockquote><p>With such rule, we would be forced to write longer messages, devote more time and attention to someone.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QDKZdp-qm8JBvBdpn5gheg.png" /><figcaption>Your messages should be at least 160 characters long.</figcaption></figure><h4>2. Walkie-talkie</h4><p>Isn’t it frustrating, when you try to answer your friend’s question and in the meantime he or she asks 5 more questions and starts 3 more threads? Isn’t it annoying? Wouldn’t it be nice to mute another person till you finish your message?</p><p>This idea is very simple and works like walkie-talkie:</p><blockquote>You can’t type while your friend is typing. And vice-versa.</blockquote><p>That would end chaotic conversations and interruptions.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*tm_rg2N3fmlOV-AJdJnn5A.png" /><figcaption>You can’t type while your friend is typing. And vice-versa.</figcaption></figure><h4>3. Calm down</h4><p>Emotions are good if managed properly. In intense conversations, they may cause a destructive and immediate outburst. Sometimes it’s good to take a few deep breaths before replying.</p><p>The rule for this idea would be:</p><blockquote>You can’t reply to the message in 15 minutes since reading it.</blockquote><p>That would give you enough time to calm down, think twice and respond wisely.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hvSIQ9asl2EAOnuuTPtR7g.png" /><figcaption>You can’t reply to the message in 15 minutes since reading it.</figcaption></figure><h4>4. Time capsule</h4><p>Waiting for Christmas gifts is a very unique experience; even waiting for a delivery of your new Apple Watch Series 4 is exciting. What if we can make our friends wait for our messages?</p><p>This idea brings an additional feature to any message:</p><blockquote>You can read the message only after the delivery date (set by sender).</blockquote><p>Your friend would know something is coming but will have to wait to discover what it is.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Xlogx8UNCPjYbPMT1XEHLQ.png" /><figcaption>You can read the message only after the delivery date (set by sender).</figcaption></figure><h4>5. Walk your words</h4><p>We probably spend more time on social media than on walking during a day. What if we bind these two activities?</p><blockquote>Walk more to write more. 1 step walked equals 1 character you can send.</blockquote><p>In this case, bumping into other people while walking and staring at the phone would be entirely explainable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EBj7p36KB_KvT8zWDvwmpQ.png" /><figcaption>Walk more to write more. 1 step walked equals 1 character you can send.</figcaption></figure><p>Besides the ideas above I had many others, that might enrich the messaging experience. Hopefully, you will find them interesting and possibly inspirational. I list some of them below.</p><ol><li>You can’t write during work hours.</li><li>You can’t write from work.</li><li>You can read a message only in a location it was sent from.</li><li>You cannot write unless your friend responds.</li><li>You can send only 1 message every 1 hour.</li><li>You cannot write more than 10 messages per day with one person.</li><li>You cannot write with more than 5 friends during a day.</li><li>Your messages will be delivered in 24 hours.</li><li>You cannot write while walking.</li><li>Your messages are visible to everyone.</li><li>Your message is sent to a random user.</li></ol><p>By mentioning all the examples above, I don’t mean that such services should exist as an alternative to currently used ones. In my opinion, they just clearly show that the quality of the experience depends on the quantity of features offered — the <strong>fewer</strong> options service provides, the <strong>more</strong> unique the experience it delivers.</p><blockquote>Less is more.</blockquote><p>I know you might be tired of this phrase (adopted by Ludwig Mies van der Rohe), but I couldn’t resist, cause — as an architect — I believe it can be easily applied to both Architecture and UX Design.</p><p>Thank you.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Ff%2F50d69a%3Fas_embed%3Dtrue&amp;dntp=1&amp;display_name=Upscribe&amp;url=https%3A%2F%2Fupscri.be%2F50d69a%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/05d5fd32eda31cbd1b83287606744532/href">https://medium.com/media/05d5fd32eda31cbd1b83287606744532/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8611ec47dc9" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/text-different-8611ec47dc9">Text different: 5 ideas for bringing a unique experience to messaging</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Architecture vs. (so-called) UX Design]]></title>
            <link>https://uxdesign.cc/architecture-vs-ux-design-6d914091d036?source=rss-c2dfda8c690a------2</link>
            <guid isPermaLink="false">https://medium.com/p/6d914091d036</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[architecture]]></category>
            <dc:creator><![CDATA[Marcin Ukleja]]></dc:creator>
            <pubDate>Sun, 03 Jun 2018 16:05:27 GMT</pubDate>
            <atom:updated>2018-06-11T17:46:13.838Z</atom:updated>
            <content:encoded><![CDATA[<h3>The intersection between Architecture and (so-called) UX Design</h3><h4>My thoughts on designing for the user in the physical and digital world.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ldLSgrrAwGjfZuhqcBlU9w.png" /></figure><p>Hi, this is my very first story on Medium, so I’d like to start with a topic that is very close to me…</p><p>I’m an <strong>Architect</strong> by profession. After graduation, I worked for a few years as an Architect but soon realized that User Experience Design is something I genuinely love to do in my life. Currently, I am Senior <strong>Product Designer</strong> at K2 — Polish digital agency.</p><p>In this article, I’m going to compare Architecture and UX Design and share my thoughts on differences and similarities between these two disciplines.</p><p>For the sake of simplicity I’m going to use term <em>UX</em>, but we all know it’s not the best and proper name for this domain.</p><h3>Differences</h3><p>It is quite obvious that Architecture differs from UX Design. Probably it’s much easier to find differences, but there are still few of them that are worth mentioning giving us a better perspective on this topic.</p><h4>Maturity</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*l7rRYJfXlcuNcRKiGTDGOA.png" /></figure><p>Architecture is with us for ages. First structures that served the housing purpose were <strong>shelters</strong> in the Neolithic period (up to 10 000 BC). In UX Design, I would compare these dwellings to <strong>command-line interfaces</strong> (one of the first means of interacting with computers): they don’t look good, they are not so comfortable/easy to use, but still can satisfy basic needs.</p><p>However, the significant awareness of these two disciplines happened after a while. In Architecture, we can relate it to the first book on the subject of architecture which is “De architectura” by <strong>Vitruvius</strong> dated in 1st century AD. It covered many aspects of design that are valid nowadays. On the other hand, in UX Design, we can think of <strong>Don Norman</strong> and his introduction of the term “user experience” in 1995 (which is more-or-less the evolution of Human-Computer Interaction area).</p><p>Looking at the dates, we can clearly see the disparity in the maturity of these to disciplines; nevertheless, we should remember that dynamic of these two disciplines matter as well.</p><h4>Product</h4><p>For sure it is not surprising that product of both Architecture and UX Design process is something completely different, but it is also good to look at it in terms of analogies.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qLcn9wENOcdEXTqOQiM5EQ.png" /></figure><p>Keep in mind that by UX Design I mean the area that is not pumped by Human Experience, Customer Experience, Product Design or any other terms that are intentionally ignored in this particular comparison.</p><p>So as Architecture delivers <strong>physical</strong> objects, UX Design is responsible for <strong>digital</strong> products. When we think of space as an Architect’s canvas, we can relate it to screen which is the medium for UX Designer. If we go deeper, we will define building (as a very common structure that users interact with) and its digital counterpart — an interface (let’s say of an app)…</p><p>We can easily apply these analogies to other scales (larger or smaller), but I’m going to cover it in one of the similarities below.</p><h4>Process Length</h4><p>That’s a huge difference and the one that played a significant role for me to become UX Designer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*GDi80tmBCm9gjsmtUxkLsg.png" /></figure><p>In Architecture, before you will see the product, the real result of your work, it usually takes <strong>months</strong>, not rarely more than a year (including construction phase). During that time you can deliver dozens of digital products like apps or websites that serve their purpose with sufficient quality. In many cases, you are able to design &amp; develop MVP (minimum viable product) within <strong>days</strong> — this is the significant advantage for impatient designers.</p><h4>Lifespan</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*U0HC9TcTOoOTFvr6QITZYA.png" /></figure><p>As expected, the long process leads to long-lasting product. It’s not unusual to see buildings that are 50 years old… and some of them would probably stand there for another 50 years or more. That might be quite rewarding for an Architect, but it also means huge responsibility for such designer.</p><p>In UX Design it’s easygoing: you design an app, and in a year it would probably be updated to proud version 2.0, to become newer version with a fancy brand new name next year, and then forgotten, sold or died — which is not uncommon for digital products.</p><h4>Research</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XMQJ59xxCdMIi5XINE8tvA.png" /></figure><p>This area is not very flattering for Architects. Their research is mainly about <strong>context</strong> which in theory is not a wrong approach — they care about surroundings, relation to other building, to city space, to street scale, etc. Unfortunately, sometimes there is a lack of user needs research — they are easily interchangeable with business needs, business context. Times when the user needs where priority passed decades ago.</p><p>On the other hand, UX Design doesn’t ignore <strong>user</strong> at all. The design process is often preceded by diligence research, prototypes are tested with users, the finished product is thoroughly analyzed for user traffic and more. There is a business in this process as well but has a much lighter impact on final user experience.</p><h4>Authorship</h4><p>I like this one because it’s a bit controversial.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0sfiZfZcU2OdtvJTO9DyCg.png" /></figure><p>Buildings — unlike paintings — are not usually signed by the Architect’s name. However, we can distinguish many buildings by design “style” and tell the name of the author. And I’m not talking about distinctive individuals like Gaudi, but more “toned” architects like Frank Lloyd Wright, Mies van der Rohe, Zaha Hadid, Norman Foster or Bjarke Ingels (in fact, I wouldn’t call him “toned”). They have their own beliefs, their own ideas, their own means of expression which makes their buildings unique without the loss of quality or usability.</p><p>It is not the case in the most of digital products. Of course it is a different product with different possibilities to express authorship, but still — it’s a significant difference that means a lot to me.</p><h3>Similarities</h3><p>Now it’s time to point similarities. They are not so obvious sometimes, but with a bit of simplifying, we can find some valuable insights that present these two disciplines in the new view.</p><h4>Process</h4><p>Earlier I mentioned that process length is something that differs Architecture from UX Design. However, the phases that happen in this process are easily comparable.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*DuZH8wErB3bPPz33oxPmsA.png" /></figure><p>Aside from strategy phase, in Architecture Design we start with <strong>analysis</strong> — like in UX Design we start with <strong>research</strong>. Later on, we are ready to focus on <strong>usability design</strong> (<strong>function</strong>). And of course, it overlaps and mixes with <strong>aesthetic design</strong> (<strong>form</strong>) but in a similar manner for both disciplines — it iterates, has impact one on another. And at the final stage, there is a time for making the project happen — <strong>construction</strong>/<strong>development</strong>.</p><p>What is also very important here is it’s highly desirable to have author’s <strong>supervision</strong> during the entire process — it assures that the initial idea will be delivered without any deficiency.</p><h4>Intermediate products</h4><p>They are not the same — definitely — but have a lot in common.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*B_LMxq7u8GgLH6n3SD4l3w.png" /></figure><p>A <strong>sketch</strong> is usually the easiest way to start — no matter you sketch the plan of the house or wireframe of an app. Pencil and the paper serve the purpose of either Architect and UX Designer. In UX it is widespread to build <strong>mockups</strong>, but Architects use mockups as well. The objective is kind of different but helps look at the design from another perspective (not rarely literally). <strong>Prototype</strong>, on the other hand, is rather distinctive for UX process — it’s often used for testing which naturally cannot happen while designing, let’s say, huge office space. In both disciplines, we need some <strong>technical documentation</strong> — mostly for construction/development phase — and it’s really comparable here.</p><p>What makes the UX design easier, is that for the entire process your all intermediate products are in real, <strong>1:1 scale</strong> — from very beginning till the end. However it makes digital products a bit less impressive and surprising at the final stage — nothing could be compared to evolution from crude drawing to real building that changes surrounded space for long (and preferably for good).</p><h4>Scalability</h4><p>In this similarity, I will use an example of an app (once again) as UX Design product because it’s very convenient to compare it to a building.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*qWsFVL93VhyDbs7uTCCbPA.png" /></figure><p>As we design, we shouldn’t think only about the scale that we are currently working on. Not only because of the strategy issues (they are essential on a larger scale), but also because on every scale we have opportunity (if not necessity) to express our idea: no matter if it is a view of tasks to be done or a button that adds these tasks — all should be related and consistent. A good building doesn’t look good only from the street view; its idea, style, quality are apparently visible in the space inside, as well in the tiniest details like door handles.</p><h4>Components</h4><p>Similarities are also visible inside the product, within its components but it might be a bit tricky.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*SQgz40ChRc76bO6ppMtzjg.png" /></figure><p>Let’s start with some common web technologies: HTML, CSS, and JavaScript. They all serve its purpose, and all of them have it’s equivalent in Architecture design. If <strong>HTML</strong> is responsible for how it’s built, so building <strong>structure</strong> is it’s analog. When we think of <strong>CSS</strong> and how it looks, it compares to <strong>form</strong> of the building, its materials, facades, etc. <strong>JavaScript</strong> makes it work like a <strong>function</strong> of the building give its real purpose and destiny.</p><p>There is also the choice of technology which plays a significant role in designing both digital products and buildings. It’s accountable for delivering all other components and elements that need to be used.</p><h4>Attitude to affordance</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UEx-9G0Ro4i-a9YbEnZKsQ.png" /></figure><p>Affordance is an essential term in design. It was introduced by psychologist James J. Gibson, but later used by Don Norman in relation to Human-Computer Interaction, which in this context refers to object’s perceived properties that provide (or not) clues how to use it. In simple words: button should look like you can tap it and it will make something happen.</p><p>In architecture, there is a phrase that corresponds with affordance: <em>Form Follows Function</em>. It was introduced by Louis Sullivan (American architect, 1856–1924) and then widely used in Modernism movement. It states that form, shape, look of the object (not only building) should relate and come from its function and purpose. So entrance to the building should look like one — not like shop window next to it (it’s definitely a too coarse example of this theory).</p><p>This concept is ubiquitous and clearly visible in both Architecture and UX Design.</p><h4>Attitude to skeuomorphism</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YsGxr2u5QyZGtGA6aV03cQ.png" /></figure><p>Skeuomorphism: another buzz-word that is widely use in UI Design. Here it’s nothing else than mimicking and imitating real-world object and materials in the interface. There was the trend to show paper texture in every notes app (iOS still has it!), to give buttons plastic, 3-dimensional look or even to use brick-wall backgrounds (!). Luckily it ended.</p><p>Most of the best buildings do not use fake materials. The real beauty comes from the honesty of the material: no matter if it’s warm wood or rough concrete. This trend is here for a long time and hopefully will remain.</p><h3>JEMS’s option “zero”</h3><p>You might haven’t heard of Polish architectural studio JEMS, but I encourage you to take a look at their projects (<a href="http://www.jems.pl/">www.jems.pl</a>). They are with no doubt one of the best architectural teams in Poland.</p><p>They follow the set of rules that is called option “zero” — <em>Referring to patterns and values comprehensible by everyone</em>:</p><ol><li>…</li><li>Clarity and unequivocally of form</li><li>Consistency of form, function, construction (structure) and technology</li><li>Consistency of whole and detail</li><li>Homogeneity of material</li><li>Truth about the material — natural materials</li></ol><p>(These rules were noted by me a few years ago, so there is some chance they were slightly updated.)</p><p>As you can see, most of these points could be applied not only to Architecture but to UX Design as well. However what is most significant here is point number 1:</p><ol><li><strong>User first</strong></li></ol><blockquote>So what is Architecture about if not about designing (for) User Experience?</blockquote><p>Thank you.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fupscri.be%2Ff%2F50d69a%3Fas_embed%3Dtrue&amp;dntp=1&amp;display_name=Upscribe&amp;url=https%3A%2F%2Fupscri.be%2F50d69a%2F&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=upscri" width="800" height="400" frameborder="0" scrolling="no"><a href="https://medium.com/media/05d5fd32eda31cbd1b83287606744532/href">https://medium.com/media/05d5fd32eda31cbd1b83287606744532/href</a></iframe><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6d914091d036" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/architecture-vs-ux-design-6d914091d036">Architecture vs. (so-called) UX Design</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>