Design Systems

252 posts

figma3 min readCurated summary

What the Design-to-Code Loop Unlocks | Figma Blog

AI is bringing design and engineering into a more continuous, bidirectional workflow. Instead of treating code as an expensive final step, teams can use functional prototypes, editable designs, and AI assistance to explore behavior and visuals together. The result is broader participation, faster learning, and a shift from mechanical translation between design and code toward more semantic collaboration. ## AI Makes Code Part of Design Exploration - Code was traditionally costly and difficult to revise, while design allowed cheap, broad exploration. - AI reverses that relationship by making functional wireframes easier to create and iterate. - Designers can explore interaction and behavior—not just static layouts—then move work between code and canvas. - AI can translate between the two mediums in a way that preserves intent and structure rather than simply converting files or syntax. ## A More Bidirectional Collaboration Model - Code-based workflows tend to move in one direction and are often constrained by the patterns already present in a codebase. - Figma’s canvas gives teams space to reconsider assumptions and explore radically different directions. - Designers and developers can work from the same evolving artifact instead of repeatedly handing work off. - AI lowers participation barriers: people without access to an internal design system can import a live product into Figma as editable frames and begin contributing. ## Lower Learning Curves for Designers and Developers - AI turns steep technical learning curves into gradual ramps by providing a capable starting point. - People can learn frameworks, routes, React, and other concepts in the context of real work rather than abstract exercises. - Designers can extend beyond previous technical limits into areas such as shaders, 3D, and custom tools. - Deeper specialization remains possible, but the initial investment is much smaller and learning becomes more contextual. ## Curiosity as the New Differentiator - When AI tools become broadly available, access to technology alone is less likely to distinguish practitioners. - Curiosity and taste become more important: people who actively experiment can discover new possibilities. - AI functions as a patient tutor, reducing the friction of learning tools, frameworks, syntax, and development environments. - Staying effective requires continually exploring what can be built rather than relying only on existing technical expertise. The design-to-code loop is therefore less about replacing designers or developers and more about making experimentation and collaboration accessible across disciplines. Teams should treat AI as both a creative medium and a learning partner, moving freely between canvas and code while preserving room to question the initial direction.

Read original(opens in new tab)
figma2 min readCurated summary

Workflow Lab: Expanding the Canvas with Figma MCP | Figma Blog

Figma’s workflow demonstrates how the Figma MCP server can reconnect design and implementation as features evolve. By reading coded states and generating editable frames on the canvas, an agent exposes product behavior that was invisible in the original design. This lets designers improve real edge cases and compare the shipped experience with design intent earlier. ## The problem: Code creates new product states - Astra, a fictional AI video platform, ships features rapidly with agentic coding tools. - An initial export flow covered sequence selection, format choice, settings confirmation, and export. - As development progressed, additional states appeared: - Encoding errors - Rendering and loading progress - Empty selections - Unsupported formats - These states were not necessarily design oversights; they emerged from real code and data. - When the canvas represents only the initial flow, designers cannot fully address the experience users will encounter. ## Expanding the canvas with Figma MCP - The Figma MCP server allows an agent to read implementation details and write results to the Figma canvas. - Using `use_figma`, the agent identifies coded states and creates editable frames using the team’s design-system components. - Astra’s canvas expands from four original frames to fourteen frames representing the broader product reality. - This replaces a slower task-and-ticket feedback loop with a direct conversation between design, code, and the agent. ## Designing better edge cases - The designer can immediately work on states that previously remained hidden: - Adds recovery guidance to the encoding error state. - Enhances the render loading state with progress information and an estimated completion time. - Adds copy and personality to the empty-selection state to encourage feature adoption. - Designers spend less time discovering missing requirements and more time shaping actual product behavior. - The canvas becomes a shared workspace for reviewing the full experience, not merely documenting the initial concept. ## Comparing design and implementation - The workflow also places the coded version beside the original Figma design for visual comparison. - A findings panel surfaces discrepancies by severity. - Example differences include: - A larger modal title - An additional “Post share link” button - A removed settings-panel surface - A demoted settings header The practical recommendation is to use Figma MCP as an ongoing design-code feedback loop: bring real implementation states onto the canvas, refine them with design expertise, and use visual comparisons to catch drift before it becomes part of the shipped product.

