<?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 Surendar Selvaraj on Medium]]></title>
        <description><![CDATA[Stories by Surendar Selvaraj on Medium]]></description>
        <link>https://medium.com/@surendarselvaraj?source=rss-d40b89c76dba------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*3uxTzP6B2AoY2yPssn9DBw.jpeg</url>
            <title>Stories by Surendar Selvaraj on Medium</title>
            <link>https://medium.com/@surendarselvaraj?source=rss-d40b89c76dba------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Wed, 18 Nov 2026 02:24:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@surendarselvaraj/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[650+ Google Material 3 Button Variants + Microsoft Fluent 2 Mappings in One Figma Component]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://www.designsystemscollective.com/650-google-material-3-button-variants-microsoft-fluent-2-mappings-in-one-figma-component-d02a72fe78aa?source=rss-d40b89c76dba------2"><img src="https://cdn-images-1.medium.com/max/1920/1*4rQBTvba0EKIUIAdOr0PQw.png" width="1920"></a></p><p class="medium-feed-snippet">How one Figma component replaces 650+ Material 3 variants, preserves Fluent 2 behavior, and supports 144,000 configurations.</p><p class="medium-feed-link"><a href="https://www.designsystemscollective.com/650-google-material-3-button-variants-microsoft-fluent-2-mappings-in-one-figma-component-d02a72fe78aa?source=rss-d40b89c76dba------2">Continue reading on Design Systems Collective »</a></p></div>]]></description>
            <link>https://www.designsystemscollective.com/650-google-material-3-button-variants-microsoft-fluent-2-mappings-in-one-figma-component-d02a72fe78aa?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/d02a72fe78aa</guid>
            <category><![CDATA[material-design]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[microsoft]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Mon, 31 Aug 2026 06:33:11 GMT</pubDate>
            <atom:updated>2026-08-31T06:33:11.594Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Last Design System Designer]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://www.designsystemscollective.com/the-last-design-system-designer-d105989d8416?source=rss-d40b89c76dba------2"><img src="https://cdn-images-1.medium.com/max/1402/1*7SK-gizdFxNjjX64jRwPKQ.png" width="1402"></a></p><p class="medium-feed-snippet">AI can enforce design system rules, but automating junior work may remove the path that creates future system leaders.</p><p class="medium-feed-link"><a href="https://www.designsystemscollective.com/the-last-design-system-designer-d105989d8416?source=rss-d40b89c76dba------2">Continue reading on Design Systems Collective »</a></p></div>]]></description>
            <link>https://www.designsystemscollective.com/the-last-design-system-designer-d105989d8416?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/d105989d8416</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[design-leadership]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Tue, 04 Aug 2026 16:51:38 GMT</pubDate>
            <atom:updated>2026-08-04T16:51:38.043Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[I Built a Design Review Skill. The Hardest Rule Was Teaching It to Say “I Don’t Know.”]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://www.designsystemscollective.com/i-built-a-design-review-skill-the-hardest-rule-was-teaching-it-to-say-i-dont-know-928edbd42ccc?source=rss-d40b89c76dba------2"><img src="https://cdn-images-1.medium.com/max/1536/1*K1g3dk6iH-Z2hhPrsZODmg.png" width="1536"></a></p><p class="medium-feed-snippet">It scored my broken component 14. Then its self-audit found the same failure it was built to prevent.</p><p class="medium-feed-link"><a href="https://www.designsystemscollective.com/i-built-a-design-review-skill-the-hardest-rule-was-teaching-it-to-say-i-dont-know-928edbd42ccc?source=rss-d40b89c76dba------2">Continue reading on Design Systems Collective »</a></p></div>]]></description>
            <link>https://www.designsystemscollective.com/i-built-a-design-review-skill-the-hardest-rule-was-teaching-it-to-say-i-dont-know-928edbd42ccc?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/928edbd42ccc</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 14:58:42 GMT</pubDate>
            <atom:updated>2026-07-31T14:58:42.245Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[Convergent Deprecation: Deprecation Does Not Terminate When Your Consumer Is a Generator]]></title>
            <link>https://www.designsystemscollective.com/convergent-deprecation-deprecation-does-not-terminate-when-your-consumer-is-a-generator-ba1c87875adf?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/ba1c87875adf</guid>
            <category><![CDATA[model-context-protocol]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[data-governance]]></category>
            <category><![CDATA[ai-agent]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Thu, 23 Jul 2026 18:22:23 GMT</pubDate>
            <atom:updated>2026-07-23T18:22:23.531Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*zb0Uh9cDZYe00bP4cEgc8A.png" /></figure><p>On July 28, 2026 the Model Context Protocol publishes a specification that does something design systems have never done for their own primitives. It gives every protocol feature a governed sunset. A feature moves through a formal Active, Deprecated, Removed lifecycle. Deprecation and removal are two separate proposals. A minimum of twelve months, never fewer than ninety days even for a security fix, must pass between the two. And a Standards Track feature cannot even reach Final until a matching scenario lands in an executable conformance suite, the same suite that scores the official SDKs. Removal is not a date on a roadmap. It is a proof obligation with a guaranteed runway.</p><p>Now look at the thing your design agents actually write to. A design token in the W3C Design Tokens Format Module, the first stable version of which shipped on October 28, 2025, carries a $deprecated property. You set it to true, you optionally write a reason, and that is the entire mechanism. Carbon, Procore, and most mature systems wrap it in a calendar convention: deprecated in this major version, removed two majors later, migration guide attached. It is a flag and a promise, read by a human who sees the warning, stops reaching for the old thing, and moves on before the removal date.</p><p>That model was correct for fifteen years. It has one load-bearing assumption: that once a primitive is marked deprecated, adoption of it stops. A human reads the changelog and does not add new usages. The population of things depending on the deprecated primitive only shrinks. You wait, it drains, you remove it.</p><p>Your consumer is no longer a human reading a changelog. It is a generator. And a generator does not read your deprecation notice.</p><h4>The measured problem</h4><p>This is not a thought experiment. When researchers put seven advanced models against 145 API mappings across eight Python libraries in 28,125 completion prompts for the ICSE 2025 study “LLMs Meet Library Evolution,” the models emitted deprecated APIs in 25 to 38 percent of the relevant completions. A separate 2026 study on knowledge conflicts from evolving APIs found state-of-the-art models reach only 48 to 51 percent success on version-conditioned generation, meaning that even when you tell the model which version to target, it picks the wrong, often deprecated, surface about half the time. The cause is structural, not a bug that a patch fixes: models learn from a static historical corpus, so a primitive you deprecated last quarter is still the confident default in the weights, and no deprecated flag in a token file changes what the weights prefer.</p><p>Carry that into a design system that an in-canvas agent now writes to. You deprecate color.brand.legacyBlue and point it at color.brand.primary. Your human designers stop using it. But every time the agent generates a new screen, a new component variant, a new state, it reintroduces legacyBlue a third of the time, because that is what it saw ten thousand times in training and your advisory flag is invisible to it as a constraint. The migration team retires four old usages this week. The agent authors ten new surfaces and puts the deprecated token back into three of them. Your live-dependent count does not go down. It wobbles, and sometimes it goes up.</p><p>You have entered a state I will name, because naming it is the first useful move: Deprecation Divergence. The population of live dependents on a deprecated primitive fails to decrease monotonically, because generative emission reintroduces the primitive faster than migration retires it. The primitive is deprecated forever and removable never. Your design system accumulates a layer of undead tokens and components that every governance dashboard shows as deprecated and in migration for quarters on end, while the agent quietly keeps them alive.</p><h4>The thesis</h4><p>In an agent-native design system, deprecation must be designed to provably converge to zero live dependents, or it does not terminate.</p><p>That sentence is the whole framework, and it is worth being precise about why it is not obvious. The classic answer to “can I remove this” is static usage analysis: find every reference, and when the count hits zero, delete. Style Dictionary and Tokens Studio already build the reference graph that makes this possible. But find-usages-then-delete assumes the reference set is monotonically shrinking, or at least static, while you drain it. Under agent emission it is neither. Counting references is necessary and useless at the same time, because the number you count is invalidated by the next generation pass. The problem was never measurement. The problem is that nothing guarantees the thing you measured stays measured.</p><p>Convergent Deprecation is the model that supplies that guarantee. It has three parts.</p><h4>Component one: the Sunset Invariant</h4><p>State the property you actually need as an invariant, so a machine can check it. The Sunset Invariant: after a primitive enters the Deprecated state, its live-dependent set is monotonically non-increasing until it reaches zero.</p><p>Any round in which the count rises is a violation, and a violation has a name, Deprecation Divergence, and a cause you can always attribute: a new emission of a deprecated primitive. This matters because it converts a fuzzy governance worry into a decidable check over a time series. You do not need to predict whether a deprecation will finish. You watch the invariant. The first time it breaks, you know the deprecation is diverging and you know exactly which write did it.</p><h4>Component two: the Emission Freeze</h4><p>An invariant you cannot enforce is a wish. The Sunset Invariant is enforced by the second component, and this is the part with no prior art in either the design-token world or the protocol world. The Emission Freeze: the moment a primitive is deprecated, generative agents may no longer emit new uses of it, and the prohibition is enforced at plan time, not caught at review time.</p><p>This is deliberately not a lint warning and not a failed check after the fact. It sits at the same enforcement point as the OBJECT semantics in my earlier Decision Anchors work and the pre-write gate in the Permission Contract: the agent proposes to emit legacyBlue, the governance layer refuses the emission and reroutes it to the declared successor color.brand.primary before anything is written. A deprecation, in this model, is not a flag on a token. It is a redirect. The successor is not optional metadata, it is the thing the freeze routes to, which is why declaring it is mandatory.</p><p>The Emission Freeze is what makes the Sunset Invariant true by construction. If no new emission of a deprecated primitive can land, the live-dependent set cannot grow, so it is monotonically non-increasing, so it converges. The freeze is the inverse of a Decision Anchor: an anchor protects an intentional deviation from being auto-corrected toward convention, and a freeze prohibits a deprecated convention from being auto-emitted at all. Same machinery, opposite sign.</p><h4>Component three: the Convergence Gate</h4><p>The third component decides when removal is allowed, and it borrows its shape directly from what MCP just standardized. The Convergence Gate: a deprecated primitive is eligible for removal only when an executable conformance scenario proves two facts, that the live-dependent set is zero and that zero post-deprecation emissions occurred, or the guaranteed runway has elapsed and a human signs an explicit override.</p><p>The first clause is MCP’s conformance-gated Final status, pointed at a design primitive: you do not get to call something removable because a date passed, you get to call it removable because a scenario in your suite says no live consumer depends on it. The second clause is MCP’s minimum-window guarantee, imported as a safety valve so that a primitive that genuinely cannot converge does not become un-removable forever. But note the asymmetry the gate enforces: with the Emission Freeze on, the runway is almost never the binding constraint, because the set converges on its own. Removal by calendar is the fallback, removal by proof is the default.</p><h4>The reference implementation</h4><p>I built a small resolver to show the two regimes are not rhetorical. It models one deprecated token with eighteen live dependents, a migration that retires up to four per round, and an agent that authors ten new surfaces per round and re-emits the deprecated token thirty percent of the time, the midpoint of the measured 25 to 38 percent range. It runs with the Emission Freeze on by default and with a no-freeze flag to simulate today’s advisory deprecated flag. With only the advisory flag, the deprecation diverges:</p><pre> round  retired  re-emitted   live  note<br>    1        4           5     19  agent re-emitted 5 (freeze would have refused)<br>    2        4           5     20  agent re-emitted 5 (freeze would have refused)<br>    3        4           3     19  agent re-emitted 3 (freeze would have refused)<br>    4        4           0     15<br>    5        4           7     18  agent re-emitted 7 (freeze would have refused)<br>   ...<br>   12        4           4     13  agent re-emitted 4 (freeze would have refused)<br><br>Sunset Invariant: VIOLATED (Deprecation Divergence)<br>Emission-Freeze violations: 43<br>Convergence Gate: BLOCK REMOVAL. 13 live dependents remain; 43 post-deprecation emissions.</pre><p>The token started at eighteen dependents and, after twelve full rounds of active migration, sits at thirteen. It rose above its starting count twice. Forty-three new uses were authored after the deprecation. The runway elapsed and the primitive is not removable, because the set the calendar promised would drain never did. With the Emission Freeze on, the same migration, the same agent, the same re-emit rate:</p><pre> round  retired  re-emitted   live<br>    1        4           0     14<br>    2        4           0     10<br>    3        4           0      6<br>    4        4           0      2<br>    5        2           0      0<br><br>Sunset Invariant: HELD<br>Emission-Freeze violations: 0<br>Convergence Gate: ADMIT REMOVAL. Proof: 0 live dependents, 0 post-deprecation emissions. Removed at round 5.<br></pre><p>Every re-emit the agent attempted was refused at plan time and rerouted to the successor, so the set only shrank, and it hit zero in five rounds. The gate admits removal with a proof, not a promise. The difference between the two runs is not effort or discipline. It is whether the constraint lives at plan time or on a flag.</p><h4>Where this sits, and what it is not</h4><p>This extends a line of work and it is worth drawing the boundaries so the contribution is clear rather than inflated. It is not Decay Modes. That framework typed whether a governance record hardens or dissolves when it lapses. Convergent Deprecation governs a design primitive, not a record, and it supplies the one thing the dissolve pole quietly assumed but never guaranteed: that the thing being retired actually reaches a retirable state. Decay Modes told you which direction expiry should fail. This tells you how to guarantee expiry terminates at all.</p><p>It is not Proof-Carrying Design. PCD proves a change declared its full footprint. Convergent Deprecation proves a removal’s dependent set is empty and, crucially, that the set is trustworthy because emission was frozen. The proof-carrying pattern is shared and conceded. The novel part is the monotonicity guarantee under adversarial emission, which PCD has no mechanism for.</p><p>It is not static usage analysis or dead-code elimination. Those are the tools the Convergence Gate uses to count. The framework is the observation that counting is unsound without a freeze, and the freeze is the fix. It consumes the component-state signal from DSBOM, it can size the runway using the perceptual reach in Blast Radius Mapping, and it shares the pre-write enforcement point of the Permission Contract. It is one more piece in the same governance substrate, aimed at the one lifecycle event that substrate had not covered: getting rid of something.</p><h4>Failure modes</h4><p>A framework is only honest if it names where it breaks. No declared successor: if a primitive is deprecated with nowhere to route emission, the Emission Freeze degrades from a redirect into a hard stop that blocks the agent mid-task, so deprecation without a successor should be a separate, louder state, not the default. Over-scoped freeze: freezing a broad group when only one token is being retired will refuse legitimate work, so the freeze must be scoped to exactly the deprecated primitive. Override abuse: the runway-elapsed override exists for honest exceptions, and a team that treats it as the normal path has rebuilt calendar-based removal with extra steps, so overrides should be rare, signed, and audited. Measurement blind spots: the gate is only as good as the dependency graph, so a dependent outside the graph will read as zero when it is not, and the gate should fail closed on primitives whose full consumer set is not enumerable. Emergency removal: a primitive that is actively harmful cannot wait for convergence, which is why MCP kept a ninety-day expedited path, and this framework should too, an expedited removal that skips the runway but never skips the freeze, so the set stops growing while you scramble.</p><h4>How a team adopts this</h4><p>You do not need to rebuild your design system. You need three changes. Make deprecation a two-part state in your token and component metadata, a deprecated marker plus a required successor reference, not a lone boolean. Move the deprecation constraint into the plan-time layer your agent already reads, the same skill or ruleset that carries your other generation constraints, so the freeze is a rule the generator honors before it writes, not a check that fires after. And add one scenario to your CI: the live-dependent count of every deprecated primitive must be non-increasing since the last run, and removal is gated on that count reaching zero with no post-deprecation emissions. The first scenario catches divergence the day it starts. The gate makes removal a proof your pipeline can produce on demand.</p><h4>The takeaway</h4><p>The protocol layer figured this out first. MCP will not let a feature die on a calendar, it makes death a proven, gated, runway-protected event, because the ecosystem consuming those features moves too fast and too autonomously to trust a flag. Design systems now have the same kind of consumer, an agent that generates at machine speed and treats your deprecation notice as decoration. The deprecated flag was the right tool for a reader. It is the wrong tool for a writer. Convergent Deprecation is what deprecation has to become when the thing you are deprecating against is not a person who will stop, but a generator that will not, until you make it.</p><h4>Sources</h4><p>The 2026-07-28 MCP Specification Release Candidate: <a href="https://blog.modelcontextprotocol.io/posts/2026-07-28-release-candidate/">https://blog.modelcontextprotocol.io/posts/2026-07-28-release-candidate/</a></p><p>SEP-2596, Specification Feature Lifecycle and Deprecation Policy: <a href="https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2596">https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2596</a></p><p>SEP-2484, Require Conformance Tests for Standards Track SEPs to Reach Final: <a href="https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2484">https://github.com/modelcontextprotocol/modelcontextprotocol/pull/2484</a></p><p>W3C Design Tokens Format Module 2025.10 (the deprecated property): <a href="https://www.designtokens.org/tr/drafts/format/">https://www.designtokens.org/tr/drafts/format/</a></p><p>Wang et al, LLMs Meet Library Evolution, ICSE 2025 (25 to 38 percent deprecated API usage): <a href="https://dl.acm.org/doi/10.1109/ICSE55347.2025.00245">https://dl.acm.org/doi/10.1109/ICSE55347.2025.00245</a></p><p>When LLMs Lag Behind: Knowledge Conflicts from Evolving APIs, arXiv 2604.09515: <a href="https://arxiv.org/abs/2604.09515">https://arxiv.org/abs/2604.09515</a></p><p>Carbon Design System, Deprecations: <a href="https://carbondesignsystem.com/deprecations/">https://carbondesignsystem.com/deprecations/</a></p><p>Software Engineering at Google, Chapter 15, Deprecation: <a href="https://abseil.io/resources/swe-book/html/ch15.html">https://abseil.io/resources/swe-book/html/ch15.html</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ba1c87875adf" width="1" height="1" alt=""><hr><p><a href="https://www.designsystemscollective.com/convergent-deprecation-deprecation-does-not-terminate-when-your-consumer-is-a-generator-ba1c87875adf">Convergent Deprecation: Deprecation Does Not Terminate When Your Consumer Is a Generator</a> was originally published in <a href="https://www.designsystemscollective.com/">Design Systems Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kimi K3 Just Topped the Code Leaderboard. Here Is the Test That Actually Matters to Designers.]]></title>
            <link>https://medium.com/design-bootcamp/kimi-k3-just-topped-the-code-leaderboard-here-is-the-test-that-actually-matters-to-designers-e12d61938750?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/e12d61938750</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[coding]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Wed, 22 Jul 2026 04:25:07 GMT</pubDate>
            <atom:updated>2026-07-22T04:25:07.007Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5vuxS9xyZHFlNIfKZ4vdhA.png" /></figure><p>Design System Fidelity, a runnable test for whether an AI coding agent respects your system, not just whether its code runs.</p><p>On July 16, 2026, Moonshot AI released Kimi K3, and within days it sat at number one on the Frontend Code Arena with a score of 1,679, ahead of Claude Fable 5 and GPT-5.6. It is a 2.8 trillion parameter open model, and its weights go fully public on July 27. The coding world did what it always does. It opened a spreadsheet, lined up Kimi K3 against Claude Code and Codex, and started arguing about SWE-bench and Terminal-Bench numbers.</p><p>I am a designer. I read the same leaderboard, and I felt nothing, because it measures the wrong thing for us.</p><h4>The benchmarks answer a question designers never asked</h4><p>Every number in those comparisons is some version of “does the code work.” Does it pass the tests. Does it resolve the issue. Does it survive the terminal. Those are real questions, and if you ship backend services they might be the only questions.</p><p>They are not my question. When an agent builds a screen for me, I do not first ask whether it runs. I ask whether it looks like it belongs to the product I have spent two years shaping. Did it use our color roles or did it paint a purple that is almost, but not quite, our purple. Did it reuse our button or did it hand-roll a new one that behaves subtly differently. Did it respect the spacing rhythm or did it sprinkle pixel values that will drift out of sync the first time we retheme.</p><p>There is no leaderboard for that. So a tool can be state of the art on the Frontend Code Arena and still quietly wreck your design system on every screen it touches, and the benchmark will never tell you.</p><h4>Why agents drift, and why it is not their fault</h4><p>Here is the uncomfortable mechanic. An AI coding agent generates UI from what it can infer in the moment, not from the accumulated decisions your product was built on. If it cannot see your system, it produces its best guess, and its best guess is hardcoded. It writes a hex value like #6750a4 and a 20px radius that look right in isolation and match nothing you actually maintain. As one 2026 write-up on AI-assisted development put it, without tokenization the agent generates values that are close, but not the same, and different every time.</p><p>Tokens are the fix, because tokens are the one channel through which a generator can stay inside your visual language rather than inventing its own. Figma’s 2025 design systems research found that teams using semantic token names saw 43 percent better accuracy in AI-generated code. The gap is widest exactly where design lives: nested components, mode-based tokens, semantic alias chains. The model is not being lazy. It is being blind, and the difference between a faithful screen and a drifting one is whether you made your system legible to it.</p><p>That reframed the whole comparison for me. The interesting question is not which model is smartest. It is which output respects my system, and I wanted a way to measure that instead of eyeballing it.</p><h4>The test: a Design System Fidelity Score</h4><p>So I built a small one, and I want you to steal it. It is a script that reads a piece of generated UI code and scores it from 0 to 100 on how faithfully it used the design system, not on whether it compiles. It counts four things any designer already looks for by hand: how many references point at real design tokens, how many system components got reused, how many hardcoded colors and pixel values were invented instead, and how many raw elements were hand-rolled where a component already existed.</p><p>From those it produces a token fidelity percentage, a component fidelity percentage, and one blunt number I have come to trust more than any of them: the count of values a reviewer has to catch by eye. That last number is the real cost. Every hardcoded value is a thing a human has to notice, question, and fix before it rots the system.</p><p>To calibrate it I ran two versions of the same profile card through it against a public Material 3 contract. One was built the faithful way, with system components and tokens. The other was built the way agents drift, raw divs and buttons with inline hex and pixels. Same screen, same pixels on the surface. Here is what the test said.</p><pre> faithful.html<br>  token references:            10<br>  system component uses:       3<br>  hardcoded colors (hex):      0<br>  hardcoded dimensions (px):   0<br>  values a reviewer must catch by eye: 0<br>  DESIGN SYSTEM FIDELITY SCORE: 100 / 100<br>  verdict: SHIP (design-system-faithful)<br><br>drifting.html<br>  token references:            0<br>  system component uses:       0<br>  hardcoded colors (hex):      7<br>  hardcoded dimensions (px):   14<br>  values a reviewer must catch by eye: 21<br>  DESIGN SYSTEM FIDELITY SCORE: 0 / 100<br>  verdict: DRIFT (reinvents the system, do not merge as-is)<br>derboard. Here Is the Test That Actually Matters to Designers.</pre><p>Twenty-one values a human has to catch, on one card. Now multiply that by every screen an agent generates in a sprint. Both cards would pass a functional review. Both would render. One is a teammate and the other is a slow leak, and only the fidelity test can tell them apart before merge.</p><h4>How to actually compare Kimi K3, Claude Code, and Codex</h4><p>This is where I stop you from writing the spreadsheet everyone else wrote. Do not compare the three on their published benchmarks and pick the biggest number. Run the real test instead. Take one real screen from your product. Write one prompt for it. Send that identical prompt to Kimi K3, to Claude Code, and to Codex, each pointed at your actual token file and component library. Then score the three outputs with a fidelity check like this one. The tool you want is not the one that tops the Frontend Code Arena. It is the one whose output drifts least from your system, produces the fewest values your reviewers have to catch, and reuses your components instead of quietly reinventing them.</p><p>You will sometimes find the leaderboard winner is not your winner. A model that is marginally better at abstract coding puzzles can be markedly worse at staying inside a specific design language, because those are different skills and only one of them shows up in the rankings. The only way to know is to test on your system, with your tokens, on your screen.</p><h4>The real lever is not the model</h4><p>Here is the part that outlasts this week’s release. The models are converging and commoditizing. Kimi K3 is open weight and priced a fraction of the frontier, Claude Code and Codex will answer within the quarter, and by next year the gap between them on any given screen will be noise. You cannot build a moat on which model you picked, because everyone can pick the same one.</p><p>What does not commoditize is whether your design system is legible to whichever model you use. A tokenized, well-named, agent-readable system turns any competent model into a faithful contributor. An untokenized one turns even the best model into a hardcoding machine. The leverage moved from the generator to the system it generates against. Your tokens, your component contracts, and the one-page brief that tells an agent how to read them are now the most valuable thing you own, because they are what convert raw model capability into work that actually looks like your product.</p><p>So watch the Kimi K3 headline, enjoy it, and then close the leaderboard. The score that decides whether AI helps or harms your design is not on Moonshot’s benchmark page. It is the fidelity of the next screen an agent hands you, and that number is mostly up to you.</p><h4>Run it yourself</h4><p>The fidelity test is tiny and dependency-free. The system contract, the faithful and drifting samples, and the scorer are all in the reference folder for this piece. Point the scorer at any output from any agent, swap in your own tokens and components, and you have a repeatable way to grade AI coding agents on the one axis designers actually care about.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e12d61938750" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/kimi-k3-just-topped-the-code-leaderboard-here-is-the-test-that-actually-matters-to-designers-e12d61938750">Kimi K3 Just Topped the Code Leaderboard. Here Is the Test That Actually Matters to Designers.</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[I Asked Claude to Fix Its Own UX Using CLAUDE.md and DESIGN.md. It Failed.]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://www.designsystemscollective.com/i-asked-claude-to-fix-its-own-ux-using-claude-md-and-design-md-it-failed-d06ff6f3dae9?source=rss-d40b89c76dba------2"><img src="https://cdn-images-1.medium.com/max/1672/1*PabDgO3KGewZgOULgayySQ.png" width="1672"></a></p><p class="medium-feed-snippet">A reproducible experiment that uncovered a missing layer in AI-readable design systems.</p><p class="medium-feed-link"><a href="https://www.designsystemscollective.com/i-asked-claude-to-fix-its-own-ux-using-claude-md-and-design-md-it-failed-d06ff6f3dae9?source=rss-d40b89c76dba------2">Continue reading on Design Systems Collective »</a></p></div>]]></description>
            <link>https://www.designsystemscollective.com/i-asked-claude-to-fix-its-own-ux-using-claude-md-and-design-md-it-failed-d06ff6f3dae9?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/d06ff6f3dae9</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Mon, 20 Jul 2026 06:30:30 GMT</pubDate>
            <atom:updated>2026-07-20T06:30:30.183Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Design File Is No Longer the Source of Truth]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://www.designsystemscollective.com/the-design-file-is-no-longer-the-source-of-truth-7d0264e61c85?source=rss-d40b89c76dba------2"><img src="https://cdn-images-1.medium.com/max/1672/1*w22O0rqLcEN80zAtr-pukA.png" width="1672"></a></p><p class="medium-feed-snippet">Why Storybook Is Becoming the Executable Layer of Modern Product Systems</p><p class="medium-feed-link"><a href="https://www.designsystemscollective.com/the-design-file-is-no-longer-the-source-of-truth-7d0264e61c85?source=rss-d40b89c76dba------2">Continue reading on Design Systems Collective »</a></p></div>]]></description>
            <link>https://www.designsystemscollective.com/the-design-file-is-no-longer-the-source-of-truth-7d0264e61c85?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/7d0264e61c85</guid>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Sat, 18 Jul 2026 07:34:58 GMT</pubDate>
            <atom:updated>2026-07-18T07:34:58.144Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[AI to Agentic to Autonomous to You]]></title>
            <description><![CDATA[<div class="medium-feed-item"><p class="medium-feed-image"><a href="https://www.designsystemscollective.com/ai-to-agentic-to-autonomous-to-you-30983a469ba6?source=rss-d40b89c76dba------2"><img src="https://cdn-images-1.medium.com/max/1672/1*GlLQql8jhRgYr0kfS57osA.png" width="1672"></a></p><p class="medium-feed-snippet">We stopped chatting with AI. Now we manage it. Here&#x2019;s the rest of the ladder.</p><p class="medium-feed-link"><a href="https://www.designsystemscollective.com/ai-to-agentic-to-autonomous-to-you-30983a469ba6?source=rss-d40b89c76dba------2">Continue reading on Design Systems Collective »</a></p></div>]]></description>
            <link>https://www.designsystemscollective.com/ai-to-agentic-to-autonomous-to-you-30983a469ba6?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/30983a469ba6</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[agentic-ai]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Sat, 18 Jul 2026 07:32:44 GMT</pubDate>
            <atom:updated>2026-07-18T07:32:44.689Z</atom:updated>
        </item>
        <item>
            <title><![CDATA[The Motion Envelope: 30 Years After Flash, Figma Motion Still Cannot Say Why Anything Moves]]></title>
            <link>https://medium.com/design-bootcamp/the-motion-envelope-30-years-after-flash-figma-motion-still-cannot-say-why-anything-moves-8d87c19c997a?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/8d87c19c997a</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[motion-design]]></category>
            <category><![CDATA[accessibility]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Mon, 13 Jul 2026 07:39:36 GMT</pubDate>
            <atom:updated>2026-07-13T07:39:36.612Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A78Ed0MPUwDSjI7lX9qD3A.png" /></figure><p>Keyframes record how pixels move and nothing else. The Motion Envelope makes every animation declare its purpose, and a verifier proves the compiled keyframes stay inside the envelope that purpose earns.</p><p>The keyframe is older than most people using it. Burtnyk and Wein published computer-generated key-frame animation in 1971, borrowing the concept from traditional animation studios older still. Macromedia Flash mainstreamed it for interface work in the late 1990s, and every motion tool since (After Effects, Principle, ProtoPie, Figma’s Smart Animate, Lottie, Rive’s timelines) has refined the same abstraction: define states, interpolate between them, tune the curve. Thirty years of better ergonomics on an unchanged unit.</p><p>In 2026 that unit got an industrial supply chain. Adobe shipped what it calls semantic motion in After Effects on January 20, with an Auto-Keyframer that predicts object paths. At Config on June 24, Figma rolled out its Weave generation tools in open beta and introduced Figma Motion: a keyframe timeline inside Figma Design, motion attachable to design-system components so it travels the way fills and typography do, and a Dev Mode where, in Figma’s words, “every timing value, every easing curve, every keyframe is readable” and exportable as CSS, JSON, or React. Read that carefully: the largest design platform just made the complete HOW of motion inspectable at the component level, and the WHY appears nowhere in the artifact. All of these tools are remarkable, and all of them automate or expose the same thing: keyframe production. An agent that generates keyframes at scale is automating 1996, and the volume is now hitting design systems that have no way to evaluate what arrives.</p><p>Because here is what a keyframe records: how pixels move. Position, scale, opacity, over normalized time. Here is what it does not record, anywhere, in any format: why. Whether the motion is feedback confirming a tap, orientation explaining a layout change, or decoration that exists to be pretty. That missing fact is not a nice-to-have. It is the fact every meaningful judgment about motion depends on, including, as we will see, the one judgment the accessibility standards already require and no tool can make.</p><p>This article proposes the Motion Envelope: a governance model where every animation in a design system declares its purpose as a machine-read field, the purpose determines a machine-checkable constraint envelope, and a verifier proves the compiled artifact (the actual keyframes, not the design intention) stays inside it. The named gaming move it catches is lenient-envelope shopping. The named aggregate hazard is the surface overdraft.</p><h3>Motion governance exists. All of it is input-side.</h3><p>Let me be precise about the incumbents, because motion governance is no longer an empty field and pretending otherwise would be false.</p><p>Design systems ship motion tokens today. Material 3 publishes duration and easing token specs. IBM’s Carbon defines productive and expressive motion styles with tokenized curves. The W3C Design Tokens Community Group format defines first-class duration and cubicBezier types, while springs, keyframes, and composite motion still have no first-class types in the specification. Semantic naming (motion.duration.fast, not 200ms) is established practice.</p><p>Purpose taxonomies exist too, as guidance. The academic Taxonomy of Functional Animation classifies interface motion into functions like identifying, structural, guide, feedback, didactic, esthetic, and emotive, validated by expert survey. Material distinguishes functional from expressive motion. These taxonomies tell designers how to think. None of them is a field a machine reads.</p><p>And motion governance is now a product category. LottieFiles’ Motion System ships approved animation libraries, presets, and distribution workflows for teams, marketed on the argument that color has tokens and type has a scale while motion lacks an owner. It is a real product solving a real problem, and it defines the incumbent model: govern the inputs. Approve a library, bless the presets, control who can add to it. Their own FAQ states the philosophy plainly: once presets are baked into components, “there’s nothing left to check.”</p><p>That sentence is where this article begins. For the brand consistency of library-sourced assets, the scope the FAQ is actually about, it is fair. As a governance philosophy for what ships, it is exactly wrong. There is everything left to check. What ships is not the preset; it is the compiled output, produced by hand-tuned CSS, by a spring config someone tweaked, or increasingly by a generative tool that never consulted the library. Input-side governance approves what teams may reach for. Nothing verifies what actually moves. Governance by library and governance by verification are different capabilities, and the second one does not exist for motion, in any tool, at any layer of the stack.</p><h3>The exemption no checker can grant</h3><p>The sharpest proof that output-side motion governance is missing sits inside the accessibility standards everyone already claims to follow.</p><p>WCAG 2.3.3 (Animation from Interactions, Level AAA) requires that motion animation triggered by interaction can be disabled, “unless the animation is essential to the functionality or the information being conveyed.” WCAG 2.2.2 (Pause, Stop, Hide, Level A) makes the parallel carve-out for moving, auto-updating content, and because it sits at Level A it binds every conformance target, not just the ambitious ones. Both criteria hinge on the word essential, and essential is a purpose judgment.</p><p>Now look at the tooling. Automated accessibility checkers have gotten genuinely good at motion detection. LottieFiles ships a Lottie Accessibility Analyzer that inspects Lottie JSON before render and flags motion sensitivity risks, flashing, and contrast issues. TestParty detects WCAG 2.2.2 violations from source, catching CSS animations over five seconds and auto-advancing carousels. axe and friends check rendered pages. These tools are real, artifact-level in some cases, and they all share one structural limit: they enforce universal rules. Animation longer than five seconds, flag it. Flashing over threshold, flag it.</p><p>What none of them can do from the artifact alone is apply the standard’s own exemption, because the deciding fact (is this motion essential?) is not present in anything they read. A Lottie file does not say whether it is decoration or feedback. A CSS keyframe block does not say whether the motion conveys state or vibes. The most important clause in motion accessibility is undecidable by every checker on the market, not because the checkers are weak but because the input is missing the load-bearing field.</p><p>The Motion Envelope’s first claim is simply: put the fact in the artifact. Everything else follows from that.</p><h3>The Motion Envelope, in four parts</h3><p>One: purpose is a required, machine-read field. Every animation in the system declares one purpose from a small governed set. The reference implementation uses five: feedback, orientation, spatial_continuity, attention, and decoration, adapted from the Taxonomy of Functional Animation and Material’s functional/expressive split. The taxonomy is not the contribution; taxonomies are twenty years old. The contribution is the field: purpose moves from design guidance to declared, reviewable, machine-consumed metadata, the same shift design tokens made when color moved from a style guide PDF into JSON.</p><p>Two: the envelope is a function of the purpose. Each purpose earns a constraint envelope: duration ceiling, iteration limit, displacement bound, allowed trigger classes, and a required reduced-motion behavior. Feedback motion is brief, runs once, moves little, is user-triggered, and survives prefers-reduced-motion in simplified form, because feedback is essential in exactly the WCAG sense. Decoration may be long and looping, but it must drop to nothing under reduced motion, because decoration is the definition of nonessential. The binding is strict on purpose: an envelope is not a per-animation negotiation, it is what the declared purpose earns. The metaphor is the flight envelope: operate inside it and you are certified, exit it and you are not, and the envelope you get depends on what kind of aircraft you claimed to be.</p><p>Three, and this is the heart: a verifier checks the compiled artifact, not the intention. A small trusted checker ingests the actual output (CSS keyframes, Lottie JSON, spring parameters, normalized into one fact format), derives measured motion facts (total path displacement, duration, iteration count, trigger class, presence and kind of reduced-motion variant), and checks the facts against the declared purpose’s envelope. Tool-independence is the point: the same check governs hand-written CSS, a designer’s Lottie export, and whatever a generative canvas emits, because it reads what ships rather than what was intended. Reduced motion stops being a hand-authored afterthought and becomes a compile target derived from purpose: essential purposes degrade, decoration drops, and the absence of the required variant is a build failure, not an audit finding six months later.</p><p>The verifier also runs the mismatch detector, which catches the gaming move this design invites. If purposes earn envelopes, authors (human or agent) will shop for the lenient envelope: declare the infinitely pulsing notification badge as “feedback” to dodge decoration’s drop requirement. Some of that shopping is machine-detectable, because the compiled facts betray the declaration: feedback that loops forever and fires autonomously is decoration wearing a feedback badge, and the verifier flags it as a config error, not a style nit. Lenient-envelope shopping that survives the detector routes to human review, which is what Intent Diffs are for. Declared-intent systems always carry this residual; the difference here is the detectable cases are actually detected.</p><p>Four: the surface budget. Envelope conformance is per-animation, and per-animation checks have a known blind spot, one I have written about before as the Conformance Trap: individually conformant changes that aggregate into a degraded system. Motion has the sharpest version of it. Peripheral motion captures human attention involuntarily; that is what it is for, evolutionarily. For users with ADHD the capture cost is higher and recovery slower, and vestibular dysfunction, which more than 35 percent of adults have experienced by age 40, makes sustained ambient motion physically hostile. web.dev’s accessibility guidance and practitioner writing (Pope Tech, December 2025) both name ADHD distraction and vestibular harm as the core motion risks. Three tasteful ambient animations, each inside its decoration envelope, are still three things moving at once next to a checkout form.</p><p>So the Motion Envelope adds Surface Motion Load: each declared surface (a named composition unit listing its member animations) carries a budget for concurrent autonomous motion, and the verifier counts. The budget number is a governed default in the tradition of performance budgets, chosen and owned by the team, not an empirically derived perception threshold, and I will not pretend otherwise. Honest scope note: true concurrency depends on runtime layout and viewport composition, which compiled artifacts do not carry; the declared-surface approximation is checkable today, runtime verification is future work.</p><h3>The replay: keyframes pass, envelopes fail</h3><p>The reference implementation (motions.json plus motion_check.py) carries seven compiled animations across two surfaces and runs two worlds on identical inputs.</p><p>In envelope mode: M-01, a 180ms user-triggered button ripple declared as feedback, is inside its envelope and allowed. M-02, an ambient hero gradient drift declared as decoration with a proper reduced-motion drop, is allowed. M-03, a promo banner shimmer declared as decoration but compiled with no reduced-motion variant, is blocked: nonessential motion must drop, and the Level A failure (the 2.2.2 and 2.3.3 essential-motion exemptions) is caught at the artifact, before any page exists for an auditor to scan. M-04 is the shopping case: a notification badge pulse declared as feedback whose compiled facts loop infinitely and fire autonomously; the mismatch detector flags it as a config error, decoration wearing a feedback badge. M-05, a 420ms page transition declared spatial continuity, is allowed at 320px displacement, which would bury any universal displacement rule but is exactly what its purpose earns. Then the aggregate pass runs: checkout-form holds two autonomous motions against a budget of one, and home-hero holds three individually allowed decorations against a budget of two. Both surfaces are in overdraft. Note the deliberate rule in checkout-form’s count: both of its autonomous motions were already blocked per-animation, and they still count against the surface until they are removed, because blocking a merge does not un-ship what is currently live. Home-hero is the purer case: three animations that each pass their envelope, aggregating into a surface that fails its budget. The run exits 1 with four problems.</p><p>In keyframe-only mode, the status quo, the same seven animations are validated for well-formed, monotonic keyframes, which is the only check the artifact supports when purpose is not read. Everything passes. Exit 0. The purpose violations, the WCAG drop failure, the envelope shopping, and both overdrafts are invisible, and the summary line states the reason: the deciding fact is not in the keyframes.</p><p>The delta between those two exit codes, on byte-identical inputs, is the entire argument of this article in executable form.</p><h3>What this asks of teams, honestly</h3><p>Adoption cost lives in two places. The declaration burden: every animation needs a purpose field, which is one enum value, reviewable in the same pull request as the motion itself, and exactly the kind of field an agent can be required to emit with its output. And the decompiler tier list: Lottie JSON and spring configs normalize cleanly and should be the first supported tier; CSS keyframes are the hard tier (relative units, composed transforms, values resolvable only at runtime), and a team should scope the first deployment to the formats its motion actually ships in rather than promising universal coverage on day one.</p><p>For the ecosystem this slots into, three connections and one refusal. Motion changes are Trapdoor-prone in Blast Radius Mapping terms: tiny structural fan-out, enormous perceptual reach, exactly the quadrant a dependency-sized gate auto-merges. Envelope results are natural components of a Proof-Carrying Design receipt, so an agent’s motion change arrives with its envelope check attached. Purpose declarations are precisely the kind of settled intent Intent Diffs surface for human review. And the refusal: this is not a fourth contract. The Three Contracts already cover it; purpose is the meaning contract for a motion primitive, the envelope is its method contract, and who may add motion to which surface is its permission contract. The Motion Envelope is the three contracts instantiated for the one token class that never got them.</p><h3>Failure modes</h3><p>Envelope shopping beyond the detector. The mismatch detector catches fact-contradicted declarations; a plausible false purpose on a borderline animation survives it. Residual for human review, same as every declared-intent system, including mine.</p><p>Agent-emitted purposes. The adoption story asks agents to emit the purpose field with their output, and when the same agent emits both the keyframes and the declaration, the declaration is not an independent signal; it is the fox filing its own flight plan. In that deployment the mismatch detector stops being auxiliary and becomes load-bearing, and its current coverage is narrow. Expanding fact-contradiction rules per purpose, and routing every agent-declared purpose through Intent Diffs, is the honest price of agent-generated motion.</p><p>Taxonomy wars. Teams will dispute whether five purposes suffice. They will not suffice for everyone; the governed set is extensible per system. The invariant that matters is not the list, it is that every purpose in the list carries an envelope and every animation carries a purpose.</p><p>Invented thresholds. 300ms feedback ceilings and budget-of-two surfaces are defensible defaults, not perception science. Publishing them as science would be the pseudo-quantification mistake; they are governed values a team tunes, like performance budgets, and the verifier’s job is consistency, not truth.</p><p>Reduced-motion theater. A team can compile a “simplified” variant that is barely simpler. The envelope checks presence and kind, not aesthetic sufficiency. Sufficiency stays with human review; the envelope guarantees the variant exists and the drop actually drops.</p><h3>The takeaway</h3><p>Motion is the token class where design systems still accept the 1971 abstraction as the artifact of record, and generative tools are now filling that artifact at industrial rates. The incumbent answer governs the library. The missing answer governs the output, and it becomes possible the moment the artifact carries one more field. A keyframe says how. A purpose says why. An envelope makes the why checkable, and a design system that can check the why of motion can finally extend to its most perceptually powerful primitive the same discipline it learned to apply to a hex value.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*9QjXbLWcR6GNXS7PlTLHIg.png" /></figure><p>Described diagram: a three-lane horizontal flow. Lane one, authoring: three sources (hand-written CSS, a Lottie export, a generative canvas node graph) all emitting keyframe documents into a funnel. Lane two, the checkpoint: each document paired with a small purpose tag (feedback, decoration, spatial continuity) entering a gate shaped like a flight envelope chart, with an inset magnifier showing measured facts (duration, displacement, loop, reduced-motion variant) being compared against the envelope curve for its declared purpose; one document bounces off the curve marked SHOPPING. Lane three, the surface: allowed animations landing on two labeled viewport rectangles, one calm and within budget, one glowing amber with a counter reading 3 of 2 and the label SURFACE OVERDRAFT.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8d87c19c997a" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/the-motion-envelope-30-years-after-flash-figma-motion-still-cannot-say-why-anything-moves-8d87c19c997a">The Motion Envelope: 30 Years After Flash, Figma Motion Still Cannot Say Why Anything Moves</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Token Structure That Survives Five Products (Google Uses It Too)]]></title>
            <link>https://www.designsystemscollective.com/the-token-structure-that-survives-five-products-google-uses-it-too-c480e864ef64?source=rss-d40b89c76dba------2</link>
            <guid isPermaLink="false">https://medium.com/p/c480e864ef64</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[token]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ux-design]]></category>
            <dc:creator><![CDATA[Surendar Selvaraj]]></dc:creator>
            <pubDate>Mon, 13 Jul 2026 06:29:39 GMT</pubDate>
            <atom:updated>2026-07-13T06:29:39.800Z</atom:updated>
            <content:encoded><![CDATA[<h3>It is the same three-tier system Google runs across Android in Material 3. But the reason to build it changed this year: your design system quietly became an API, and tokens are its type system, the contract every AI agent reads before it touches your UI.</h3><p>Most design systems don’t fail because the components are wrong. They fail because a single color lives in four hundred places. The structure that fixes that is the same one Google runs in Material 3, and I will walk through it with copy-paste code below.</p><p>But first, the shift almost nobody has named yet, because it is the reason this stopped being a styling topic.</p><p>For twenty years, a design system was documentation. Something humans read, interpreted, and mostly followed. Its audience was people, and people forgive ambiguity. They fill gaps with judgment.</p><p>That era is over. Your design system now has a second reader, and it does not forgive anything. AI agents read your system directly, over open protocols, and they build real UI from what they find. The moment that happened, your design system stopped being a document and became an interface. An API.</p><p>And an API without a type system is a liability. That is what most design systems are today: a pile of hex codes wearing friendly names, held together by the collective memory of a team that is about to be outnumbered by machines. This piece is about the type system that fixes it, told with copy-paste code, diagrams you can regenerate yourself, and a claim I will defend all the way down: tokens are no longer styling. They are the contract between your brand and every agent that renders it.</p><h3>The problem</h3><p>Here is how it starts. Innocently.</p><p>You ship the first product. A button needs a brand color, so you write it in:</p><pre>.button-primary {<br>  background: #6750A4;<br>}</pre><p>It works. You move on. A second product reuses the component. A third team forks it “just for now.” Eighteen months later, marketing asks for a small brand refresh, a slightly different blue, and a dark theme while you are at it.</p><p>Now that one hex value is sitting, hardcoded, in hundreds of files across several codebases. Nobody knows exactly where. What should be an afternoon becomes a multi-week migration, a spreadsheet of screens, and a QA cycle. The “small refresh” quietly becomes a quarter of work.</p><p>The problem, stated plainly: when your components hold raw values, every visual change is a manual hunt. The system has no single place to make a decision, so every decision is made everywhere.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4fZyGHLvw5-WJueMDQmw6Q.png" /></figure><h3>Why one flat layer is not the fix</h3><p>Most teams reach for tokens at this point, and stop halfway. They create one flat list of named values:</p><pre>{<br>  &quot;blue-600&quot;: &quot;#6750A4&quot;,<br>  &quot;button-background&quot;: &quot;#6750A4&quot;,<br>  &quot;link-color&quot;: &quot;#6750A4&quot;<br>}</pre><p>This feels like progress. It is not. button-background and link-color both point straight at a raw value. The names changed. The coupling did not. The moment &quot;primary&quot; needs to become a different blue, you are back to find-and-replace.</p><p>The problem was never that you skipped tokens. It is that you used one layer where you needed three.</p><h3>The solution: three tiers</h3><p>Material 3 splits tokens into reference, system, and component. Each tier points at the one below it, and that chain is the entire trick. Here is each layer, with copyable examples in the <a href="https://www.designtokens.org/">W3C Design Tokens format</a>.</p><h3>Tier 1: Reference tokens (the raw values)</h3><p>These describe what a value <em>is</em>, never where it is used. This is your palette, your type scale, your spacing ramp, sitting quietly at the bottom.</p><pre>{<br>  &quot;ref&quot;: {<br>    &quot;palette&quot;: {<br>      &quot;primary40&quot;:  { &quot;$value&quot;: &quot;#6750A4&quot; },<br>      &quot;primary90&quot;:  { &quot;$value&quot;: &quot;#EADDFF&quot; },<br>      &quot;neutral10&quot;:  { &quot;$value&quot;: &quot;#1C1B1F&quot; }<br>    }<br>  }<br>}</pre><p>Reference tokens never change based on context. md.ref.palette.primary40 is that hex, everywhere, always.</p><h3>Tier 2: System tokens (the semantic roles)</h3><p>System tokens assign meaning. They say “primary means this reference, right now, in this theme.” They describe a role, not a value. This is where a theme’s character actually lives.</p><pre>{<br>  &quot;sys&quot;: {<br>    &quot;color&quot;: {<br>      &quot;primary&quot;:           { &quot;$value&quot;: &quot;{ref.palette.primary40}&quot; },<br>      &quot;primary-container&quot;: { &quot;$value&quot;: &quot;{ref.palette.primary90}&quot; }<br>    }<br>  }<br>}</pre><h3>Tier 3: Component tokens (the usage)</h3><p>Component tokens are the last mile. A component asks for a role and the role resolves down the chain. A button never reaches down to a raw hex.</p><pre>{<br>  &quot;comp&quot;: {<br>    &quot;fab&quot;: {<br>      &quot;container&quot;: {<br>        &quot;color&quot;: { &quot;$value&quot;: &quot;{sys.color.primary-container}&quot; }<br>      }<br>    }<br>  }<br>}</pre><p>Compiled to CSS custom properties, the whole chain reads cleanly:</p><pre>:root {<br>  --md-ref-palette-primary40:     #6750A4;                         /* raw */<br>  --md-sys-color-primary:         var(--md-ref-palette-primary40); /* role */<br>  --md-comp-fab-container-color:  var(--md-sys-color-primary);     /* usage */<br>}</pre><p>Read it top to bottom and the discipline is obvious: a button does not know what blue is. It knows it wants the “primary” role. The system decides what primary means. The reference layer holds the actual value. Three questions, three answers, cleanly separated.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kLXDV5zTOJQxIbT7zf1xDQ.png" /></figure><h3>Why the chain matters</h3><p>This is not architecture for its own sake. It is the reason <a href="https://m3.material.io/styles/color/dynamic-color/overview">Dynamic Color</a> works.</p><p>Because every component token points at a semantic system token rather than a literal reference value, you can swap the system layer and the entire interface re-themes at once, consistently and correctly. Change what “primary” means and every button, every FAB, every accent follows, because none of them were holding the hex code. They were holding a promise the system kept.</p><p>That is the payoff you actually want:</p><ul><li>A rebrand becomes a swap at the system layer.</li><li>Dark mode becomes an alternate set of system tokens.</li><li>A new product theme becomes configuration, not a redesign.</li></ul><p>You stop migrating and start switching.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*052LUYyTqzw62N-qHC58CA.png" /></figure><h3>Why this matters more now</h3><p>For years this was a nice-to-have that senior people argued for and everyone else deferred. That changed when agents entered the file.</p><p>AI agents now read your design system directly. Through the <a href="https://modelcontextprotocol.io/">Model Context Protocol (MCP)</a>, a model can pull your real tokens and components, the actual named values, not a guess inferred from a screenshot. When it generates a screen, it can reach for your system tokens the same way your engineers do.</p><p>But that only works if your tokens carry meaning. If your system is a flat list of hex codes with pretty names, an agent gets the same brittle result your team gets: output that looks right and is quietly wrong the moment anything changes. A clean, semantic token layer is what makes AI-generated UI correct instead of confidently wrong. The structure that saved you during a rebrand is now the structure that keeps a machine honest.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Og3Mcpl_3ppnGa5z7ZNTdw.png" /></figure><h3>What is coming next</h3><p>Push this one step further. Right now a single agent reads your system over MCP. Soon you will have several: a design agent, a code agent, a QA agent, coordinating through agent-to-agent protocols like <a href="https://a2aproject.github.io/A2A/">A2A</a>, which now sits alongside MCP under the Linux Foundation’s Agentic AI Foundation.</p><p>When multiple agents collaborate on a feature, they need a shared, unambiguous source of truth. That source of truth is your design system, and specifically its tokens. Teams whose systems encode intent, not just values, will hand agents something they can build on. Teams whose systems are a pile of hex codes will hand agents something they can only guess at.</p><p>I made the fuller case for this shift in <a href="https://www.designsystemscollective.com/your-design-system-has-two-users-now-you-only-documented-it-for-one-b7ce74f3edea">Your Design System Has Two Users Now, You Only Documented It for One</a>. This piece is the token-level companion to it: the two readers are humans and agents, and tokens are the layer where you finally speak to both in the same language.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*JswrATqe1GUsbqSZSTRDlQ.png" /></figure><h3>The one rule</h3><p>If you take a single thing from this, take the rule that makes the whole model work:</p><blockquote><strong><em>Components never point at raw values.</em></strong><em> If a button knows a hex code, the system has already leaked, and every promise above it is void.</em></blockquote><p>Everything else, the naming conventions, the tiers, the tooling, is in service of that one boundary.</p><h3>How to migrate without a big-bang rewrite</h3><p>You do not need to rebuild everything on Monday. Do it in five moves:</p><ol><li><strong>Audit.</strong> Grep your component code for raw hex values (#[0-9A-Fa-f]{3,6}). That count is your technical debt, made visible.</li><li><strong>Extract primitives.</strong> Pull every raw value into a reference layer. Change nothing else yet.</li><li><strong>Add the semantic layer.</strong> Introduce system tokens that point at references. Name them by role: color-action, color-surface, color-on-surface.</li><li><strong>Repoint components.</strong> One component at a time, swap raw values for system tokens.</li><li><strong>Seal the boundary.</strong> Add a lint rule that fails the build if a component references a primitive or a raw hex directly.</li></ol><p>Five products from now, that boundary is the difference between a switch and a migration.</p><h3>The bigger shift</h3><p>Step back from the syntax for a moment.</p><p>We spent a decade teaching design systems to speak to humans: guidelines, examples, do’s and don’ts, the soft tissue of a shared craft. That work was never wasted. But it was built on an assumption that just quietly broke: that the reader could think.</p><p>Agents cannot fill your gaps with taste. They resolve what you encoded and nothing more. So the quality of your token layer is no longer a matter of engineering hygiene. It is the ceiling on how correctly a machine can express your brand at scale. A semantic token system is you, telling every current and future agent what you meant, in a language it cannot misread.</p><p>That is why this is not a styling topic anymore. The teams that win the next few years will not be the ones with the prettiest components. They will be the ones whose intent is legible to both audiences at once, the human and the machine, from a single source of truth. Reference, system, component. Raw value, role, usage. It is a small structure. It is about to carry an enormous amount of weight.</p><p>Build it now, while it is still a choice. Soon it will be the difference between a system an agent can build on and a system an agent can only guess at, and the guess will ship to production before anyone notices.</p><p>The design system stopped being documentation. Treat it like the API it became.</p><p>If your components still hold raw hex today, that is the first thing I would fix this week. What is your token setup, one flat layer or three?</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c480e864ef64" width="1" height="1" alt=""><hr><p><a href="https://www.designsystemscollective.com/the-token-structure-that-survives-five-products-google-uses-it-too-c480e864ef64">The Token Structure That Survives Five Products (Google Uses It Too)</a> was originally published in <a href="https://www.designsystemscollective.com/">Design Systems Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>