<?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 Stuart Robson on Medium]]></title>
        <description><![CDATA[Stories by Stuart Robson on Medium]]></description>
        <link>https://medium.com/@sturobson?source=rss-7eb44cc09178------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*Zv4tO755j4SiHGt0.jpeg</url>
            <title>Stories by Stuart Robson on Medium</title>
            <link>https://medium.com/@sturobson?source=rss-7eb44cc09178------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 10:34:14 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@sturobson/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[The Recipe Isn’t The Bake — What Design Systems Need Beyond Documentation]]></title>
            <link>https://medium.com/@sturobson/the-recipe-isnt-the-bake-what-design-systems-need-beyond-documentation-5ac0d760df82?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/5ac0d760df82</guid>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Tue, 18 Aug 2026 00:00:06 GMT</pubDate>
            <atom:updated>2026-09-08T08:42:38.729Z</atom:updated>
            <content:encoded><![CDATA[<p>Each week on The Great British Bake Off, the Technical Challenge gives bakers a neat sheet of instructions and a pile of ingredients, then asks them to recreate a bake they may have never seen before, tried, or heard about.</p><p>On paper, everyone has the same recipe.</p><p>In practice, the results vary from showstopping to showstoppingly tragic.</p><p>That gap, between the recipe card and the actual bake, mirrors a problem many organisations face with design systems. They create documentation that looks complete on the page, but leaves out the missing pieces people might actually need — the process, the trade-offs, the edge cases, and the context that explains how and when to use the system and its parts.</p><p>Instead, they discover what the tent reveals. Good instructions help, but they don’t decide the outcome. The docs matter, but they are not the whole system.</p><p>A design system only becomes usable when there are people around it who can help teams make sense of it in the middle of real work. The problem is rarely that guidance does not exist. More often, it is incomplete when it meets the reality of deadlines, legacy code, and messy product decisions.</p><p>This article explores why design system documentation cannot promise success, what really happens between “read the guidelines” and “ship the product”, and how to treat your system less like a finished rulebook and more like a cookbook used by real people in messy conditions.</p><h3>From The Tent To The Team</h3><p>Design systems hit the same friction point. A team publishes a polished site with tokens, components, patterns and guidelines. The home page promises consistency and speed. Follow the documentation and you’ll ship interfaces that match the rest of the organisation.</p><p>Except you won’t. One team fights with legacy code. Another works in a new product area with constraints that feel incompatible with the system. Designers join from agencies with their own ingrained habits and novel ideas. Engineers arrive from different stacks and need time to build fluency. They all read the same documentation, yet the products they ship end up telling very different stories.</p><p>The same instructions do not produce the same outcome when people are working under different conditions. A system needs more than a page of rules and a few neat examples.</p><h3>The Comfort Of The Perfect Recipe</h3><p>There’s a seductive belief that if we just document everything thoroughly enough, our problems disappear. A tidy site offers control. Rules are clean, tokens are neat, nothing is left to guesswork. It feels like a complete answer.</p><p>But documentation is rarely the full picture. A recipe card that says “Cream the butter and sugar” changes depending on who reads it-someone confident in the kitchen sees a world of technique; someone less experienced sees ambiguity and hidden steps. The same gap exists in design systems.</p><p>Leadership might expect documentation to function like a lever — pull it once, features ship faster, consistency appears, bugs disappear. That’s wrong. Documentation is one input among many. Skill, context, deadline pressure, and team culture shape what actually ships.</p><h3>What The Recipe Card Misses</h3><p>Don’t get me wrong. Documentation matters.</p><p>Without a shared language and a place to find answers, teams waste inordinate amounts of time on settled questions.</p><p>But documentation has hard limits. It can’t see the user journey you’re working on. It can’t know the trade-offs you’re juggling or the unusual constraints you’re operating under. The meaning of a guideline lives in the person reading it.</p><p>Two teams read “use the card component to display items in a grid.” One has deep knowledge of accessibility and hierarchy; another is racing a deadline with minimal support. On the docs site they look identical. In a real product they diverge. Different spacing, missing states, skipped accessibility checks.</p><p>One team implements a modal correctly — focus management, escape key handling, all error states covered. Another takes the same component but misses the async error behavior shown only once in the docs. Their version works for happy paths but confuses users when data is still loading. Both believe they’re following the system. Neither recognises the gap until support tickets arrive.</p><p>The problem is not a lack of rules. People still have to interpret the same guidance under different conditions, and those conditions change the outcome.</p><h3>Ingredients, Not a Chef</h3><p>A design system is a curated set of ingredients and recipes-not a chef. It can’t see what you’re building. It can’t know your constraints or watch how users respond. Tokens encode colour, spacing, typography-the primitives, and <a href="https://www.alwaystwisted.com/articles/a-design-tokens-workflow-part-1/">A Design Tokens Workflow</a> covers how to maintain them once they exist. Components and patterns are the recipes.</p><p>Many systems launch with ‘single source of truth’ language. The same component still gets interpreted differently across teams. Different constraints, different deadlines, different habits-people adapt it in different ways.</p><h3>The Work Between The Rules</h3><p>Team practices matter. If designers and engineers review work together, they catch misunderstandings early. If they throw work over a wall, small deviations can snowball. A spacing tweak in one feature becomes a hand-written alternative in another, then a forked component in a third.</p><p>Culture matters too. On healthy teams, people admit when a guideline doesn’t make sense and push back when it collides with real user needs. On unhealthy ones, the system gets treated as dogma, and nobody wants to be the one who says it’s wrong.</p><p>Pressure matters too. When teams are working against a deadline, the path of least resistance often wins. If the documented component is hard to integrate, someone will quietly recreate something similar. That copy diverges and before long, your “one card component” is scattered across codebases.</p><h3>Maintainers Have To Show Up</h3><p>Weekly design reviews with system maintainers create a space to check if components are being applied sensibly. Pairing sessions between system engineers and product teams unblock integration issues that never surface from docs. Open office hours give people permission to ask for help without shame.</p><p>Governance matters. Not committees, just clear routes for questions and change. A channel for “kind of system, kind of not” screenshots with fast feedback. <a href="https://www.alwaystwisted.com/articles/building-your-design-system-workflow-rituals-templates/">Building Your Design System Workflow: Rituals and Templates</a> has more on setting up that kind of governance without adding bureaucracy.</p><h3>Designing For Imperfect Conditions</h3><p>Design systems are often created as if they will be used in ideal circumstances — greenfield projects, full stack alignment, time to refactor. Real teams and real work rarely live there.</p><p>Legacy codebases, accessibility debt, different release cadences, different branding requirements. If your documentation assumes perfect conditions, it will feel irrelevant to teams working at the edge. They’ll quietly create their own patterns to survive.</p><p>A more realistic approach should document intent alongside the rules. Explain what a component is <em>for</em> and where it’s safe to adapt. Describe which aspects need strict adherence and which can bend. Offer substitutions for edge cases. “If you can’t use this component because of X, here’s the acceptable alternative and why.” That is the work. Documentation that pretends constraints don’t exist won’t help.</p><h3>From Documentation To Enablement</h3><p>A strong design system team should act like coaches, not archivists. Your job is not just to create artefacts; it’s to help people work well with them.</p><p>The system has to live where people actually work, not just on a website. Training sessions, walkthroughs for new joiners, recorded examples, live pairing where someone builds a small feature with a maintainer and learns by doing.</p><p>Embedding system team members into product teams for a few sprints changes what you learn. You see which patterns are genuinely awkward, which requirements are real, and what’s hard to integrate.</p><p>Feedback loops matter. If there’s no easy way for teams to surface problems, the system will drift silently. In-page comments, lightweight request forms, regular listening sessions.</p><p>As AI starts sitting between people and the docs, this role becomes more critical. It can make everything move faster, but it cannot absorb the judgment that keeps the system honest. You need humans in the loop.</p><h3>The Sous Chef, Not the Head Chef</h3><p>AI can be helpful in a design system when it stays in the boring, mechanical parts of the job. It can read a system, suggest components, generate snippets, and answer “what should I use here?” questions faster than someone can look through pages of documentation.</p><p>That is useful. A designer unfamiliar with components can ask for a layout that respects the spacing scale and get a starting point. A developer can screenshot part of a design and ask which system patterns fit the case. A maintainer can ask AI to compare a proposed component against existing tokens, patterns, and naming conventions.</p><p>The limit is pretty obvious, though. AI does not understand a product the way a person does. It doesn’t know the codebase you are working with or the edge cases that are acceptable and which aren’t. It’s got no idea of the realities of a team already under pressure. It cannot tell the difference between a pattern that is technically valid and one that is actually workable in the real world.</p><p>It can draft docs, suggest a naming scheme, generate a first pass of examples, surface inconsistencies, or turn a rough screenshot into a component shortlist. It can save a bit of time. But it should not be the person deciding whether the pattern belongs in the system.</p><p>The real risk is speed. If the documentation is stale, a component is poorly explained, or the system is under-specified, AI spreads that uncertainty at speed. It will happily produce something that looks consistent on the surface while missing the real requirements, the actual user flow, or the team’s constraints.</p><p>AI is a fast helper, not a design system lead. It is useful when someone is checking the output, not when the output is being trusted without context.</p><p>The system still has to be explained by the folks who understand the trade-offs and the decisions still need to belong to the maintainers.</p><h3>When Things Go Wrong</h3><p>Organisations can hit one of three patterns.</p><p>A docs site nobody visits. Components appear in production that don’t exist in the system. Teams say they couldn’t find what they needed, or the official version was too hard to integrate.</p><p>The same guideline gets interpreted differently everywhere. One team follows the spacing scale precisely; another squeezes in an extra variable to match the design handed to them. Both point to the same page to justify their choice. The guideline was too open.</p><p>A product team working on a payments flow, for example, may quietly override a date picker because the design is too rigid for a corner case in the transaction screen. That tweak works, and then it becomes a pattern. After a few months, the override is spread throughout the product. Removing it feels like breaking something teams depend on.</p><p>Rarely is the cause “we didn’t document thoroughly enough.” It’s almost always “we made it hard for people to actually use what we built.”</p><h3>A Few Things To Do</h3><p>A healthier approach starts with structure. Treat documentation as a working tool. Prioritise clarity and real examples over perfect prose.</p><p>Make it easy to skim and easier to find what you need when you’re deep in a task. Keep the rule, the intent, and the edge cases in the same place so people do not have to guess which version is safe.</p><p>Position your design system team as partners in product work. They should spend time with teams, join planning, and attend post-release reviews — <a href="https://www.alwaystwisted.com/articles/from-proposal-to-release-designing-your-design-system-workflow/">From Proposal to Release</a> walks through what that kind of workflow can look like in practice.</p><p>Design feedback loops into the system. When a pattern keeps proving awkward, that’s a sign to adjust it. Capture those learnings and give credit to the teams that surfaced them. Measure outcomes instead of component counts, looking at whether features ship more smoothly and whether users are getting better experiences across products.</p><h3>Why The Work Matters</h3><p>The Technical Challenge on Bake Off strips away support and coaching to see how bakers cope under pressure.</p><p>Real product teams deserve better.</p><p>Documentation will always be vital, but writing the rules is the easy part. The real work is making sure those rules make sense when people are up against real world constraints — in the conversations, the code reviews, and the quiet questions teams ask when a component or pattern just doesn’t fit.</p><p>A design system can look tidy and still fail if the people using it never see the maintainers. Questions pile up without answers. Teams stop asking and start forking. By the time adoption is dropping, the system is too fragmented to rebuild trust. The thing that keeps it alive is not a perfect manual. It is presence. A team that embeds with product teams, reviews code, and adjusts patterns when they don’t fit reality.</p><p>That is what makes a design system trustworthy. The docs matter, but they only become useful when there are people around them who can explain them, adapt them, and keep them honest.</p><p><em>Originally published at </em><a href="https://www.alwaystwisted.com/articles/the-recipe-isnt-the-bake"><em>https://www.alwaystwisted.com</em></a><em> on August 18, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5ac0d760df82" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Running and Evolving Your Design Systems Workflow — Metrics, Mistakes, and Scaling]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">It&#x2019;s 12 o&#x2019; clock (and it&#x2019;s a wonderful day). Lars from the mobile team just noticed something. Their progress bars don&#x2019;t match the ones in&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@sturobson/running-and-evolving-your-design-systems-workflow-metrics-mistakes-and-scaling-096f06bc3793?source=rss-7eb44cc09178------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@sturobson/running-and-evolving-your-design-systems-workflow-metrics-mistakes-and-scaling-096f06bc3793?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/096f06bc3793</guid>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[workflow]]></category>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Wed, 01 Jul 2026 00:00:08 GMT</pubDate>
            <atom:updated>2026-07-04T10:20:17.223Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Building Your Design System Workflow — Rituals and Templates]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">Understanding what a good workflow looks like and actually building one are totally different things. You know your proposals need a clear&#x2026;</p><p class="medium-feed-link"><a href="https://medium.com/@sturobson/building-your-design-system-workflow-rituals-and-templates-e8473a5b471c?source=rss-7eb44cc09178------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@sturobson/building-your-design-system-workflow-rituals-and-templates-e8473a5b471c?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8473a5b471c</guid>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Wed, 24 Jun 2026 00:00:29 GMT</pubDate>
            <atom:updated>2026-07-04T10:20:25.764Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[From Proposal to Release: Designing Your Design System Workflow]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-snippet">The Cost of Chaos</p><p class="medium-feed-link"><a href="https://medium.com/@sturobson/from-proposal-to-release-designing-your-design-system-workflow-c1b58fe4e776?source=rss-7eb44cc09178------2">Continue reading on Medium »</a></p></div>]]></description>
            <link>https://medium.com/@sturobson/from-proposal-to-release-designing-your-design-system-workflow-c1b58fe4e776?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/c1b58fe4e776</guid>
            <category><![CDATA[design-process]]></category>
            <category><![CDATA[workflow]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Wed, 17 Jun 2026 00:00:52 GMT</pubDate>
            <atom:updated>2026-07-04T10:19:57.473Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[I’ve been compiling my Sass wrong, for years]]></title>
            <link>https://medium.com/@sturobson/ive-been-compiling-my-sass-wrong-for-years-aa2f8d4fdc72?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/aa2f8d4fdc72</guid>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Wed, 28 Jan 2026 00:00:17 GMT</pubDate>
            <atom:updated>2026-01-29T09:54:18.392Z</atom:updated>
            <content:encoded><![CDATA[<p>For years, I’ve been preprocessing Sass in my build pipeline without really thinking about how I was doing it. Every project would follow the same pattern: set up Sass, write a build script, and leave it alone. It worked. It was fast enough. I never questioned it.</p><p>That changed recently when I saw a deprecation warning in my build logs. It transpires, I’ve been using an API that’s been obsolete for almost five years. And I didn’t even know it.</p><h3>The warning</h3><p>The warning was clear enough:</p><pre>Deprecation Warning: The legacy JS API is deprecated and will be removed in Dart Sass 2.0.0.</pre><p>I’d probably glanced over this warning a couple of times in recent weeks, but today it stopped me. I’m using <strong>Dart Sass</strong>. How was I possibly using a “legacy” API? I started digging and realised I’ve been clinging to renderSync() since my node-sass days.</p><h3>What I missed, the modern API</h3><p>Back in late 2021, Dart Sass 1.45.0 introduced a fresh approach. Instead of renderSync(), the new API gave us:</p><ul><li>compile() and compileAsync() for compiling files</li><li>compileString() and compileStringAsync() for compiling strings directly</li></ul><p>These aren’t just renamed methods. They’re a proper redesign with better performance, cleaner syntax, proper Promise support instead of callbacks, and better TypeScript support.</p><h3>The performance bump</h3><p>The real surprise is the performance gain. When you use the modern API with sass-embedded (the faster Dart Sass implementation), you could be looking at <strong>5-10x faster</strong> compilation. That&#39;s not a marginal improvement. For projects with hundreds of imports, that&#39;s the difference between a build taking 30 seconds and 3 seconds.</p><p>Why? The old API was designed for the node-sass era, before modern Sass had its own compiler. The new API was built from the ground up for Dart Sass.</p><h3>Migrating the code</h3><p>Here’s what the actual migration looks like. My old code using the legacy API:</p><pre>const sass = require(&#39;sass&#39;);<br>const fs = require(&#39;fs&#39;);<br><br>// Synchronous file compilation<br>const result = sass.renderSync({<br>  file: &#39;styles/main.scss&#39;,<br>  outputStyle: &#39;compressed&#39;,<br>  sourceMap: true,<br>  outFile: &#39;dist/main.css&#39;,<br>});<br><br>fs.writeFileSync(&#39;dist/main.css&#39;, result.css);<br>fs.writeFileSync(&#39;dist/main.css.map&#39;, result.map);</pre><p>The modern equivalent:</p><pre>const sass = require(&#39;sass&#39;);<br>const fs = require(&#39;fs&#39;);<br><br>// Synchronous file compilation<br>const result = sass.compile(&#39;styles/main.scss&#39;, {<br>  style: &#39;compressed&#39;,<br>  sourceMap: true,<br>});<br><br>fs.writeFileSync(&#39;dist/main.css&#39;, result.css);<br>if (result.sourceMap) {<br>  fs.writeFileSync(&#39;dist/main.css.map&#39;, JSON.stringify(result.sourceMap));<br>}</pre><p>The key differences took me a moment to adjust to:</p><ol><li><strong>The file path is the first argument</strong> — Not buried in an options object. Much cleaner.</li><li><strong>outputStyle is now </strong><strong>style</strong> - Just a property rename.</li><li><strong>No </strong><strong>outFile needed</strong> - The modern API doesn&#39;t write files for you. You get back the CSS and source map, then handle the file writing yourself.</li><li><strong>CSS is already a string</strong> — No more calling .toString() on a Buffer.</li><li><strong>Source maps are objects</strong> — Not strings, so you stringify them when writing.</li></ol><h3>Compiling strings instead of files</h3><p>There are scenarios where you need to compile Sass without reading from a file. Build tools might construct Sass strings on-the-fly, or you could have a CMS that lets content editors define variables. Maybe you’re generating a theme dynamically based on user input. In those cases, you’re compiling strings directly:</p><p><strong>Old way:</strong></p><pre>const result = sass.renderSync({<br>  data: &#39;$primary: #333; body { color: $primary; }&#39;,<br>  outputStyle: &#39;compressed&#39;,<br>});</pre><p><strong>New way:</strong></p><pre>const result = sass.compileString(&#39;$primary: #333; body { color: $primary; }&#39;, {<br>  style: &#39;compressed&#39;,<br>});</pre><h3>Going async</h3><p>One of the nice wins is async/await support. The old callback-based approach looked like this:</p><pre>sass.render(<br>  {<br>    file: &#39;styles/main.scss&#39;,<br>  },<br>  (err, result) =&gt; {<br>    if (err) {<br>      console.error(err);<br>      return;<br>    }<br>    console.log(result.css.toString());<br>  }<br>);</pre><p>With the modern API:</p><pre>async function compileSass() {<br>  const result = await sass.compileAsync(&#39;styles/main.scss&#39;);<br>  console.log(result.css);<br>}<br><br>compileSass();</pre><p>Much cleaner with async/await. If you’re using this in a build tool or automation script, it’s much more natural to work with.</p><h3>Custom functions and importers</h3><p>Custom functions let you extend Sass with your own logic. You might need a function to calculate responsive sizes, generate colour variants, or perform calculations that Sass’s built-in functions don’t handle. Importers let you override how Sass finds and loads files (useful if you’re loading Sass from a database, a package manager, or a custom file system). These are more advanced use cases, but if you’re doing either, the API changed significantly.</p><p>The old way with custom functions:</p><pre>const sass = require(&#39;sass&#39;);<br><br>const result = sass.renderSync({<br>  file: &#39;styles/main.scss&#39;,<br>  functions: {<br>    &#39;double($n)&#39;: function (n, done) {<br>      done(sass.types.Number(n.getValue() * 2, n.getUnit()));<br>    },<br>  },<br>});</pre><p>The modern approach:</p><pre>const sass = require(&#39;sass&#39;);<br><br>const result = sass.compile(&#39;styles/main.scss&#39;, {<br>  functions: {<br>    &#39;double($n)&#39;: function (args) {<br>      const n = args[0].assertNumber(&#39;n&#39;);<br>      return new sass.SassNumber(n.value * 2, n.numeratorUnits);<br>    },<br>  },<br>});</pre><p>The modern API uses a more robust system. It’s less magical and more explicit, which honestly feels better.</p><h3>What about build tools?</h3><p>If you’re using a build tool like webpack, Vite, or gulp, check whether they’ve updated their Sass integration. Most have, but support varies:</p><p><strong>sass-loader</strong> (for webpack) supports the modern API in v14+ if you set api: &#39;modern-compiler&#39;. That option gives you the performance bump I mentioned earlier.</p><p><strong>Vite</strong> already uses the modern API by default, so if you’re on a recent version, you’re already getting the benefits.</p><p><strong>gulp-sass</strong> is still working on full migration support, though it’s improving.</p><p>If you’re configuring sass-loader, the setup is straightforward:</p><p>That one option can make a noticeable difference in your build times if you’ve got a lot of Sass to process.</p><pre>{<br>  loader: &#39;sass-loader&#39;,<br>  options: {<br>    api: &#39;modern-compiler&#39;,<br>    implementation: require(&#39;sass&#39;)<br>  }<br>}</pre><h3>Should you update?</h3><p>Yes.</p><p>Here’s why.</p><p><a href="https://github.com/sass/dart-sass/milestone/3">Dart Sass 2.0.0 is coming</a>, and the legacy API will be removed entirely. If you’re still using renderSync() and render(), your build will break. There&#39;s no safety net, no deprecation option, no workaround.</p><p>Beyond that, the performance gains are real. If you’re compiling Sass regularly as part of your workflow, cutting build times by 80–90% is worth the effort. The modern API is genuinely better to work with too.</p><p>If you do need time to migrate, you can suppress the warnings temporarily:</p><pre>sass.renderSync({<br>  file: &#39;styles/main.scss&#39;,<br>  silenceDeprecations: [&#39;legacy-js-api&#39;],<br>});</pre><p>But don’t rely on that, you’ll be forced to update eventually anyway.</p><h3>The lesson</h3><p>I’ve only just noticed the warnings in my build logs recently. I could have accidentally spent years skipping it thinking “It works” was enough. Sometimes what works is just outdated, and you don’t realise it until something forces you to look at it properly.</p><p>In this case, I didn’t know how much of a performance benefit I would be leaving on the table. I was using an API that had been superseded by something better, faster, and cleaner. All because I never upgraded a function call from (checks notes) 2015.</p><p>The renderSync() API served a purpose. It got Sass running in Node in the first place. But it&#39;s time to move on. The modern API isn&#39;t just a rename, it&#39;s a real improvement that makes your builds faster and your code cleaner.</p><p>So I’ve updated my build scripts. Compared to migrating from @import to @use and @forward, it didn&#39;t take long. The deprecation warning is gone and my builds are faster.</p><p>I probably should have done this when it came out five years ago, but at least I did it now.</p><p>If you’re seeing that same deprecation warning in your logs, now is a good time to update yours too.</p><p><em>Originally published at </em><a href="https://www.alwaystwisted.com/articles/ive-been-compiling-my-sass-wrong-for-years"><em>https://www.alwaystwisted.com</em></a><em> on January 28, 2026.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=aa2f8d4fdc72" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Faculty Of Design Systems]]></title>
            <link>https://medium.com/@sturobson/the-faculty-of-design-systems-6a2d8b719010?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/6a2d8b719010</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[workflow]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Mon, 02 Dec 2024 00:00:59 GMT</pubDate>
            <atom:updated>2026-09-08T08:43:14.980Z</atom:updated>
            <content:encoded><![CDATA[<p><em>Originally published at </em><a href="https://www.alwaystwisted.com/articles/the-faculty-of-design-systems"><em>https://www.alwaystwisted.com</em></a><em> on December 2, 2024.</em></p><p>I reached my late teenage years at almost the perfect time for a horror fan. The late 1990s saw a resurgence of the genre in the film industry. Sparked by the success of <em>Scream</em> in 1996, Dimension Films went through every drawer of its writer, Kevin Williamson, to see what other delights he’d written.</p><p>In 1997, <em>I Know What You Did Last Summer</em> was released, and in 1998, Williamson’s cross-genre <em>The Faculty</em> brought science fiction and horror to a small town in Ohio.</p><p>Much like Dawson and Joey discussing the best Spielberg films in <em>Dawson’s Creek</em> (another Williamson creation), these movies were packed with references to older films in their respective genres. They didn’t just tell their own stories, they built on the cultural DNA of what came before, remixing familiar tropes in clever and unexpected ways.</p><p>It’s fitting, then, that one of my favourite lines from <em>The Faculty</em> has stuck with me:</p><blockquote><em>If you were going to take over the world, would you blow up the White House *Independence Day* style, or sneak in through the back door?</em></blockquote><blockquote><em>Casey Connor (The Faculty, 1998)</em></blockquote><p>This question isn’t just about alien invasions, it’s a perfect metaphor for introducing something new, like a Design System, into a complex organisation.</p><p>Do you go in with fireworks and a grand unveiling, or do you quietly work your way into the structure until it becomes part of the system’s DNA?</p><h3>Invasion of the Design System</h3><p>Like a subtle sci-fi horror movie, building a Design System doesn’t have to involve loud bangs and big drama. Sometimes, it’s about quietly embedding it into existing workflows and teams until it becomes an essential part of how your organisation works.</p><p>Your Design System doesn’t need to arrive in a spaceship over the White House to make an impact. Instead, think of it like the creeping unease of <em>Invasion of the Body Snatchers</em>, quietly infiltrating workflows and processes until it’s simply part of the organisation’s DNA.</p><p>When a system is gradually built, integrated into workflows, and consistently demonstrates its value, it has the power to become indispensable. It’s like a well-executed plot twist: surprising when revealed, yet inevitable in hindsight.</p><p>This method can be particularly effective when resources are scarce, or when approval for a formal Design System isn’t yet on the table. Start small: address a persistent inconsistency, introduce a handful of design tokens, or offer a reusable component that saves a team time. Each small improvement fosters trust, demonstrates value, and lays the groundwork for broader adoption.</p><p>Like the best slow-burn horror films, this approach leaves a lasting impression. A Design System developed this way isn’t just a tool-it becomes part of the culture, shaping how teams think, work, and collaborate.</p><h3>The Big Explosion vs. The Quiet Revolution</h3><p>You could launch your Design System with fireworks, a grand unveiling like the <em>Independence Day</em> mothership making its dramatic entrance. But while a big, bold debut gets attention, it can also create chaos.</p><p>The reality is that a “big bang” approach can cause as many problems as it solves. It risks alienating the very people you need to win over. This is where the <em>quiet revolution</em> comes in-slowly integrating the system into workflows, proving its value piece by piece, and growing adoption naturally over time.</p><h3>The Risks of the Big Bang Approach</h3><p>The “big bang” might sound appealing, but it can backfire:</p><ul><li><strong>“We don’t have time to use this.”</strong> — Teams drowning in deliverables might feel the system is an added burden.</li><li><strong>“Why weren’t we consulted?”</strong> — A top-down approach can alienate teams who feel excluded.</li><li><strong>“We already have our own components.”</strong> — Teams may view the system as redundant or even a threat.</li><li><strong>“Why is this being driven by that team?”</strong> — Questions about ownership can undermine trust.</li></ul><p>Big explosions might grab attention, but they often fizzle out when enthusiasm fades or resistance builds. The initial buzz doesn’t guarantee lasting adoption.</p><h3>Why a Quiet Revolution can work</h3><p>The quiet revolution is about creating change subtly, like the creeping takeover in <em>Invasion of the Body Snatchers</em>. By solving immediate pain points and offering tangible benefits, you build trust and adoption naturally.</p><ul><li><strong>Start small</strong> — Introduce a reusable component or a few design tokens that make work easier.</li><li><strong>Listen and adapt</strong> — Engage with teams to understand their challenges and incorporate their feedback.</li><li><strong>Be visible, but not intrusive</strong> — Show you’re there to help without forcing adoption.</li></ul><p>Over time, these small wins add up, creating a network of advocates who spread the system organically. By the time the system is fully adopted, it will feel like it was always meant to be there-an integral part of how your organisation works.</p><h3>Small Team, Big Impact</h3><p>Many Design Systems don’t begin with fanfare but with a handful of dedicated individuals-designers, developers, or both-quietly working behind the scenes. They’re like the small group of survivors in a horror movie, spotting the patterns others miss and taking action before it’s too late.</p><p>A grassroots approach often starts with small, practical observations:</p><ul><li>Multiple teams solving the same problems in slightly different ways.</li><li>Buttons that look similar but behave inconsistently.</li><li>Spacing that’s inconsistent between screens.</li><li>Colours that fail accessibility standards.</li></ul><p>These individuals think, <em>“What if we standardise this?”</em> And with that, the seeds of a Design System are planted.</p><h3>Success Through Subtlety</h3><p>Small teams have the advantage of working under the radar, avoiding the pressure of delivering a fully-formed system from day one. Instead, they focus on incremental improvements, such as:</p><ul><li><strong>Streamlining repetitive work</strong> — A shared button or token set that saves time.</li><li><strong>Improving quality</strong> — Standardising patterns to reduce bugs and ensure accessibility compliance.</li><li><strong>Building trust</strong> — Demonstrating the benefits of consistency through visible, small wins.</li></ul><p>Over time, these efforts create momentum. The Design System becomes less about imposing change and more about solving shared problems. As teams experience its benefits, they naturally adopt it-and even advocate for it.</p><h3>Incremental Buy-in: One Step at a Time</h3><p>Invasion isn’t about force; it’s about persistence. Securing buy-in for a Design System works the same way-through small, meaningful steps that show value without overwhelming anyone.</p><p>Rolling out the system incrementally-one component, one team at a time-reduces resistance. Start with something manageable: a shared button component, a small set of tokens, or a consistent typography scale. These changes demonstrate immediate value, building trust and encouraging further adoption.</p><h3>Creating a Network of Champions</h3><p>When teams see tangible benefits, they become advocates. A developer might share how a component saved hours of work, or a designer might explain how tokens improved consistency. These champions spread enthusiasm, making adoption feel natural and organic.</p><h3>From Steps to a Movement</h3><p>Incremental improvements grow over time, turning the Design System into something larger-a movement. By the time the system is fully integrated, it won’t feel like an external addition but a natural extension of how the organisation operates.</p><h3>Communicate First, Build Second</h3><p>A quiet revolution thrives on communication. Without clear dialogue, even the best-crafted system risks being misunderstood or ignored. Start with the <em>why?</em> Why does the system exist? What problems does it solve? When teams understand its value, they’re more likely to engage and advocate for it.</p><p>Communication isn’t just about delivering a message; it’s about fostering collaboration. By gathering feedback and involving teams in the process, the system becomes a shared effort rather than a top-down directive. Like the subtle infiltration in <em>Invasion of the Body Snatchers</em>, effective communication quietly plants the system’s seeds, helping it take root and grow naturally within the organisation.</p><p>Much like <em>Invasion of the Body Snatchers</em>, a Design System’s success lies in its gradual and understated integration. Over time, it reshapes how people think, work, and collaborate until it becomes an inseparable part of the organisation’s DNA-something so ingrained that no one remembers a time without it.</p><p>By the time the system is fully adopted, it won’t feel like a revolution-it’ll feel like the way things have always been done. And like the best slow-burn stories, its impact will be enduring, shaping how the organisation evolves and grows for years to come.</p><p>By the time anyone notices, it’s already everywhere.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=6a2d8b719010" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[100%, This Is The Ultimate, Best, Correct, And Right Way To Do Or Not To Do Something In Web Design…]]></title>
            <link>https://medium.com/@sturobson/100-this-is-the-ultimate-best-correct-and-right-way-to-do-or-not-to-do-something-in-web-design-67d9d0bd2be9?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/67d9d0bd2be9</guid>
            <category><![CDATA[web]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Wed, 07 Dec 2016 12:37:37 GMT</pubDate>
            <atom:updated>2016-12-07T12:47:28.982Z</atom:updated>
            <content:encoded><![CDATA[<h3>100%, This Is The Ultimate, Best, Correct, And Right Way To Do Or Not To Do Something In Web Design And Development</h3><p>Or maybe it’s a conclusion we have ended up upon after working on problems in our own context, with our own requirements and existing issues, that’s completely different to anybody elses context so it might not work or be right for them.</p><p><strong>¯\_(ツ)_/¯</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67d9d0bd2be9" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Getting Buy In For Your Styleguide]]></title>
            <link>https://medium.com/@sturobson/getting-buy-in-for-your-styleguide-219ea43a7913?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/219ea43a7913</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[style-guides]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Sat, 19 Mar 2016 07:33:23 GMT</pubDate>
            <atom:updated>2016-03-19T07:38:39.883Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>“If you book them, they will come.”</em></blockquote><blockquote><em>(not) Jim Morrison</em></blockquote><p>In creating a front-end styleguide, design language and framework for (initially) a small part of a company, getting ‘buy in’ from other departments and developers could be a potential problem.</p><p>Here’s this collection of files you’ve created that help you with your day–to–day work with a pattern library of your website, but how can that possibly help another department, or even another company within a larger organisation.</p><p>Part of it comes down to how you have gone about creating your design language, your pattern library and your front-end framework. Part of it is how you go about evangelising what you’ve created.</p><p>A style guide, built upon a pattern library that is part of the design language is just that. A guide (more on this, in another article (to be written)). It is not ‘the law’, it should have the ability to be wielded masterfully by another designer, to be modified, adapted, re-written (in parts) to suit the sites design and requirements.</p><p>In an organisation with many teams potentially creating sites that could be poles apart from each other a clear front-end architecture of possibilities with a component–based, modular pattern library can be of great benefit to all.</p><p>You should bestow the virtues of using your front-end framework and pattern library, showing how that, if every developer started using it, it would improve not only itself but the websites that are the customer / visitor / user facing.</p><p>The ‘thing’ (the front-end framework and pattern library) can be improved, by everyone, be it someone who’s part of the ‘original team’ or another developer working for another company or part of the organisation.</p><p>Using version control and creating a system of how to update the codebase, maybe with peer review, means everyone in the organisation can have their say, giving their opinion on edits to the code all the while helping the overall ‘thing’ and a sites visitor.</p><p>If everyone within a large organisation uses the same front-end framework and architecture it allows for an increasing improvement in code quality, bringing new and/or better design patterns, performance improvements all leading to ‘better’ sites (from a code perspective) for everyone.</p><p>This can be of benefit, not only to someone visiting the site with a more performant faster page and better accessibility, for example, but also to the organisation as a whole.</p><p>If every developer on every project starts to use the same front-framework, the same pattern library it can make it easier for developer to switch teams, or ‘jump in’ as an extra pair of hands. Using the same base elements of the front-end architecture means the developer will be ‘up to speed’ in no time. That’s got to be a good thing.</p><p>I think there are many benefits for a company to treat their front-end framework and pattern library as a going concern, there is always room from improvement, the work is never ‘done’.</p><blockquote><em>“No matter how good you get you can always get better, and that’s the exciting part.”</em></blockquote><blockquote><em>Tiger Woods</em></blockquote><p><em>Originally published at </em><a href="http://alwaystwisted.com/articles/getting-buy-in-for-your-styleguide"><em>alwaystwisted.com</em></a><em> on January 16, 2016.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=219ea43a7913" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Styleguides, Pattern Libraries and Design Languages]]></title>
            <link>https://medium.com/@sturobson/styleguides-pattern-libraries-and-design-languages-84746902c51c?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/84746902c51c</guid>
            <category><![CDATA[style-guides]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Wed, 20 Jan 2016 00:00:00 GMT</pubDate>
            <atom:updated>2016-03-19T07:36:24.156Z</atom:updated>
            <content:encoded><![CDATA[<p>The terminology surrounding front-end ’styleguides’ seems to be ever expanding. We have styleguides, pattern libraries, UI libraries, design systems, design patterns and a design language to name a few.</p><p>Some of these are similar to each other, some are used to encompass everything. For clarity it’s best to define what you are meaning when using one of these terms. It will help you and your colleagues understand what part of the project you are talking about without possible confusion.</p><p>This is how I see three of the often used terms. Style guides, Pattern Libraries and Design Languages.</p><h3>The what, the where, the how and the why</h3><h4>Pattern Libraries</h4><p>A pattern library is a collection of front-end code that creates a component part of the overall design of the page. It is ‘the what’ of the website. If you need to use a carousel this is ‘what’ code you would use.</p><h4>Styleguides</h4><p>With a pattern library being ‘the what’ of a sites design a styleguide is ‘the how’ and ‘the where’. You have this collection of colours and typefaces and the styleguide will show you how and where to put them in your website. The patterns you need for a project will have their placement and usage defined within the styleguide.</p><p>It is ‘a guide’ though. It should allow for deviation where necessary or chosen when content dictates a change in the design.</p><h4>Design Language</h4><p>As we have ‘the what’, ‘the where’ and ‘the how’ then a Design Language, in part, is the overall ‘the why’. With our ready–made patterns and our styleguide showing us where and how to use them the Design Language will instruct us as to why we would use ‘the what’ and’(the) where’ we should put them altogether.</p><h4>The simplest of terms</h4><p>That’s how I see these three terms, like a ‘Johnny Ball Reveals All’ trio for projects.</p><p>Out of the three I think I’ve not given the Design Language as much credit as to what it is. It can be seen as much more than the simple why you would put what where and how. It should be the living, growing ‘thing’ for the project, in all aspects of design, not just of the web. From my point of view, as a front-end developer, that’s for others to define and express better that I could try to.</p><p><em>Originally published at </em><a href="http://alwaystwisted.com/articles/styleguides-pattern-libraries-and-design-languages"><em>alwaystwisted.com</em></a><em> on January 20, 2016.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=84746902c51c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Front End Development]]></title>
            <link>https://medium.com/@sturobson/front-end-development-46ea7a4dc665?source=rss-7eb44cc09178------2</link>
            <guid isPermaLink="false">https://medium.com/p/46ea7a4dc665</guid>
            <dc:creator><![CDATA[Stuart Robson]]></dc:creator>
            <pubDate>Sun, 06 Jul 2014 07:42:51 GMT</pubDate>
            <atom:updated>2014-07-06T08:18:46.657Z</atom:updated>
            <content:encoded><![CDATA[<h4>It’s a way of life</h4><p>Front End Development is a key role in the war on creativity. You can easily do without a designer now and just colour in your latest Bootplate Boilerstrap.</p><h3>But it’s hard.</h3><p>Sometimes it requires a cup of coffee. Not an instant cup of coffee. Like Vodka, coffee for front end development is best served triple filtered, with ice if you’re really at the forefront of your craft.</p><p>Fundamentally Front End Development is a way of life. You have to spend your life not enjoying family and friends but picking holes at others code. Making sure you’re using the latest Gah or Grr task manager to impress your ‘friends’.</p><p>You can’t use CSS anymore, no way. You shouldn’t even look at it now you’re agonizing over your variable names. Life’s too short to worry about how the CSS looks now you’ve worked out how to ‘nest’ things and make awesome loops that ‘just work’.</p><p>Obviously you don’t use HTML5, you use HTML 5.1. A work in progress but you’re at the cutting edge, like a pirate from the wild west days.</p><p>Everyone’s got super high speed internet right? What’s an Opera mini anyhow? You’ve just gotta make sure those images look fab on a retina display. That’s what matters. High resolution images will fit down the intertubes so smoothly, if you wait and make sure you don’t tick ‘progressive’ on those jpeg files, smooth doesn’t mean ‘bit by bit’.</p><p>The web is 99% typography, so make sure that other 1% is at least a megabyte of unoptimised pngs.</p><p>Make sure those fonts load, eventually. Users are <em>really </em>excited about a blank page. The intrigue, the excitement, the suspense. By the time your fonts have finally loaded they will get even more excited as they’ve forgotten why they were on the page. A bonus.</p><p>Stop using plain HTML, get JavaScript to do this for you. Everyone has it now, it’s even part of the constitution in the US and Boris Johnson’s adding it to his Queens speech. A JavaScript frameplate makes it easier and simpler for you. A bonus.</p><p>Ultimately that’s the main thing. Front End Development is a way of life to make your life simpler. So you can look at the hippest bicycle, listen to obscure music, drink coffee made from beetle crap and tweet about privacy all day long.</p><p>So go forth, embrace all these new technologies that make your life better. Browsers will catch up, users will still engage and your beard will look better for it.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=46ea7a4dc665" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>