Read original(opens in new tab)
figma2 min readCurated summary

The TL;DR on MCP: Why Context Matters and How to Put It to Work | Figma Blog

MCP (Model Context Protocol) connects AI tools to the design decisions and data stored in tools like Figma. Figma argues that giving coding agents structured access to components, tokens, and layout rules produces code that better matches the intended design and design system. It also creates a two-way workflow in which developers and designers can move between code and canvas without losing context. ## MCP Connects Design and Development - Product work is increasingly iterative rather than a linear design-to-development handoff. - MCP lets AI coding tools access Figma files as structured design sources, not merely as screenshots. - Figma’s MCP server helps bring design context into code, while code-to-canvas tools can bring working interfaces back into Figma. - This keeps the broader product team involved as designs and implementations evolve. ## Why Context Matters for AI-Generated Code - Without context, an AI tool may: - Choose a color that resembles the brand color but is not linked to the correct design token. - Recreate a card instead of reusing an established component. - Flatten a complex, nested form into a single basic element. - These seemingly minor deviations accumulate across screens and components. - MCP exposes the underlying components, tokens, and layout decisions that explain how a design was built. ## Designers: Files Directly Influence Production Code - Design systems now influence not only human implementation but also AI-generated code, from prototypes through production. - Well-structured, consistent Figma files can guide AI toward more reliable and on-brand results. - Poor organization or small inconsistencies can spread widely because AI reproduces them at scale. - MCP also lets designers review code-built interfaces in Figma, add missing states, refine details, and prepare work for production without starting over. ## Developers: Less Translation, More Building - AI coding tools can accelerate implementation, but their output is less accurate when design intent is unavailable. - MCP reduces the translation required between a visual design and working code by supplying the system and component context behind the design. - Developers can spend more time building instead of reconstructing design decisions from screenshots or incomplete handoffs. Figma’s practical recommendation is to treat design files and design systems as active inputs to AI workflows. The better the structure and context captured in those files, the more consistently AI can generate code that reflects the intended product.

Read original(opens in new tab)
toss3 min readCurated summary

Why Toss reduced its design roles to two

On April 1, Toss’s Design Chapter consolidated six design roles into two: Product Designer and Visual Designer. The change reflects how role boundaries had already blurred as designers crossed disciplines and technology reduced the importance of tool-specific expertise. Toss’s central argument is that designers should be organized around judgment and user problems—not the tools, media, or screens they work with. ## Why Role Boundaries Became a Problem - The previous structure separated designers by tools and outputs rather than by the decisions they made. - Ambiguity emerged in areas such as: - Whether interaction in a design system belonged to Platform or Interaction Designers - Whether interactive graphics should be handled through Lottie, code, or UI design - Whether expanding a PC product to mobile belonged to a Tools Product Designer or Product Designer - These divisions sometimes determined ownership based on medium instead of capability or context. ## Designers Were Already Crossing Disciplines - Tools Product Designers began designing mobile products. - Interaction Designers worked on parts of internal design tools. - Graphic Designers created semantic icon systems. - Platform Designers built interactive web pages. - Brand Designers with visual-design backgrounds worked on lighting products. - AI and other tools have shortened the time needed to learn formerly specialized skills, including: - Video and Lottie production - Figma prototyping - Coding interactive experiences - As tool proficiency becomes less differentiating, the ability to judge what creates a good experience becomes more important. ## Product Designer - Product Designer and Tools Product Designer were merged into one role. - The distinction between mobile and PC disappeared. - The role now focuses on: - Understanding the user’s context and problems - Deciding how those problems should be solved - Designing across screen sizes and product environments ## Visual Designer - Platform, Interaction, Graphic, and Brand Designers were combined into Visual Designer. - Visual Designers are expected to work across media and produce what the experience requires, such as: - Building interactions within systems - Creating icons for prototypes - Designing interactive web experiences - The defining capability is visual judgment: deciding what is beautiful, appropriate, and correct. - The title was chosen to emphasize visual decision-making rather than a specific medium or technique. ## Lessons from Other Industries - Disney animation reduced many physical and intermediate production steps through software while preserving stages requiring important creative judgment. - Digital audio workstations allow artists such as Billie Eilish and Finneas to compose, perform, record, and mix with a laptop, but human judgment about what sounds good remains essential. - Digital cinema and streaming weakened the historical distinction between film and television production. - Across these industries, tools converged while the value of creative judgment increased. ## What Comes Next - The new job structure will not immediately change how people work. - Toss still needs to redesign hiring standards, onboarding, and career-development paths. - The consolidation is intended to give designers broader ownership and more room to make decisions across disciplines, ultimately improving the experiences delivered to users.

