Design Systems Implementation

🍱 How To Organize Your Design System At Scale (https://lnkd.in/e9343uqv), a fantastic case study on how to set up a design system with 900 shared components and 25 designers — with product-specific domain components and shared ownership between the design system guild and product designers. Written by Jérôme Benoit ↓ Key takeaways: ✅ 1 design system, 8 design libraries, 1 library serves 1 goal. ✅ Each library has owners, editors (edit/publish), users (view-only). ✅ All designers have access to all resources from all files. ✅ Product team has domains, each domain has feature teams. ✅ Foundations + Core components are owned by design system team. ✅ Domain components are product-specific, owned by product designers. ✅ Each feature team has its own frame (not a page!) on a Domain page. ✅ Domain components are structured [Instance name] 💠 [Core name]. ✅ The work by product teams can move up to the Core level, too. In many products, different feature teams often have very different needs, and that’s why secondary design systems emerge. With this set-up, all teams are still working within 1 single design system, pulling and pushing components between levels and having search across all design work in all domains at once — without an organizational overhead! 👏🏼👏🏽👏🏾 Useful resources: How To Organize 1250+ Design Screens in Figma (+ File examples), by Lorenzo Palacios Venin https://lnkd.in/e7X4fKcj Booking.com: Multi-Platform Design System (+ Figma), by Nicole Saidy https://lnkd.in/edueYQPG Frog: Building A Global Design System, by Anthony Nguyen https://lnkd.in/etkiTxfB Doctolib Figma Files Organization Tips, by Jérôme Benoit https://lnkd.in/eK7bhQeS Multi-Brand Design System, by Pavel Kiselev https://lnkd.in/eShgnPnW Design System Structure for Teams, Projects and Files, by Luis Ouriach https://lnkd.in/eFZUjUCU How to Organize Your Figma Files For Design System, by Jules Mahé https://lnkd.in/eeHG2VzU Organizing Design System For Scalability, by Allie Paschal https://lnkd.in/eeAtakGs Design That Scales (Book), by Dan Mall https://lnkd.in/eeFrqFfP And kudos to the wonderful design team at Doctolib and all the wonderful designers above for sharing their insights for everyone to learn from!👏🏼👏🏽👏🏾 #ux #design #designsystems

Duolingo didn’t always have Product Review, but it’s one of the best processes we’ve implemented. Here’s why: When we were a small company (maybe 25 employees) the process for getting something in the product was pretty informal: walk up to Luis von Ahn or Tyler Murphy (our head designer), sit with them at their desks, show them the design, get approved. This was okay, until we noticed something: the designers who sat closest to Tyler, and the PMs who sat closest to Luis, were developing much faster than their peers. They got more feedback more often, and so could learn and iterate much faster than others. We also noticed that our engineers, who rarely interfaced with Tyler and Luis, were developing much more quickly across the board. Why was this? Engineers always reviewed each other’s code before going into production. They were constantly learning from each other thanks to a defined and consistent process. Product Review was a game-changer for talent development and product quality, because it created a process for documenting and reviewing changes. People weren’t just showing a spec at a desk—they were using a template to explain the change and the impact. And we had a system for evaluating those changes—the stakeholders were aligned and discussion happened in one meeting rather than at a desk/via Slack/in the hallway/in a fishtank… etc. Because we shared notes after PRs, PMs and designers started to improve much faster, because they got consistent feedback and could learn from each other’s reviews. Start-ups are often scared of process—they think it adds bureaucracy and slows things down. But in some cases, a good process is essential to growing the people and the product. We wouldn’t be where we are today without it. The team has iterated a lot on Product Review since our early days (I rarely join a PR anymore) but here’s the initial template I shared for PMs/designers to fill out back in 2015:

I have spent hundreds of hours analyzing design systems. One of the things that confused me for many years is how to structure color scales and tokens. I have experimented with multiple structures at different sizes of design systems, and at a high-level recommend the following approach: 1. Primitive Colors Your design system foundations should always start with a full color scale that is based on your brand identity. We call these colors Primitives, and your variable/token collection should look like this: - purple-600 - purple-500 - purple-400 - And so on.. To create a Primitives palette you will want to start from your main brand colors and use a tool like UIColors, Supapalette, Colorbox to expand to the full scale. (links in comments) This is a great foundation to have, as it gives you a set of shades that can be used in different ways, and ensures all of them have consistent hues, saturation and brightness. However, Primitive colors are simply not effective when used directly in your designs: - They create ambiguity - Their names have no contextual meaning - They are often misused due to similarity If you have had the “why are there 20 different shades of gray?” conversation with an engineer, you know what I mean. So let’s see how we can improve that. 2. Semantic Colors This is my default recommendation to all product design teams that don’t have a highly complex design system. What you will want to do here is create a new variable collection named Semantic, which is what’s visible in your design files, and comprises of: - Brand / Action - Text - Link - Border - Icon - Surface / Background - Bias - Data / Charts Each color should point to a primitive value, e.g. - text-primary → gray-800 - text-secondary → gray-600 - text-tertiary → gray-400 This takes a bit of setting up, but creates immense long-term value. A great example of a simple, theme-level Semantic structure is Shopify’s Polaris (link in comments) 3. Component-level Semantic Lastly, if you are working on a design system with a lot of complexity and, ideally, a dedicated design systems team, you might want to add another level of hierarchy and specify colors at a component-level. In this structure, you would want to create color tokens based on how they are used in each component. - input-text-filled → text-primary - input-text-placeholder → text-secondary - input-text-disabled → text-tertiary This eliminates all guesswork, but also increases the complexity exponentially. It does serve a purpose though. As design systems scale, you may find that: - A theme-level semantic structure is too restrictive - There is still some guesswork - Decisions need to be documented. An example of this is Uber’s Base and Adobe’s Spectrum design system, linked in the comments. I’m curious to know, what structure are you using for your design system and what has worked well for you? — If you found this useful, consider reposting ♻️ #uidesign #designsystems #productdesign

Essential Git: The 80/20 Guide to Version Control Version control can seem overwhelming with hundreds of commands, but a focused set of Git operations can handle the majority of your daily development needs. Best Practices 1. 𝗖𝗼𝗺𝗺𝗶𝘁 𝗠𝗲𝘀𝘀𝗮𝗴𝗲𝘀    - Write clear, descriptive commit messages    - Use present tense ("Add feature" not "Added feature")    - Include context when needed 2. 𝗕𝗿𝗮𝗻𝗰𝗵 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝘆    - Keep main/master branch stable    - Create feature branches for new work    - Delete merged branches to reduce clutter 3. 𝗦𝘆𝗻𝗰𝗶𝗻𝗴 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄    - Pull before starting new work    - Push regularly to backup changes    - Resolve conflicts promptly 4. 𝗦𝗮𝗳𝗲𝘁𝘆 𝗠𝗲𝗮𝘀𝘂𝗿𝗲𝘀    - Use 𝚐𝚒𝚝 𝚜𝚝𝚊𝚝𝚞𝚜 before important operations    - Create backup branches before risky changes    - Verify remote URLs before pushing Common Pitfalls to Avoid 1. Committing sensitive information 2. Force pushing to shared branches 3. Merging without reviewing changes 4. Forgetting to create new branches 5. Ignoring merge conflicts Setup and Configuration Essential one-time configurations: # Identity setup git config --global user. name "Your Name" git config --global user. email "your. email @ example. com" # Helpful aliases git config --global alias. co checkout git config --global alias. br branch git config --global alias. st status ``` By mastering these fundamental Git operations and following consistent practices, you'll handle most development scenarios effectively. Save this reference for your team to maintain consistent workflows and avoid common version control issues. Remember: Git is a powerful tool, but you don't need to know everything. Focus on these core commands first, and expand your knowledge as specific needs arise.

There is absolutely no point in gathering feedback from employees without creating feedback loops and USING feedback to inform improvement. WHAT IS AN EMPLOYEE FEEDBACK LOOP❓ An employee #feedbackloop is just one of many feedback loops in organizations. It is a structured process where people provide input or comments about their work experiences, job satisfaction, or performance, and this #feedback is used by the organization to make improvements, enhance employee engagement, and create a better working environment. That last part is where many organizations fall down... they don't USE feedback to inform improvements. This is a huge missed opportunity!! Employee feedback is a powerful way for organizations to identify improvement areas. Also, when people see that they are taken seriously, they feel heard and valued, and this feeling can significantly enhance engagement and job satisfaction. There is a real danger in asking for people's feedback and then ignoring it...or failing to acknowledge it. People lose engagement and trust... slowly they stop giving feedback.... and the organization struggles to improve. 💥 CREATING FEEDBACK LOOPS 💥 If you are thinking of creating/improving your employee feedback loops, here are some high-level steps to guide you: 1️⃣ Identify the type of feedback required 2️⃣ Select Feedback Methods 3️⃣ Regularly Collect the Feedback 4️⃣ Analyze and Share Results 5️⃣ Take Action 6️⃣ Follow Up 7️⃣ Track Progress: 8️⃣ Celebrate Successes 9️⃣ Iterate and Improve: Every single one of these 9 steps are important. And not very difficult. All it takes is good leadership and organization. Remember that feedback should not be a once-off effort. It is important to aim towards creating a feedback culture, where regularly giving and receiving feedback is encouraged and valued. Consistency is key! _______________________________________ I'm Catherine McDonald- Lean Business and Leadership Coach. Follow me for insights on Lean, Leadership, Coaching, Strategy and Organizational Behaviour

𝗪𝗵𝘆 𝗘𝗻𝘁𝗲𝗿𝗽𝗿𝗶𝘀𝗲 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗶𝘀 𝘁𝗵𝗲 𝗞𝗲𝘆 𝘁𝗼 𝗔𝗹𝗶𝗴𝗻𝗶𝗻𝗴 𝗦𝘁𝗿𝗮𝘁𝗲𝗴𝘆 𝘄𝗶𝘁𝗵 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 Enterprise Architecture is the bridge that 𝗰𝗼𝗻𝗻𝗲𝗰𝘁𝘀 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝗶𝗰 𝘃𝗶𝘀𝗶𝗼𝗻 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗼𝗽𝗲𝗿𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 needed to make it a reality. Without EA, you risk misaligned initiatives, wasted resources, and failed transformations. 𝗛𝗼𝘄 𝗰𝗮𝗻 𝘆𝗼𝘂 𝗹𝗲𝘃𝗲𝗿𝗮𝗴𝗲 𝗘𝗔 𝘁𝗼 𝗮𝗹𝗶𝗴𝗻 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆 𝘄𝗶𝘁𝗵 𝗲𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻? Here are 𝟯 𝗔𝗰𝘁𝗶𝗼𝗻𝗮𝗯𝗹𝗲 𝗦𝘁𝗲𝗽𝘀 to make EA a driving force in your org: 𝟭 | 𝗖𝗹𝗲𝗮𝗿 𝗧𝗮𝗿𝗴𝗲𝘁 𝗦𝘁𝗮𝘁𝗲 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 A target state architecture is the blueprint to achieve strategic goals. 𝙒𝙝𝙮 𝙞𝙩 𝙬𝙤𝙧𝙠𝙨: Codifying and refining direction, EA creates a 𝘀𝗵𝗮𝗿𝗲𝗱 𝘃𝗶𝘀𝗶𝗼𝗻 𝘁𝗵𝗮𝘁 𝗮𝗹𝗶𝗴𝗻𝘀 𝘁𝗲𝗮𝗺𝘀 𝗮𝗻𝗱 𝗶𝗻𝗶𝘁𝗶𝗮𝘁𝗶𝘃𝗲𝘀. 𝙃𝙤𝙬 𝙩𝙤 𝙖𝙥𝙥𝙡𝙮 𝙞𝙩: Work with stakeholders to map current state, identify gaps, and design a target state addressing short-term needs and long-term objectives. This architecture is accessible to everyone involved. 𝟮 | 𝗚𝗼𝘃𝗲𝗿𝗻𝗮𝗻𝗰𝗲 𝗙𝗿𝗮𝗺𝗲𝘄𝗼𝗿𝗸 𝗳𝗼𝗿 𝗔𝗹𝗶𝗴𝗻𝗺𝗲𝗻𝘁 Governance makes decisions at all levels support broader strategy. 𝙒𝙝𝙮 𝙞𝙩 𝙬𝙤𝙧𝙠𝙨: Clear governance structure 𝗮𝘃𝗼𝗶𝗱𝘀 𝘀𝗶𝗹𝗼𝗲𝗱 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻-𝗺𝗮𝗸𝗶𝗻𝗴 and maintains consistency across initiatives. 𝙃𝙤𝙬 𝙩𝙤 𝙖𝙥𝙥𝙡𝙮 𝙞𝙩: Architecture reviews evaluate projects for alignment with target state. Prioritize, resolve conflicts, and keep business and IT aligned. 𝟯 | 𝗙𝗼𝗰𝘂𝘀 𝗼𝗻 𝗠𝗲𝗮𝘀𝘂𝗿𝗮𝗯𝗹𝗲 𝗢𝘂𝘁𝗰𝗼𝗺𝗲𝘀 EA delivers 𝘁𝗮𝗻𝗴𝗶𝗯𝗹𝗲 𝘃𝗮𝗹𝘂𝗲 𝗰𝗼𝗻𝗻𝗲𝗰𝘁𝗶𝗻𝗴 𝗴𝗼𝗮𝗹𝘀 𝘁𝗼 𝗿𝗲𝘀𝘂𝗹𝘁𝘀. 𝙒𝙝𝙮 𝙞𝙩 𝙬𝙤𝙧𝙠𝙨: Measuring outcomes sees that 𝗘𝗔 𝗱𝗿𝗶𝘃𝗲𝘀 𝗯𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝗶𝗺𝗽𝗮𝗰𝘁 𝗮𝗻𝗱 𝗱𝗲𝗹𝗶𝘃𝗲𝗿𝘀 𝘃𝗮𝗹𝘂𝗲. 𝙃𝙤𝙬 𝙩𝙤 𝙖𝙥𝙥𝙡𝙮 𝙞𝙩: 𝗟𝗶𝗻𝗸 𝗮𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗶𝗻𝗶𝘁𝗶𝗮𝘁𝗶𝘃𝗲𝘀 𝘁𝗼 𝗢𝗞𝗥𝘀 𝘄𝗶𝘁𝗵 𝗾𝘂𝗮𝗻𝘁𝗶𝗳𝗶𝗮𝗯𝗹𝗲 𝗞𝗣𝗜𝘀 like cost reduction, improved time-to-market, or increased customer satisfaction. Track progress and adjust plans to maximize results. 𝗪𝗿𝗮𝗽-𝗨𝗽: Enterprise Architecture is the connective tissue that 𝗲𝗻𝘀𝘂𝗿𝗲𝘀 𝘀𝘁𝗿𝗮𝘁𝗲𝗴𝘆 𝘁𝗿𝗮𝗻𝘀𝗹𝗮𝘁𝗲𝘀 𝗶𝗻𝘁𝗼 𝗮𝗰𝘁𝗶𝗼𝗻𝗮𝗯𝗹𝗲 𝗼𝘂𝘁𝗰𝗼𝗺𝗲𝘀. By defining a target state, implementing governance, and focusing on measurable results, EA helps organizations stay aligned, agile, and effective. How is your organization using EA to align strategy with execution? Share your experiences below! _ 👍 Like if you enjoyed this. ♻️ Repost for your network.  ➕ Follow @Kevin Donovan 🔔 _ 🚀 Join Architects' Hub!  Sign up for our newsletter. Connect with a community that gets it. Improve skills, meet peers, and elevate your career! Subscribe 👉 https://lnkd.in/dgmQqfu2 #EnterpriseArchitecture #DigitalTransformation #StrategyToExecution #BusinessAlignment #Governance #Innovation

In Figma, we use variables. But are they the same as tokens? And what is that JSON file developers keep talking about? Let’s understand this for a better workflow: 1. Variables in Figma Variables let you define values like colours, spacing etc. --> Example (Figma): color/danger = #FF0000 This keeps designs consistent inside Figma. 2. So what is a token? A design token is a simple name + value pair that describes a design decision in a format code can use. --> Example (JSON): "moon-color-text-danger": "#FF0000" 3. Isn’t that the same? Not quite. Tokens are intentionally simpler. Each token represents one decision: one value only. • A colour token maps a single hex value • A spacing token maps a single pixel value • A radius token maps a single corner value This simplicity is what makes tokens portable across platforms. They don’t carry Figma-specific logic like modes or variable aliasing. 4. The JSON file This is the container for tokens. Think of it as the dictionary of all design decisions in your system. Inside it, every decision is expressed in a consistent, structured format. Why it matters: • JSON is machine-readable • JSON is tool-agnostic • SON becomes the single source of truth for both designers and developers 5. What works well today in Figma • Variables can be grouped, aliased, and scaled across files • They can be applied to styles and components • With plugins such as Token Studio, variables can be exported into JSON 6. Where it falls short • Figma does not yet export a “true” token file natively • JSON export requires plugins or manual workflows • Bi-directional sync (design ↔ code) is still early • Naming conventions are not enforced, which risks drift between design and dev 7. How it connects Here’s the flow today: • Designers create variables in Figma (design intent) • These variables are exported (manually or via plugin) into JSON (structured tokens) • Developers translate that JSON into platform code (iOS, CSS, Android, etc.) When the JSON updates, every platform can stay in sync 👉 The takeaway Figma variables are a flexible design tool. Tokens are the code-friendly format. JSON is where those tokens live as the single source of truth. The pieces are coming together, but we are not yet at a perfect one-click sync between design and code. How is your team handling this today? Are you exporting variables into tokens, or still managing JSON separately with developers? Any handy tools I might have missed?

𝗣𝗗𝗖𝗔 𝗶𝘀 𝗮 𝗽𝗿𝗮𝗰𝘁𝗶𝗰𝗮𝗹 𝗮𝗽𝗽𝗿𝗼𝗮𝗰𝗵 𝘁𝗼 𝗖𝗼𝗻𝘁𝗶𝗻𝘂𝗼𝘂𝘀 𝗜𝗺𝗽𝗿𝗼𝘃𝗲𝗺𝗲𝗻𝘁 𝗶𝗻 𝗣𝗿𝗼𝗰𝘂𝗿𝗲𝗺𝗲𝗻𝘁 "𝘐𝘵’𝘴 𝘢𝘭𝘭 𝘢𝘣𝘰𝘶𝘵 𝘵𝘩𝘦 𝘤𝘶𝘭𝘵𝘶𝘳𝘦 𝘢𝘯𝘥 𝘗𝘋𝘊𝘈,"our new boss highlighted as we worked to introduce process and quality standards in a new global sourcing organisation. With his background in engineering and quality management, he pointed out a crucial factor that often is under-appreciated in Procurement: 𝗖𝗼𝗻𝘁𝗶𝗻𝘂𝗼𝘂𝘀 𝗶𝗺𝗽𝗿𝗼𝘃𝗲𝗺𝗲𝗻𝘁 𝗶𝘀𝗻’𝘁 𝗷𝘂𝘀𝘁 𝗳𝗼𝗿 𝗺𝗮𝗻𝘂𝗳𝗮𝗰𝘁𝘂𝗿𝗶𝗻𝗴, it’s just as vital for optimising Procurement processes, strengthening supplier relationships, and realising cost efficiencies and foremost is a cultural shift. The famous Kaizen, builds the 𝗪𝗛𝗬 behind continuous improvement, emphasising the mindset of "𝗰𝗵𝗮𝗻𝗴𝗲 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗯𝗲𝘁𝘁𝗲𝗿." But practical methodologies like PDCA turn this spirit into the 𝗛𝗢𝗪, a structured approach for meaningful, incremental change. Here's how PDCA gets applied in a real-time example: 𝗣𝗟𝗔𝗡: A bottleneck in the approval process is causing delays in submitting purchase orders. The goal is to reduce the approval time from 5 days to 2 days. Based on data & category patterns analysed a solution is identified. 𝗗𝗢: A small pilot is run with reduced approval steps for low-risk, low-value orders for certain categories. 𝗖𝗛𝗘𝗖𝗞: After six weeks, they measure the results. The approval time has improved considerably but still is slightly above the target at 2.5 days. 𝗔𝗖𝗧: Since the pilot was successful, the approach is scaled across categories with the team continuing to fine tune the process with PDCA to hit the target. But PDCA is not only about processes, it is about improving also: ▪️𝗦𝘂𝗽𝗽𝗹𝗶𝗲𝗿 𝗽𝗲𝗿𝗳𝗼𝗿𝗺𝗮𝗻𝗰𝗲 through regular target setting and KPI reviews ▪️𝗖𝗼𝘀𝘁 𝗺𝗮𝗻𝗮𝗴𝗲𝗺𝗲𝗻𝘁 planning and proving realisation of saving strategies ▪️𝗧𝗲𝗰𝗵𝗻𝗼𝗹𝗼𝗴𝘆 𝗰𝗵𝗮𝗻𝗴𝗲𝘀 and the review of pilots to scale upon success ▪️𝗧𝗲𝗮𝗺 𝗰𝗼𝗹𝗹𝗮𝗯𝗼𝗿𝗮𝘁𝗶𝗼𝗻 and shared responsibility by involving everyone needed 𝗣𝗗𝗖𝗔 isn't a complex framework or the only tool in the toolbox of continuous improvement and problem-solving. But it’s a simple, effective way to turn continuous improvement into a daily practice for everyone in the team. Looking back at numerous improvement projects, it enhanced our approach to streamline procurement practices in a systematic way and helped to embed a culture of continuous improvement. ❓Do you use PDCA. ❓Where is it applied in your organisation. 👇Let’s discuss in the comments. #continuousimprovement #kaizen #pdca #procurementexcellence #qualitymanagement

Most AI ideas die before they even get off the ground. Why? Because teams get stuck in endless debates instead of building something tangible. The best way to get leadership buy-in, align teams, and validate your AI concept? Prototyping. But here’s the secret—you don’t need to code to prototype AI effectively. Instead of diving into AI coding tools like Cursor or Replit, you can use no-code AI prototyping tools like Notion AI, UX Pilot, CustomGPTs, and Voiceflow to move even faster. In our latest AI Community Learning Series, Polly M Allen (Ex-Principal PM, Alexa AI) and Rupa Chaturvedi (AI UX Leader, ex-Amazon, Google, Uber) shared how to: ✅ Align teams faster with interactive AI prototypes (instead of lengthy PRDs) ✅ Use no-code tools to build AI-powered experiences—without writing a single line of code ✅ Pick the right AI use cases and avoid overcomplicating solutions Plus, they demoed how to build a Shopping AI Assistant live—showing exactly how to structure, test, and refine AI interactions in minutes. Curious how they did it? Full recap + session replay 👇 Have you built an AI prototype before? What worked (or didn’t)? Share your thoughts below! #ProductManagement #AI #Design #Prototyping

Design reviews aren’t about proving your design is “right.” They’re about sparking the right conversations, surfacing blind spots, and aligning your work with both the business and the user. But here’s the thing: The quality of the questions you ask directly shapes the quality of the feedback you’ll receive. When you ask questions that seek approval, you invite surface-level reactions: “I don’t like that color.” “Can you move this button?” “It doesn’t feel right.” When you ask questions that seek perspective, you unlock insights that go much deeper: “Does this flow align with the goals we set?” “Which part of this journey feels riskiest for launch?” “What business constraints should we keep in mind?” That’s the shift: ❌ Approval → opinions ✅ Perspective → alignment, priorities, and actionable feedback Strong designers don’t just show screens. They guide the conversation by asking thoughtful, open questions that: Clarify the “why” behind feedback Dig into what truly matters for success Encourage stakeholders to connect feedback back to goals That’s how design reviews stop feeling like a defensive battle and start becoming a collaboration that moves everyone forward. Because when you stop asking “Do you like it?” and start asking “How does this support our goals?”you elevate both the conversation and the design.