Read original(opens in new tab)
figma2 min readCurated summary

Build With More Context and More Control in Figma Make | Figma Blog

Figma’s Make kits and Make attachments add structured context to AI-generated prototypes, helping them start closer to production reality. Make kits provide design-system guidance through code packages, libraries, styles, and tokens, while attachments bring in project-specific data and requirements. Together, they reduce cleanup and make generated designs more consistent with how products are actually built. ## Make Kits Teach Make About the Design System - Make kits are reusable packages that combine components or styles with guidelines explaining how they should be used. - They can use: - JavaScript components from public npm packages - Packages from Figma’s secure private registry - Styles and design tokens from Figma libraries - Guidelines tell Make not only which components exist, but also how to apply them. - Instead of starting with generic UI and repeatedly correcting spacing, patterns, and components, Make can begin with production-aligned structures. - This helps: - Maintain consistency across forms, dashboards, settings, and onboarding - Let teams generate work in parallel without drifting from the design system - Reduce preparation and correction before review - Engineers can more easily recognize familiar components and focus on evaluating the proposal rather than translating it into their system. - Figma plans to expand kits to represent more design-system structure, including component structures from Figma libraries. ## Make Attachments Ground Prototypes in Project Context - Design systems do not capture every project-specific constraint, such as: - Real data - Migration requirements - Edge cases - Compliance rules - Legal copy and content - Make attachments allow users to provide source material directly instead of describing everything in a long prompt. - Supported materials include: - PDFs and Markdown files - CSV and JSON datasets - Screenshots and images - Brand guidelines - Legal copy - Media and SVG files - Code and other project assets - Attachments help Make create prototypes that reflect actual data, validation states, content, and requirements rather than producing an idealized version that omits complexity. - For example, an onboarding flow can be grounded in real user data, complete legal requirements, and multiple validation states instead of shortened copy and simplified edge cases. ## A More Production-Aligned Starting Point - Make kits provide the reusable design and code foundation. - Attachments add the details and constraints unique to a specific project. - The combination is intended to shorten the distance between an AI-generated prototype and a shippable product, allowing teams to spend less time rewriting and more time refining the experience.

Read original(opens in new tab)
figma3 min readCurated summary

Agents, Meet the Figma Canvas | Figma Blog

Figma is opening its canvas to AI agents, allowing tools such as Claude Code and Codex to create and modify designs directly in Figma files. Through the `use_figma` tool and customizable skills, agents can use a team’s components, variables, design decisions, and workflows instead of producing generic designs. The feature is free during beta but is expected to become usage-based and paid. ## Agents Work Directly on the Figma Canvas - Figma’s MCP integration lets agents read and write Figma files through the `use_figma` tool. - Agents can create or update: - Design assets - Components - Files based on existing design systems - Designs linked to established variables and conventions - Teams can move between code, the command line, and Figma while keeping design context shared. - Figma positions the canvas as the place where product decisions become visible and refined. ## Working Across Code and Canvas - The existing `generate_figma_design` tool converts HTML from live apps and websites into editable Figma layers. - The new `use_figma` tool operates directly on the canvas, using existing components and variables. - The tools are intended to work together: - `generate_figma_design` brings current implementation details into Figma. - `use_figma` edits those designs or creates new system-aligned assets. ## Skills Encode Design Intent - Skills are Markdown-based instructions that tell agents: - Which workflow steps to follow - What sequence to use - Which team conventions to respect - What quality standards and specialized knowledge to apply - Anyone can author a skill without building a plugin or writing traditional code. - The foundational `/figma-use` skill teaches agents Figma’s structure and core principles. - Teams can customize that foundation to reflect their own design systems and working methods. ## Example Skills and Workflows Figma highlights skills for tasks such as: - Generating component libraries from code - Creating designs from existing components and variables - Producing accessibility specifications for VoiceOver, TalkBack, and ARIA - Creating components from structured JSON contracts - Applying design systems to existing designs - Managing spacing through variables and fallbacks - Synchronizing design tokens between code and Figma - Running parallel, multi-agent design workflows ## More Predictable and Self-Correcting Output - Skills make AI behavior more consistent by encoding repeatable instructions and implementation rules. - Agents can use screenshots to identify mismatches and iteratively refine generated screens. - Because agents work with real Figma structure—components, variables, and auto layout—corrections affect the underlying design system rather than only the visual appearance. - Team conventions become active rules that agents apply during creation, rather than static documentation they merely reference. Figma’s agent workflow is most useful when teams invest in well-defined components, variables, and skills. During the beta, teams can experiment with `use_figma` and community skills to automate design work while preserving their existing design intent and system standards.

Read original(opens in new tab)
figma2 min readCurated summary

How We Rebuilt the Foundations of Component Instances | Figma Blog

Figma replaced its decade-old Instance Updater with a reactive foundation called Materializer. The change separates component resolution from layout and variable evaluation, while enabling granular updates instead of recalculating entire instance trees. Figma reports that common operations in large design systems are now up to 50% faster, and the architecture can support other dynamic features beyond components. ## Why the Original Architecture No Longer Scaled - Instance Updater was introduced around 2016 to resolve component properties, manage instance structure, and synchronize instances with their main components. - Over time, Figma added features such as: - Auto layout in 2019 - Variants in 2020 - Component properties in 2022 - Variables in 2023 - Slots, introduced as an open beta feature in 2025 - Modern instances can combine variants, variable bindings, auto layout, nested instances, variable modes, and extensive overrides. - A small edit can therefore propagate through deeply nested trees and trigger widespread recalculation. - Instance Updater accumulated specialized logic for layout, variables, and other integrations, making it increasingly fragile and slow. - In extreme cases, systems repeatedly invalidated one another, causing actions such as instance swaps or property changes to take seconds. ## The Goals of the Rewrite - Figma concluded that incremental optimization would not solve the underlying architectural problems. - The new design aims to separate responsibilities: - The instance system resolves which properties and children an instance should have. - Layout systems handle layout calculations. - Variable systems handle variable evaluation. - Updates should be granular, affecting only the portions of a tree that actually changed rather than rebuilding entire instances. - Figma also wanted reusable infrastructure for dependency tracking, reactive updates, and efficient invalidation across the editor. ## Materializer and Derived Subtrees - Figma built **Materializer**, a generic system that operates on the document tree. - Its purpose is to create and maintain **derived subtrees**—structures whose properties and hierarchy are computed from other sources of truth. - Component instances are one use case, but the same model can support features such as rich text nodes whose content is synchronized with an external CMS. - This broader abstraction allows teams to build dynamic features without embedding bespoke update logic into a single specialized runtime. The rewrite turns component instances from a monolithic synchronization problem into one application of a more general reactive system. By isolating responsibilities and invalidating only affected subtrees, Figma improves performance for complex design systems while creating a foundation for future dynamic features.

Read original(opens in new tab)
figma2 min readCurated summary

How to Supercharge your Design System with Slots | Figma Blog

Slots let designers customize components without detaching them from a design system. By allowing content to be inserted into stable structures—much like components work in code—slots reduce variant sprawl, preserve consistency, and improve design-to-development handoff. Figma recommends starting with high-traffic components and using default content strategically to balance guidance with flexibility. ## Why Slots Matter - Growing design systems often become restrictive, leading teams to: - Create excessive variants - Expand component libraries - Detach instances - Develop workarounds outside the system - Slots allow designers to change content while preserving a component’s underlying structure. - The approach mirrors code-based composition, where developers inject dynamic content into predictable layouts. - Benefits include: - **Design system managers:** fewer variants and less maintenance - **Designers:** more freedom within the system - **Developers:** structures that map more predictably to production - **Automation and AI:** clearer, more interpretable component structures - Figma introduced slots at Schema 2025 and made them available in open beta. ## Start with High-Use Components The greatest immediate value comes from components that teams frequently detach or customize. - Prioritize components that: - Appear often across screens - Are duplicated throughout the system - Have accumulated many variants - Support frequently changing content - Common starting points include: - Dialogs and modals - Menus and lists - Cards and panels - Slots are especially useful when the structure stays stable but the content varies. - Repeating elements such as menu items or list rows no longer require numerous hidden layers for every possible item count. - Designers can add only the items they need while keeping the component connected. - For configuration-heavy components like cards and modals, slots can replace combinations of properties and variants for titles, descriptions, media, and buttons. ## Use Pre-filled and Empty Slots Deliberately Slots can either contain default content or remain empty, depending on the intended workflow. - **Pre-filled slots:** - Provide context and demonstrate expected usage. - Reduce unnecessary work when content is usually predictable. - Are useful for persistent elements, such as an icon in the top-right corner of a card. - **Empty slots:** - Clearly signal that the designer must add content. - Work well when customization is required. - Resemble existing instance-swap patterns used in many design systems. - Authors should choose between the two based on whether content is optional, predictable, or required. Figma’s practical recommendation is to introduce slots where teams already experience the most friction, then use defaults and empty placeholders intentionally to guide customization without sacrificing flexibility.

Read original(opens in new tab)
figma2 min readCurated summary

3 Ways Teams Are Building Conviction Faster With Figma Make | Figma Blog

Product teams are using Figma Make to turn abstract product ideas into interactive prototypes earlier in the process. By making concepts tangible, PMs can align designers and engineers, test assumptions, collect feedback, and build conviction before significant development begins. The article highlights examples from ServiceNow, Ticketmaster, and Affirm. ## Prototyping Instead of Relying Only on PRDs - Product managers traditionally translate customer needs, design goals, and engineering constraints into shared decisions. - Figma Make lets them create prototypes that demonstrate both a product’s appearance and behavior. - Interactive prototypes provide more useful early feedback than static mockups or abstract explanations. - Teams can identify problems, test ideas with users, and adjust direction before implementation progresses too far. - Earlier visibility helps teams make better-informed decisions and build products that more closely meet user needs. ## Bringing Complex Product Thinking Into Shared Focus - At ServiceNow, Product Director Ram Devanathan works with a design team serving multiple product groups, making dedicated design support difficult to obtain. - He needed to redesign a configuration page containing 15–20 settings, including technical options affecting incident prioritization and system load. - The initial mockup was functional but did not fully communicate the desired hierarchy, guidance, or tone. - Ram used Figma Make to transform the mockup into a clearer prototype: - Settings were grouped logically. - Simpler options appeared first. - Tooltips explained individual settings. - A warning clarified that changes required restarting the service. - The prototype gave Ram and the designer a shared, concrete representation of the intended experience. - Figma Make templates can also embed design systems and UX patterns, allowing PMs to iterate consistently without requiring designers for every early exploration. - Ram found that showing the idea directly was much more effective than describing it abstractly, helping the team reach agreement faster. ## Validating Features Before Building - The article next introduces Ticketmaster’s use of Figma Make for validating new features before development. - Ticketmaster applies prototypes to situations involving high-demand concert ticket purchases and internal dashboards for monitoring sales and troubleshooting issues. - The provided excerpt ends before explaining the specific feature-validation process or the third approach involving Affirm. Figma Make is presented less as a replacement for design or engineering and more as an early collaboration and validation tool. Product teams can use it to communicate complex behavior, explore alternatives, and secure alignment before committing substantial resources.

Read original(opens in new tab)
figma3 min readCurated summary

Workflow Lab: AI Image Tooling and Interactive Prototyping in Figma | Figma Blog

Figma’s Workflow Lab demonstrates how teams can combine AI image editing, vector tools, and interactive prototyping to test conversion-focused product experiences quickly. For Trivet, a recipe app, the goal is to increase referral-program signups without disrupting the user journey. The team explores three approaches—an immersive modal, an integrated feed card, and a full-screen overlay—each using different visual strategies to balance attention and usability. ## The Signup Problem - Trivet’s referral banner is generating fewer clicks and signups than expected. - The team must determine whether the banner is: - Too subtle to attract attention - Too disruptive to support a smooth experience - The sprint tests three levels of visibility: - A modal - An in-feed card - A full-screen overlay - The team evaluates not only layout, but also tone, visual tension, and how attention affects conversion. ## Direction One: Use Visual Treatment to Spark Curiosity - A modal creates a more immersive interruption than an in-feed card. - Photography is used to support messaging about “unlocking” exclusive recipes. - Recipes are partially blurred so they appear visible but inaccessible. - Figma’s glass effect, refraction, and progressive blur create a frosted, layered surface. - The visual treatment makes the reward feel tangible while justifying the interruption. ## Direction Two: Add Personality to the Interface - The referral message is integrated directly into the feed to feel more supportive and less disruptive. - A hand-drawn cake illustration replaces photography because it requires less visual space. - Figma’s Remove background and Vectorize tools turn the raster sketch into an editable vector asset. - The designer: - Adjusts colors using brand variables found through inline fill search - Uses the Cut tool to refine edges while preserving paths - Rotates anchor points with bounding boxes to polish details - The result is a reusable, scalable illustration that adds texture and approachability to the card. ## Direction Three: Create a Full-Screen Overlay - A full-screen experience maximizes visibility and clearly signals priority. - The larger format requires photography strong enough to carry the entire interaction. - Instead of replacing an imperfect image, the designer adapts it to the layout. - The workflow uses precise image-editing tools such as Erase object to remove distracting elements, including a spoon. - This approach prioritizes visual impact, though it introduces the greatest interruption to the user experience. ## From Design Exploration to Prototyping - The workflow connects Figma Design, AI image tools, FigJam, and Figma Make. - Designers can move from visual experimentation to interactive prototypes without waiting for production assets. - A broader team—including product, content, growth, and engineering—can compare the concepts and evaluate which level of attention best supports signups. The practical recommendation is to test visual intensity against user experience rather than assuming maximum visibility will perform best. Figma’s integrated image and prototyping tools make it faster to create and compare multiple directions before committing to implementation.

Read original(opens in new tab)
figma2 min readCurated summary

Building Frontend UIs with Codex and Figma | Figma Blog

Figma’s Codex integration creates a two-way workflow between coding and visual design. Using the Figma MCP server, developers can turn Figma designs into implementation context for Codex, then bring running interfaces back into editable Figma files. The result is a faster cycle for building, comparing, refining, and collaborating on frontend experiences. ## Starting an Application from a Design - Developers can select frames or nodes in Figma Design, Figma Make, or FigJam. - They copy a direct selection link by right-clicking a frame and choosing **Copy as → Copy link to selection**. - The link is provided to Codex with an implementation prompt, such as using existing design-system components. - Codex calls the MCP server’s `get_design_context` tool to retrieve: - Layout information - Styles and visual properties - Component details - Other design context needed for code generation - The MCP server supports additional tools and prompts for extracting information from Figma files. ## Bringing Code Back to the Canvas After iterating on the implementation, developers can import the live interface into Figma rather than recreating it manually. - The application must be rendered locally or on a publicly accessible web server. - Codex uses the `generate_figma_design` tool to convert the running UI into editable Figma frames. - Codex guides users through: 1. Creating or selecting a Figma file 2. Choosing a workspace 3. Setting up the application for capture 4. Opening the application in a browser session - The capture toolbar supports: - **Entire screen:** Captures the currently displayed screen - **Select element:** Captures a specific UI component - **Open file:** Opens the resulting Figma design for inspection ## Iterating Between Code and Design Once the interface is in Figma, teams can use the canvas to explore and refine the product. - Add design-system components. - Convert styles, fonts, and colors into variables. - Adjust layouts and add annotations. - Design interactions, empty states, and alternative flows. - Collaborate on multiple visual directions. - Send the refined design back to Codex through the same MCP workflow. The article presents this round trip as a continuous loop: design informs code, code produces a working interface, and the interface returns to Figma for further exploration. This lets teams begin from either a design or an implementation while preserving context and reducing the friction between developers and designers.

Read original(opens in new tab)
tossOriginal article

Creating Toss's new face (opens in new tab)

Toss redesigned its brand persona graphics to transition from simple, child-like icons to more professional and inclusive human figures that better represent the brand's identity. This update aims to project a more trustworthy and intelligent image while ensuring the visual language is prepared for a global, multi-cultural audience. By balancing iconic simplicity with diverse representation, the new design system maintains brand consistency across various screen sizes and service contexts. ### Refining Proportions for Professionalism * The team adjusted the vertical facial ratio to move away from a "child-like" impression, finding a balance that suggests maturity and intelligence without losing the icon's friendly nature. * The placement of the eyes, nose, and mouth was meticulously tuned to maintain an iconic look while increasing the perceived level of trust. * Structural improvements were made to the body, specifically refining the curves where the neck and shoulders meet to eliminate the unnatural "blocky" feel of previous versions. * A short turtleneck was selected as the default attire to provide a clean, professional, and sophisticated look that works across different UI environments. ### Achieving Gender-Neutral Hairstyles * The design team aimed for "neutrality" in hair design to prevent the characters from being categorized into specific gender roles. * Several iterations were tested, including high-density detailed styles (which were too complex) and simple line-separated styles (which lacked visual density when scaled up). * The final selection focuses on a clean silhouette that follows the head line while adding enough volume to ensure the graphic feels complete and high-quality at any size. ### Implementing Universal Skin Tones and Diversity * To support Toss's expansion into global markets, the team moved away from a single skin tone that could be interpreted as a specific race. * While a "neutral yellow" (similar to standard emojis) was considered, it was ultimately rejected because it felt inconsistent and jarring when displayed in larger formats within the app. * Instead of a single "neutral" color, the team defined a palette of five distinct skin tones based on universal emoji standards. * New guidelines were established to mix these different skin tones in scenes with multiple characters, fostering a sense of inclusivity and representation that reflects a diverse user base. The evolution of the Toss persona illustrates that as a service grows, its visual language must move beyond simple aesthetics to address broader values like trust and inclusivity. Moving forward, the design system will continue to expand to ensure that no user feels excluded by age, gender, or race.

figma2 min readCurated summary

The New Business Case For Design Systems | Figma Blog

Design systems are no longer merely efficiency tools or static component libraries; they are strategic investments that can influence revenue, customer loyalty, global expansion, and product quality. Research from the Design Executive Council shows that organizations are increasingly measuring design-system value through customer and business outcomes, not just reduced rework or faster handoffs. The strongest business case connects design-system work to metrics executives already care about. ## Linking Design Systems to Customer Outcomes - Teams can measure design-system impact through adoption, retention, engagement, satisfaction, and support metrics. - Freshworks attributed its design system to: - A 28% reduction in customer service costs - Faster support-ticket resolution - SAP collects more than one million in-app user feedback data points to improve its design system. - Freshworks uses CSAT scores, A/B tests, and funnel diagnostics to identify onboarding friction and guide new components, patterns, and features. - These metrics help design teams demonstrate business value while creating a roadmap for improving customer experience and product “stickiness.” ## Scaling Company Values and Product Quality - Design systems can scale not only brand identity but also company principles and product standards. - Linear uses its design system to support a culture of craft and quality, which contributes to customer loyalty and net revenue retention. - The system is intentionally flexible and continuously updated rather than governed by rigid rules. - Its goal is to ensure that products feel thoughtfully crafted while allowing teams to adapt components as needed. ## Supporting Global Growth and Localization - Design systems help companies expand internationally while maintaining consistency, brand identity, and cultural relevance. - Hyundai Motor Group uses one system across more than 30 vehicle models and three brands—Hyundai, Kia, and Genesis—while preserving each brand’s distinct identity. - Grammarly built localization into its design-system strategy from the beginning by: - Employing in-house linguists - Accounting for cultural nuances - Treating right-to-left readability as a core design input - Distributed teams across North America, South Korea, and Poland use a shared foundation to handle different languages, hardware constraints, screen sizes, and cultural expectations. - Hyundai’s 42dot uses custom Figma plugins to test multilingual user experiences. The practical recommendation is to frame a design system around outcomes that business leaders already value—customer satisfaction, retention, revenue, global growth, and product quality. Productivity improvements remain useful, but the most persuasive evidence comes from showing how design-system decisions change customer and business performance.

Read original(opens in new tab)
tossOriginal article

Rethinking Design Systems (opens in new tab)

Toss Design System (TDS) argues that as organizations scale, design systems often become a source of friction rather than efficiency, leading teams to bypass them through "forking" or "detaching" components. To prevent this, TDS treats the design system as a product that must adapt to user demand rather than a set of rigid constraints to be enforced. By shifting from a philosophy of control to one of flexible expansion, they ensure that the system remains a helpful tool rather than an obstacle. ### The Limits of Control and System Fragmentation * When a design system is too rigid, product teams often fork packages to make minor adjustments, which breaks the link to central updates and creates UI inconsistencies. * Treating "system bypasses" as user errors is ineffective; instead, they should be viewed as unmet needs in the system's "supply." * The goal of a modern design system should be to reduce the reason to bypass the system by providing natural extension points. ### Comparing Flat and Compound API Patterns * **Flat Pattern:** These components hide internal structures and use props to manage variations (e.g., `title`, `description`). While easy to use, they suffer from "prop bloat" as more edge cases are added, making long-term maintenance difficult. * **Compound Pattern:** This approach provides sub-components (e.g., `Card.Header`, `Card.Body`) for the user to assemble manually. This offers high flexibility for unexpected layouts but increases the learning curve and the amount of boilerplate code required. ### The Hybrid API Strategy * TDS employs a hybrid approach, offering both Flat APIs for common, simple use cases and Compound APIs for complex, customized needs. * Developers can choose a `FlatCard` for speed or a `Compound Card` when they need to inject custom elements like badges or unique button placements. * To avoid the burden of maintaining two separate codebases, TDS uses a "primitive" layer where the Flat API is simply a pre-assembled version of the Compound components. Design systems should function as guardrails that guide developers toward consistency, rather than fences that stop them from solving product-specific problems. By providing flexible architecture that supports exceptions, a system can maintain its relevance and ensure that teams stay within the ecosystem even as their requirements evolve.

figma3 min readCurated summary

Cooking with Constraints: A Designer’s Framework for Better AI Prompts | Figma Blog

Design and cooking both depend on preparation: clear inputs and intentional constraints lead to better outcomes. The article argues that AI models do not need politeness or emotional framing; they need precise instructions that reduce ambiguity. For product designers, structured prompting bridges the gap between probabilistic AI outputs and the repeatable, purposeful results design requires. ## Prompting as Mise en Place - “Mise en place,” or “everything in its place,” means preparing ingredients before cooking—and serves as a useful model for preparing AI prompts. - Effective prompts should establish: - **Clarity** - **Context** - **Constraints** - The author’s framework is **TC-EBC**: - **Task:** What should be built or accomplished? - **Context:** Who is it for and why? - **Elements:** Which features or components are required? - **Behavior:** How should the system respond to user actions? - **Constraints:** What technical, platform, accessibility, or product limits apply? - This approach aligns with broader prompt-engineering guidance emphasizing defined intent, modular construction, and predictable results. ## Why Vague Prompts Underperform - A request such as “build an app that uses pantry photos to suggest recipes” leaves too many decisions to the model. - Polite language and conversational phrasing can bury the actual task without adding useful information. - The resulting prototype may include basic functionality but remain visually generic, uninteresting, and barely beyond a wireframe. ## Applying TC-EBC to a Design Prompt For a pantry-based meal suggestion app, the structured prompt specifies: - **Task:** Build an AI-powered meal suggestion app using pantry and refrigerator photos. - **Context:** Create a home-cooking assistant for households with dietary restrictions. - **Elements:** Include camera input, pantry scanning, dietary settings, meal suggestions, and recipe cards. - **Behavior:** Let users upload photos, scan inventory, apply dietary preferences, and receive recipes. - **Constraints:** Make the experience mobile-first, support iOS and Android, provide accessible UI, and allow multiple household profiles. This structure makes the request easier to scan and gives the model explicit guidance about the app’s purpose, interface, behavior, and limitations. ## Design Requires Structured Uncertainty - LLMs are stochastic, meaning their outputs are probabilistic and variable. - Design, by contrast, depends on precision, consistency, and intentional decisions. - Structured prompts help “collapse uncertainty into structure,” much as a design system provides reusable rules and guidance. - The article presents the TC-EBC prompt as producing a substantially more purposeful prototype than the original one-shot request. A practical recommendation is to treat prompting like preparation for a complex recipe: define the task, provide relevant context, list required parts and behaviors, and state constraints before asking the AI to generate a design.

Read original(opens in new tab)