<?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 Iasonas Georgiadis on Medium]]></title>
        <description><![CDATA[Stories by Iasonas Georgiadis on Medium]]></description>
        <link>https://medium.com/@iasonas.georgiadis?source=rss-bc4df0160f4f------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*zZfEnjR4yl0IC0M428ML9A.jpeg</url>
            <title>Stories by Iasonas Georgiadis on Medium</title>
            <link>https://medium.com/@iasonas.georgiadis?source=rss-bc4df0160f4f------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 11:41:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@iasonas.georgiadis/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Building AI-driven workflows powered by Claude Code and other tools]]></title>
            <link>https://uxdesign.cc/designing-with-claude-code-and-codex-cli-building-ai-driven-workflows-powered-by-code-connect-ui-f10c136ec11f?source=rss-bc4df0160f4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/f10c136ec11f</guid>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[prototyping]]></category>
            <dc:creator><![CDATA[Iasonas Georgiadis]]></dc:creator>
            <pubDate>Wed, 29 Oct 2025 16:08:38 GMT</pubDate>
            <atom:updated>2025-10-30T08:46:02.923Z</atom:updated>
            <content:encoded><![CDATA[<h4>How agentic CLI tools extend Figma MCP and turn wireframes into production-ready prototypes</h4><figure><img alt="Opening illustration (three browser windows): An abstract illustration showing three browser‑like windows: the left window depicts a grey wireframe mock‑up; the dark center window contains logos for AI/design tools (a knot‑shaped Claude symbol, a starburst, and the colorful Figma logo); the right window shows a colourful finished interface. Arrows between the windows illustrate the transformation from a rough mock‑up to a polished UI" src="https://cdn-images-1.medium.com/max/1024/1*cI8-cRj06yGzsx3uBcGQaA.png" /></figure><p>I set out to explore how designers can use agentic CLI tools like <strong>Claude Code</strong> and <strong>Codex CLI</strong><em> </em>to build AI-driven workflows that turn rough wireframes into production-ready prototypes reflecting a real codebase, not generic mockups. After testing both tools, the results revealed that a product designer can truly prototype with real code and the help of <strong>Figma MCP</strong>.</p><p>With a solid design system in place, design and code share the same language, AI becomes a reliable partner, accelerating exploration and producing maintainable, real-world prototypes that teams can carry forward.</p><h3>The problem</h3><p>If you are a designer already experimenting with AI tools, you know this feeling: gorgeous prototypes that, after looking at the code, are totally disconnected from the codebase your team is using and practically useless.</p><p>I’ve explored multiple AI tools myself to speed up my design workflow, but something was always missing. I tried <a href="https://medium.com/design-bootcamp/designing-with-prompts-a-product-designers-journey-into-exploring-ai-tools-116aefa70966"><strong>Replit, Lovable, v0</strong>, and <strong>Bolt</strong></a> only to end up with prototypes built with generic code, based on <strong>Shadcn</strong> or <strong>Tailwind CSS</strong>. They didn’t align with the existing code, and couldn’t be reused in production.</p><p>This changed significantly with <strong>MCP servers</strong>, and in my <a href="https://medium.com/design-bootcamp/designing-with-mcp-server-bridging-design-systems-and-ai-for-developer-friendly-prototypes-4f08b0a0881d">previous article</a>, I was optimistic enough to imagine a workflow where designers could instantly prompt rough ideas to prototypes, while also pulling from existing code and design tokens. This time, I brought this vision to life using <strong>Code Connect UI </strong>and its improved features like component mapping and MCP instructions.</p><p>In this article, I will share how I built an AI-ready workflow using agentic CLI tools like <strong>Claude Code</strong> and <strong>Codex CLI</strong>, combined with <strong>Figma</strong> <strong>MCP</strong> and <strong>Code</strong> <strong>Connect UI</strong>, to turn high-level prompts into production-ready code that directly reflects my design system and codebase.</p><h3>From Cursor to agentic CLI tools</h3><p>Cursor was my first real look into what AI-assisted coding could look like. But soon after, agentic CLI tools like Claude Code came to play offering more control and capabilities, making AI integration into traditional workflows more efficient than any other IDE plugin ever did before.</p><p>I began exploring Claude Code and Codex CLI, two command-line tools from <strong>Anthropic</strong> and <strong>OpenAI</strong>. Both can run locally inside a terminal or IDE, with immediate access to their respective models, and integrate with MCP<strong> </strong>Servers for external tool access.</p><figure><img alt="Codex CLI terminal screenshot: A screenshot of a terminal running Codex CLI. It shows commands that call the Figma MCP server to verify whether a button component uses the correct design tokens and variables. The output lines display progress status and code‑verification messages" src="https://cdn-images-1.medium.com/max/1024/1*x1EyBYSiLGFuguher6lf6A.png" /><figcaption><em>The Codex CLI running in terminal and using Figma MCP tools.</em></figcaption></figure><p>The key difference between using an AI-powered IDE and an agentic CLI lies in how they communicate with the models. While IDEs act as middlemen, translating user requests through APIs or extensions, agentic CLIs connect directly to the models themselves, making interactions faster, more contextual, and more reliable.</p><p>This direct connection enables a truly agentic experience: Claude Code and Codex CLI don’t just respond to prompts; they reason, plan, and adapt within a project.</p><figure><img alt="A comparison diagram showing how AI-powered IDEs like Cursor and VS Code communicate with Claude through intermediary tools versus how Claude Code connects directly to the model. On the left, multiple arrows connect the user, Cursor, VS Code, and Claude 4.5 through “cursor-tools” and “vscode-tools.” On the right, a simplified diagram shows a direct two-way link between the user and “Claude Code with Claude 4.5,” highlighting the streamlined communication path." src="https://cdn-images-1.medium.com/max/1024/1*3JE8VxAZVpTmBKC0nkUzJA.png" /><figcaption><em>One of the key differences between using an AI-powered IDE and Claude Code lies in how they communicate with the same models.</em></figcaption></figure><p>Both Anthropic and OpenAI are actively supporting these tools with regular updates. One of them was a more user-friendly way of interacting with Claude Code on VS Code without the terminal.</p><figure><img alt="VS Code with official extensions: A view of Visual Studio Code with two panes. The left pane is the VS Code welcome page with recent projects and actions; the right pane displays the Claude Code extension interface, which looks like a chat window ready to accept commands" src="https://cdn-images-1.medium.com/max/1024/1*nGfcHlCM29sCrZ8_X9m1qg.png" /><figcaption><em>Both tools come with a more user-friendly version within VS Code through their official extensions.</em></figcaption></figure><h3>Building an AI-ready design system</h3><p>To ensure my workflow will work as expected, my first priority was to build a design system that aligns perfectly with my codebase, so AI agents could truly understand. One where every color, type, scale, and component carries the same meaning in both Figma and code. Then, use that shared structure to build production-ready prototypes from simple prompts or wireframes.</p><p>To achieve this, I aligned Figma variables with CSS tokens, ensuring MCP Server, Claude Code, and Codex<strong> </strong>CLI all spoke the same design language, starting from the foundations.</p><p>The result was:</p><ul><li>A design system perfectly aligned with code</li><li>React components mapped to their corresponding design versions using Figma MCP and Code Connect</li><li>Storybook documentation for all the components</li><li>A GitHub repository for traceability</li><li>An automated workflow process for orchestrating the agentic CLI tools running in my project</li></ul><p>Building around these foundations was crucial. At the end of the day, when design and code share the same language, designers and developers don’t have to make assumptions, and similarly, AI tools don’t have to guess.</p><h3>Preparing and organizing the Figma file</h3><p>What makes perfect sense for every product designer is <em>structure</em>. In any design system, structure defines clarity, and documentation defines purpose. Together, they form the bridge that helps both humans and AI make accurate decisions about how design maps to code.</p><p>The design foundations must be well-defined and closely aligned with code. In my case, the Figma variables were not only given a name, but they were directly mapped to their code syntax, which in this case were CSS variables. This mapping is essential not only for smoother collaboration between designers and developers but also for making AI workflows possible by reducing ambiguity.</p><figure><img alt="Figma variables mapped to CSS tokens: A screenshot from Figma’s variables panel listing color variables (e.g., black, white, grey‑200) alongside numeric scales and mapped values. A pop‑over shows the CSS token name and hex value for the selected variable, illustrating how design variables map directly to CSS tokens" src="https://cdn-images-1.medium.com/max/1024/1*ID0N95Pr7FpOO-6lYnibIw.png" /><figcaption><em>All Figma variables are mapped directly to CSS tokens, keeping design and code perfectly aligned.</em></figcaption></figure><p>The next step was to create both primitive and semantic CSS files, ensuring that what’s defined in Figma is also defined in the code, resulting in <strong>what you see is what you get</strong> on both ends.</p><figure><img alt="CSS variables file: A code snippet showing a CSS file where color palette variables such as — igds‑color‑grey‑50, — igds‑color‑grey‑100 and so on are defined with their hex colour values. This demonstrates that the CSS variables mirror the Figma design tokens" src="https://cdn-images-1.medium.com/max/1024/1*X9LY8Tgu0jMf2qFPhicp2Q.png" /><figcaption><em>The CSS variables reflect their corresponding Figma variables.</em></figcaption></figure><p>Once primitive and semantic tokens were in place, every design component exposed its variables in Figma through <strong>Dev Mode</strong>, making it easy for AI and developers to understand which ones to use when generating or writting code.</p><figure><img alt="Figma Dev Mode overlay: Screenshot of Figma’s Dev Mode for a Button component. The button on the canvas is overlaid with blue labels indicating spacing variables (e.g., var( — igds‑space‑12)). On the right, a code panel shows the CSS layout and style definitions using those design tokens" src="https://cdn-images-1.medium.com/max/1024/1*30RNbgqCoiUJ7n95tLNf6g.png" /><figcaption><em>By defining the code syntax for each component, Dev Mode now displays the correct format instead of inconsistent naming.</em></figcaption></figure><p>More design tokens were created to maintain consistency and define typography across the design system. Providing all this level of context also helps AI agents understand design intent more accurately and make fewer assumptions when it comes to decision-making.</p><figure><img alt="Typography tokens: An image from Figma showing a table of typography scale variables. Rows such as “5xl”, “4xl”, “3xl”, etc. list corresponding numeric values (e.g., 72, 48, 40), demonstrating consistent type scale definitions" src="https://cdn-images-1.medium.com/max/1024/1*DNYw3UhQlP2xzdjQ2AtZKA.png" /><figcaption><em>Typography tokens ensure consistent hierarchy and type scales.</em></figcaption></figure><h3>Code Connect UI and component mapping</h3><p>I was fortunate to <strong>participate in Figma’s early alpha testing</strong> for the new <strong>Code Connect UI</strong>, giving me the opportunity to try its new features and capabilities early, provide direct feedback, and see them evolve. From day one, I was impressed with how Code Connect integrated more seamlessly with <strong>Figma MCP</strong>, while also connecting to <strong>GitHub</strong> repositories, creating a stronger and more reliable connection between design and code.</p><figure><img alt="Figma Code Connect UI with GitHub: A screen showing Figma Code Connect UI for a checkbox component. There’s a search bar for design components and, on the right, a GitHub panel indicating the repository and directories (e.g., igds-design‑system, src/components). It illustrates how Figma connects to GitHub to pull source code" src="https://cdn-images-1.medium.com/max/1024/1*Qt3F0AZpNysWitUDc0ZM3Q.png" /><figcaption><em>Figma now integrates with GitHub to pull source code directly.</em></figcaption></figure><p>With the latest update, component mapping now allows specific <strong>MCP instructions</strong> for each design component. This way, AI agents can better understand how a component should behave, with custom instructions, and even apply specific code overrides without touching the source code — all within Figma.</p><figure><img alt="MCP instructions comparison (before/after): Two side‑by‑side panels comparing a component before and after applying an MCP code override. Each panel contains a small design preview and associated code, and there is a modal window showing where custom instructions are added" src="https://cdn-images-1.medium.com/max/1024/1*o0fPc43kWjOge54IebiD9g.png" /><figcaption><em>The MCP Instructions modal, with a comparison of a component before and after the code override.</em></figcaption></figure><p>This becomes especially valuable for rapidly prototyping new ideas without editing the source code or asking a fellow developer to help. Additionally, you can now adjust component properties and watch the code respond to these changes.</p><figure><img alt="Component playground &amp; live code update: Image of Code Connect’s playground where component properties such as “disabled”, “size” and “label” are adjustable via controls. The right‑hand panel displays the generated code snippet that updates in real time as these properties change" src="https://cdn-images-1.medium.com/max/1024/1*ikGkxFBmHWQ7KFKFfUyXng.png" /><figcaption><em>The playground on the left lets you adjust component properties, while the code snippet on the right updates accordingly in real time.</em></figcaption></figure><p>When the components get connected to the source code, you can view the active mapping of each design component with its corresponding code reference directly in Code Connect UI, with all variant mappings and the proper framework support.</p><figure><img alt="Code mapping &amp; source code preview: A Code Connect UI screen showing a design component preview on the left and a panel on the right that connects the design to a code component path. The source‑code section contains a snippet verifying the match between the design and the code (e.g., import statements and component definitions)" src="https://cdn-images-1.medium.com/max/1024/1*MmKHS1N4l5Z2e2Gip-cBrg.png" /><figcaption><em>The design component and its linked source code are now visible directly in Figma.</em></figcaption></figure><p>On the IDE side, Figma MCP server now works hand-in-hand with Code Connect, giving AI agents both design context and production awareness. When prompted, Claude Code can pull implementation details directly from the codebase, ensuring the generated prototypes mirror production components accurately.</p><figure><img alt="VS Code showing Claude Code understanding design/code link: A Visual Studio Code window demonstrating that Claude Code can interpret the link between design and code: the left pane lists project files, while the right pane displays a markdown description explaining how Code Connect ensures components are mapped correctly" src="https://cdn-images-1.medium.com/max/1024/1*tywrih93ylNEPSij0Asaag.png" /><figcaption><em>Claude Code can understand the connection between a design and a code component.</em></figcaption></figure><h3>Claude Code in action</h3><p>After the design system was ready, all I had to do was connect it to real code. My goal wasn’t only to make Claude Code generate components from designs, <strong>but</strong> <strong>to reuse the proper tokens, syntax, and patterns that already existed in the codebase</strong>.</p><h4>Project structure</h4><p>I built a<strong> React + Vite</strong> codebase, structured around three core folders:</p><ul><li><strong>styles</strong>: with <em>primitives.css</em>, <em>semantic.css</em>, and <em>components.css</em></li><li><strong>components</strong>: where each component included its .<em>tsx</em>, .<em>stories.tsx</em>, and .<em>css</em> file</li><li><strong>pages</strong>: a directory used for testing prototypes</li></ul><p>I provided both primitive and semantic CSS variables to establish a solid foundation of design tokens. With the help of the Figma MCP Server, Claude Code was then instructed to populate the components CSS file and implement the corresponding React components by referencing and applying those variables.</p><h4>Working with Claude Code</h4><p>The best way to work with Claude Code is within an <strong>IDE</strong> such as <strong>VS Code</strong>, either via terminal or its official extension. That way, code changes appear directly in the IDE, even if it is running in the terminal.</p><figure><img alt="VS Code terminal: A screenshot of a dark terminal within VS Code running Claude Code. It shows logs of tasks and the integrated terminal output while Claude Code executes commands" src="https://cdn-images-1.medium.com/max/1024/1*DTvqCnVjRIj1MihjPpwtVQ.png" /><figcaption><em>Claude Code within the IDE’s terminal.</em></figcaption></figure><p>A key feature of Claude Code is its ability to run multiple agents at the same time to perform different tasks. That way, I didn’t have to restrict myself to working only on one task at a time, but run multiple instances simultaneously to tackle different ones or break a complicated task into smaller ones.</p><figure><img alt="VS Code terminal: Side-by-side terminal windows in VS Code showing Claude Code and Codex CLI running simultaneously. The left panel lists design token variables from a CSS file, while the right panel displays Claude’s analytical output summarizing token counts and usage patterns. The interface demonstrates both tools working in parallel on separate tasks within the same development environment." src="https://cdn-images-1.medium.com/max/1024/1*JQrJmGx758ZoytXvDnXxSA.png" /><figcaption><em>Claude Code and Codex CLI can also run at the same time and perform different tasks.</em></figcaption></figure><h4>Optimizing the workflow</h4><p>The most important thing to keep in mind when working with Claude Code is to provide it with <strong>clear context </strong>and<strong> detailed instructions</strong>. It needs to always know how to perform a task and under what conditions. When it runs, it consumes both time and tokens, which can come at a cost (especially if you are using API pricing), so the goal is to optimize its workflow to always follow the shortest, most accurate route.</p><p>To do that, I created a centralized file at the root of my repository that outlined the project structure and defined how Claude Code should behave across the entire project when handling different tasks. These guidelines included information such as which MCP Servers and tools should be used, when to run verification checks on the implementation, which naming convention should be followed for new files, and other details.</p><figure><img alt="CLAUDE.md files illustration: Illustration of a central yellow folder connected to three subfolders below it, representing an organized project structure. The top folder contains a document with a globe icon, while the three lower folders contain documents with icons symbolizing components (puzzle piece), styles or design tools (paintbrush), and typography (letters “Aa”). The image conveys a structured system linking design elements such as components, styles, and fonts." src="https://cdn-images-1.medium.com/max/1024/1*YFZY-HMlbfVdNQ2bPN8ALw.png" /><figcaption><em>Image created by ChatGPT.</em></figcaption></figure><p>This was achievable with <strong>CLAUDE.md</strong> files — special configuration files that Claude automatically loads into context when starting a session. These files became the governance layer of my design system, ensuring that every implementation went through structured verification before being approved, and specific steps were consistently followed. The <em>root</em> file defines the global steps, while directories like <em>styles</em> and <em>components</em> have their own localized rules.</p><p>This modular approach led to faster responses and better accuracy. Each directory had its own <em>CLAUDE.md</em> file with localized instructions, like defining the format of the output I expected to get from Claude when it performed validation checks on components:</p><pre>#### Component-Specific Matrix Examples:<br><br><br>##### Button Matrix:<br>| Element | Property | Default | Hover | Active | Focus | Disabled |<br>|---------|----------|---------|-------|--------|-------|----------|<br>| Container | Background | #123c80 | #0c2855 | #092341 | #123c80 | #b7b8b9 |<br>| Container | Border | none | none | none | 2px outline | none |<br>| Text | Color | #fff | #fff | #fff | #fff | #6f7071 |<br>| Icon | Color | #fff | #fff | #fff | #fff | #6f7071 |<br>| Icon | Transform | none | none | scale(0.95) | none | none |<br><br><br>##### Card Matrix:<br>| Element | Property | Default | Hover | Selected | Focus | Disabled |<br>|---------|----------|---------|-------|----------|-------|----------|<br>| Container | Shadow | sm | md | lg | outline | none |<br>| Container | Transform | none | translateY(-2px) | none | none | none |<br>| Title | Color | #3c3e3f | #123c80 | #123c80 | #3c3e3f | #6f7071 |<br>| Description | Color | #6f7071 | #6f7071 | #5b5c5d | #6f7071 | #b7b8b9 |<br>| Icon | Opacity | 0.8 | 1 | 1 | 0.8 | 0.4 |</pre><p>This analysis compared the styling consistency of components against their Figma versions, producing a matrix to help Claude identify discrepancies in structure or token usage with precision:</p><figure><img alt="Claude’s output matrix: A terminal screenshot presenting Claude’s output matrix. It lists UI elements and properties (e.g., “Container”, “Background”, “Border”), with columns for default tokens and Figma design tokens, helping to spot mismatches between implementation and design" src="https://cdn-images-1.medium.com/max/1024/1*IKm6i7GOVd5_TmnLuO6WYw.png" /><figcaption><em>Claude’s output matrix comparing implementation tokens and Figma design values.</em></figcaption></figure><p>These are some of the methods ensuring that instead of generating arbitrary color values or Tailwind classes, Claude Code consistently references the correct semantic tokens from CSS.</p><p>That way, the AI wasn’t just generating generic code anymore; <strong>it was</strong> <strong>following specific logic and standards</strong> defined by the design system and reinforced by the project’s structure.</p><h4>Subagents and automation</h4><p>It’s worth noting that Claude Code did not always behave predictably. At times, it disregarded instructions or produced inaccurate results. Acknowledging this, I designed my agents and <em>CLAUDE.md</em> files with layered safeguards, ensuring reliable fallback mechanisms when things went off track.</p><figure><img alt="Verify‑design agent results: A terminal output showing the verify‑design agent’s assessment of a button component. The report lists items like token architecture, ALT token matches, typography, spacing and states coverage, each followed by green check‑marks to indicate correctness" src="https://cdn-images-1.medium.com/max/1024/1*srlZhJq5n1zYqiLulmOpMg.png" /><figcaption><em>The verify-design agent serves as a fallback, ensuring that the design verification process has been followed as it should.</em></figcaption></figure><p><strong>Claude Code agents</strong> (or <em>subagents</em>) act as autonomous assistants that can work on complex tasks following specific rules and using a defined set of tools. They can plan and execute these tasks independently while the main agent continues focusing on the overall workflow.</p><p>When a subagent is invoked, it operates on its own isolated context window. Think of it like a workspace that includes only the information relevant to its assigned subtask. Once it completes its work, it returns a distilled summary of its findings to the main agent, which then integrates them into the primary context.</p><figure><img alt="A flow diagram illustrating how Claude Code subagents operate. The “Main Agent” handles the primary task and invokes “Subagent #1” and “Subagent #2,” each working in isolated context windows. Arrows show subagents sending back distilled insights to the main agent. The caption explains that this setup keeps the main workflow clean and focused while subagents handle subtasks independently." src="https://cdn-images-1.medium.com/max/1024/1*taCOtWWes1HpuW-6TFqfRw.png" /><figcaption><em>Subagents work in isolated context windows and return only distilled insights to the main agent, keeping the primary workflow clean and focused.</em></figcaption></figure><p>This architecture helps keep <strong>lower token usage and costs</strong>, since subagents process smaller portions of information. Meanwhile, the main agent maintains a slightly expanded context window without becoming overloaded. It’s important to note that <strong>a larger context window doesn’t always mean better performance</strong>; it often leads to vaguer reasoning and a higher risk of errors.</p><h4>Optimizing the agents’ workflow</h4><p>Making it easy for the agent to understand when to split a task and which agent to invoke is crucial. In my setup, the root file lists all available agents, ensuring Claude is always aware of which one to use and under which circumstances.</p><pre>## Available Agents (Overview)<br><br>1. **design-verification**: For verifying component implementations match Figma designs and use correct tokens<br>2. **component-composition-reviewer**: For component creation/modification with nested components<br>3. **figma-code-connect-generator**: For ALL Code Connect related tasks<br>4. **token-analyzer**: For analyzing component token usage patterns and optimization recommendations<br>5. **a11y-accessibility-orchestrator**: Main coordinator for comprehensive accessibility audits using Playwright MCP and axe-core<br>6. **a11y-wcag-compliance-auditor**: Specialized WCAG 2.1 AA/AAA compliance testing and legal compliance assessment<br>7. **a11y-color-contrast-specialist**: Expert color contrast analysis <br>8. **a11y-keyboard-navigation-tester**: Comprehensive keyboard accessibility testing and validation<br>9. **a11y-screen-reader-tester**: Screen reader compatibility and ARIA implementation testing<br>10. **claude-md-compliance-checker**: MANDATORY final step for EVERY task</pre><p>All agents were assigned to distinct responsibilities and triggered under specific conditions or manually when needed. Certain rules were also established to ensure that Claude never skipped or overrode these validations.</p><pre>## Quality Gates &amp; Blocking Rules<br><br>### Cannot Proceed If:<br>- design-verification finds violations (when applicable)<br>- component-composition-reviewer finds violations (when applicable)<br>- token-analyzer recommends changes (when applicable)<br>- Build fails<br>- Lint fails<br>- claude-md-compliance-checker finds violations<br><br>### If An Agent Fails:<br>1. Fix ALL reported issues<br>2. Re-run the agent<br>3. Only proceed when it passes<br>4. Then run claude-md-compliance-checker</pre><p>At the end of each task, my <strong>compliance-checker</strong> agent ensured that Claude had successfully followed the workflow outlined in the root <em>CLAUDE.md</em>. If not, then Claude would iterate again, fixing all the flagged issues before marking the task as complete.</p><p>The <strong>design-verification </strong>agent also had another crucial role,<em> </em>continuously validating that all React components matched the original Figma designs.</p><pre>name: design-verification<br>description: Use this agent to verify that component implementations match <br>their Figma design specifications. This agent automatically extracts design <br>data from Figma, analyzes component implementations, and ensures proper design <br>token usage and visual property compliance.<br><br># Tool Restrictions<br>tools: [&quot;Read&quot;, &quot;Grep&quot;, &quot;Glob&quot;, &quot;WebFetch&quot;, &quot;mcp__figma__get_code&quot;, <br>&quot;mcp__figma__get_variable_defs&quot;, &quot;mcp__figma__get_screenshot&quot;, <br>&quot;mcp__figma__get_metadata&quot;]</pre><p>This system of subagents and automation turned my workflow into a self-regulating environment. The next step was to extend this framework with <strong>MCP servers</strong>, enabling my agentic CLI tools to operate beyond their local boundaries.</p><h3>Beyond local boundaries by integrating MCP Servers</h3><p>I’ve already mentioned the <strong>Figma MCP Server</strong> and how crucial it is for bridging design and code in my <a href="https://medium.com/design-bootcamp/designing-with-mcp-server-bridging-design-systems-and-ai-for-developer-friendly-prototypes-4f08b0a0881d">previous article</a>. What unlocks Claude Code’s and Codex CLI’s potential even further is their ability to interact with a wider range of <strong>external toolsets</strong> to perform actions that were previously impossible.</p><p>By connecting them to multiple MCP Servers, my CLI environment became much more than a local sandbox. It could navigate, test, and verify components in real time on <strong>Storybook</strong>, or fetch design context directly from Figma, all within a single prompt.</p><figure><img alt="A diagram showing how Claude Code integrates with external tools via MCP servers. “Claude Code” sits at the center, connected to the “Playwright MCP” on the left and “Figma MCP” on the right. Each MCP lists its available tools — Playwright includes browser navigation and form tools, while Figma includes screenshot, metadata, and design context tools. The diagram illustrates how Claude Code uses these integrations to test interfaces and fetch design data." src="https://cdn-images-1.medium.com/max/1024/1*N4tiPRMhYSGA4AhVKFR8nw.png" /><figcaption><em>MCP integrations connecting Claude Code to tools from Playwright and Figma.</em></figcaption></figure><p>The diagram above shows two of my most valuable integrations. One way to provide Claude with feedback is by sharing a screenshot, asking for a visual misalignment fix. A better way is to let Claude experience the misalignment itself, opening the browser, inspecting the interface, and analyzing the issue in real-time.</p><p>This is one of the many cases where <strong>Playwright MCP</strong> and its browser-level tools allowed Claude to test component interactions, collect console data, or even simulate user behavior during validation.</p><p>Combined with Figma MCP and other integrations, these workflows become truly agentic and automated. Subagents can now run these tools independently to perform validation checks while pulling design context from Figma and behavioral data from the browser simultaneously.</p><h3>Exploring Codex CLI</h3><p>For my experiment, Claude Code acted as the builder, and Codex CLI as the reviewer. I initially started using Codex CLI to verify Claude Code’s implementation and plan fixes. It proved especially helpful for accessibility improvements and code refinement, often suggesting more consistent or efficient component structures.</p><p>At first, Codex CLI didn’t natively support the Figma MCP Server, so it could only access designs indirectly through Playwright MCP or shared screenshots. Despite that limitation, it achieved great results, mostly because the codebase was already well structured, and each React component was built using the correct design tokens, accurately reflecting the Figma original designs.</p><p>However, this changed recently since Figma MCP is now officially supported, allowing Codex CLI to access design data directly.</p><figure><img alt="Codex CLI and Claude Code side‑by‑side terminals: Visual Studio Code showing two terminal windows side by side: the left terminal runs Codex CLI tasks, while the right terminal runs Claude Code, illustrating that both tools can operate concurrently" src="https://cdn-images-1.medium.com/max/1024/1*gAzLbOcVr9AkTybifYku9g.png" /><figcaption><em>Codex CLI and Claude Code running in parallel on separate terminal windows.</em></figcaption></figure><h3>Which one to choose</h3><p>Although Codex provides tools and features similar to Claude Code, I found that each tool excelled in its own domain. Claude Code was better at structuring the project, setting up governance files, automating and defining workflows, while Codex CLI specialized in code refinement, improving readability, accessibility, and performance.</p><p>Both are also accessible through the web or their mobile apps, allowing you to connect to your GitHub repository remotely. They can answer questions about code architecture and implementation, fix bugs, and even start or manage coding tasks while you’re away from your laptop. Once Claude completes its work, you can review the changes, create pull requests directly from the app, and continue working from anywhere.</p><p>From my point of view, together, they formed a balanced collaboration: <strong>Claude Code defined the framework and logic, while Codex CLI perfected the implementation</strong>. This pairing turned my workflow into an iterative design-code cycle that continuously refined itself.</p><h3>From wireframes to prototypes</h3><p>Once code and design share the same foundation, prototypes stop being mere mockups; they become <strong>previews of production</strong>.</p><p>To test this, I decided to put my setup to the ultimate test: <strong>transforming a simple, hand-drawn wireframe into a working prototype with a single prompt</strong>. Both Claude Code and Codex CLI were asked to execute the same task, with the same prompt, wireframe, design tokens, and design system.</p><h4>The setup and wireframe input</h4><p>Both tools communicated with the same design file through Figma MCP Server, where each design component linked to its corresponding code implementation via Code Connect.</p><figure><img alt="Code Connect snippet (React): A Code Connect panel containing a React code snippet for a Button component. It shows import statements and a &lt;Button&gt; element with props such as label=”Button”, variant=”primary”, size=”medium” and disabled" src="https://cdn-images-1.medium.com/max/1024/1*bAYpeiYisOSBRJgRIhqvEA.png" /><figcaption><em>Once connected, the Code Connect snippet for each component surfaced its </em>React source code.</figcaption></figure><p>This connection ensured that both AI agents could pull from the same source of truth, including:</p><ul><li>The design tokens that define colors, typography, and spacing</li><li>The component structure that’s already aligned with the codebase</li><li>The GitHub repository</li></ul><p>For input, I provided a <strong>hand-drawn wireframe</strong> with a few annotations, the sort of sketch I’d usually share to communicate an idea to another designer. I intentionally kept it simple, and a bit imperfect on purpose, focusing on layout and hierarchy instead of visual refinement.</p><figure><img alt="Hand‑drawn wireframe: A hand‑drawn wireframe sketch of a web page. It depicts a header at the top, a “My Work” section with three rectangular placeholders, a “Contact me” form with fields for full name, email and message, an “Any Questions?” area with checkboxes or dropdowns, and a footer at the bottom" src="https://cdn-images-1.medium.com/max/1024/1*8u-phWYYF6iMkx2c3RNqtg.png" /><figcaption><em>The hand-drawn wireframe provided as input to the AI agents (not my proudest sketch!).</em></figcaption></figure><p>The generated page should use only existing components, replicating a real scenario where the prototype reflects production code. As it turns out, both Claude Code and Codex CLI handled this perfectly, using the existing code and confirming that the Code Connect mapping worked as expected.</p><p>Below you can see some of the key components in Storybook:</p><figure><img alt="Storybook design system (GIF): A recording from inside Storybook showing various components like “Small Accordion.” The interface displays controls for properties like “descriptionText” and “expanded,” along with a description, while the left sidebar lists various components categories such as Buttons, Avatars and Alerts" src="https://cdn-images-1.medium.com/max/800/1*b4KPOxsSgLGu_e4Zd29iCg.gif" /><figcaption><em>A look inside Storybook, with some of the key components used to generate the prototype. (GIF)</em></figcaption></figure><h4>The single prompt test</h4><p>To keep the comparison fair, I used the exact same prompt for both tools. The only variation was the phrase<em> “Ultrathink this task”</em>, added for Claude Code to activate its deeper reasoning mode. Everything else, from instructions to references, remained identical, ensuring the results reflected each tool’s true capabilities.</p><pre>Ultrathink this task. <br><br>- I want you to implement the wireframe shown in [Image #5] as a new page <br>called ClaudeWireframeToPrototype, using our existing design system. <br>You must only use our current design tokens and components to recreate <br>this page.<br>- Do not rely on any previously implemented pages as a reference.<br>- You&#39;ll notice that the wireframe includes annotations to help you understand <br>the required components and specifications. For any elements that aren&#39;t <br>explicitly defined, use your judgment to apply the most appropriate existing <br>components or tokens.<br>- Capitalize all button labels and align their placement according to the <br>wireframe.<br>- Maintain a clear visual hierarchy across all UI elements.<br>- The page must be fully responsive, so make sure to implement responsive <br>breakpoints consistent with our existing patterns.<br>- You need to act as both a Senior Designer and a Senior Front-End Engineer <br>for this task. As a designer, carefully select the correct tokens and <br>components that align with our design system constraints. As an engineer, <br>implement the page using proper composition, semantic HTML, and the defined <br>tokens and components.<br>- Once the implementation is complete, use Playwright MCP tools to verify <br>button positioning, text capitalization, and visual hierarchy consistency. Fix <br>accordingly if any issues arise.</pre><p><strong>The goal wasn’t perfection; it was</strong> <strong>alignment</strong>. I wanted to see whether both agents could translate low-fidelity wireframes into a functional prototype using the right components and tokens.</p><p>Additionally, since these prototypes pull components and instructions directly from the codebase (or the Figma file), the resulting output wouldn’t just resemble production; it would be <strong>production-ready</strong>.</p><h4>Claude Code workflow</h4><p>Claude Code was the first to take on the challenge. I used its <em>ultrathink</em> capability and <em>plan mode</em>, allowing it to thoughtfully execute this task while separating research and planning from code execution.</p><p>Once the implementation was complete, I prompted it to use Playwright MCP Server to get visual context from its implementation and verify that everything was in place. It took approximately <strong>14 minutes</strong> to complete the implementation, resulting in a responsive behavior and proper use of components and design tokens such as typography, colors, etc.</p><figure><img alt="Claude’s implementation result: Side‑by‑side image comparing the original hand‑drawn wireframe to the page generated by Claude Code. The final page faithfully reproduces the wireframe’s layout with a header, a grid of content cards, a contact form and a questions section, followed by a dark footer" src="https://cdn-images-1.medium.com/max/1024/1*Wz19fWi3x7mHYejMYW22Zg.png" /><figcaption><em>A visual of the final result implemented by Claude.</em></figcaption></figure><p>Although the implementation looked great, there was an issue with importing the header component properly on tablet and mobile viewports. However, this got easily fixed with a simple prompt right after.</p><p>There was definitely more room for improvement; however, I only intended to test what the first iteration looks like with no major refinements or changes. For what it’s worth, <strong>it overall managed to pull the right components and use them as expected, delivering a satisfactory result.</strong></p><p>You can watch Claude Code working on this task as I recorded its progress and present it through this video:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F3TGefbRdNtA&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D3TGefbRdNtA&amp;image=http%3A%2F%2Fi.ytimg.com%2Fvi%2F3TGefbRdNtA%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ba08873025d6b4e7b2e11278b8a1cb97/href">https://medium.com/media/ba08873025d6b4e7b2e11278b8a1cb97/href</a></iframe><h4>Codex CLI workflow</h4><p>Next, I gave Codex CLI the same brief and design input. Codex approached the task a bit differently, being less conversational and more autonomous in its decisions.</p><figure><img alt="Codex implementation result: Side‑by‑side image comparing the wireframe to the page generated by Codex CLI. The final page resembles the desired layout but adds unexpected category labels and descriptions above each section; the contact form layout differs slightly, and a dark footer appears at the bottom" src="https://cdn-images-1.medium.com/max/1024/1*uWYR-ZelpF01WYvKKkg20A.png" /><figcaption><em>A visual of the final result implemented by Codex.</em></figcaption></figure><p>Its process ran for about <strong>20 minutes</strong>, slightly longer than Claude’s execution. The outcome, however, wasn’t ideal. All sections included an unexpected category label above each title and a short description underneath. The contact form layout also deviated from the original wireframe, while the logo wasn’t imported properly, and several issues were spotted on the responsive viewports.</p><p>These were relatively minor issues that could have been easily fixed with a few additional prompts. However, I intentionally chose not to do that, as my goal was to test how both tools would perform under identical conditions using just one prompt. It’s worth noting, though, that in other tests I conducted, Codex produced much stronger visual results and more sophisticated code, particularly in accessibility and structural logic, where Claude occasionally fell short.</p><p>You can watch Codex executing this task in my video below:</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FNt6wU0-PG6Q%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DNt6wU0-PG6Q&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FNt6wU0-PG6Q%2Fhqdefault.jpg&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/c67dee28e17e955b25e1919b23a241b5/href">https://medium.com/media/c67dee28e17e955b25e1919b23a241b5/href</a></iframe><h3>Takeaway</h3><p>In this experiment, <strong>Claude Code delivered a stronger overall result</strong>, while Codex took a few initiatives when it shouldn’t have. That was not a deal breaker, but for this single-prompt test, Claude was the clear winner.</p><p>What truly matters, though, is what this workflow unlocks. By combining tools like <strong>Claude Code</strong>, <strong>Codex CLI</strong>, and <strong>Figma MCP Server</strong>, designers can now transform wireframes or Figma designs into interactive, production-ready prototypes.</p><p>This approach accelerates ideation, bridges design and engineering, and enables early feedback from stakeholders or even users on pages powered by real, working code.</p><h3>What’s next</h3><p>From my perspective, the next step is <strong>bringing generated screens back into Figma</strong> in a way smart enough to detect components from code, translate design tokens into variables, and replicate auto-layout behavior directly from implementation. It only feels like the natural evolution of this workflow, and I think we’re getting very close to it.</p><p>Most importantly, this experiment proved that <strong>AI doesn’t replace design; it complements it</strong>. It can safely become part of both the design and production workflow, not by generating random layouts or meaningless code, but by following specific guidelines defined by the designer.</p><p>What becomes really essential is the <strong>design system</strong> itself. Now is the time to invest in them, especially after Figma’s latest <a href="https://www.figma.com/blog/schema-2025-design-systems-recap/"><strong>Schema 2025</strong></a> updates, including features like <strong>Extended<em> </em>Collections</strong>, <strong>Slots</strong>, and more.</p><p>At the end of the day, it’s up to each organization to decide how it wants to move forward. Some may prefer quick solutions that generate designs or prototypes detached from any codebase, while others, especially larger teams with established systems and legacy code, will benefit more from connected workflows like this, where AI integrates with existing infrastructure.</p><p><strong>Design systems are now at a defining moment</strong>, proving their value not only to humans but also to machines. Structure will always take time, and it’s not always appreciated since it’s invisible, but it remains a small yet crucial investment toward a much greater opportunity; one where AI aligns with both the designer’s and developer’s intent to produce maintainable code and realistic, production-ready prototypes.</p><h3>Thanks for reading!</h3><p>👋 I’m Iasonas, a Lead Product Designer, currently exploring how better tooling can bring design and development closer together. I write about design tools, AI-powered prototyping, and the intersection of UX and engineering.</p><p>🔗 Feel free to connect with me on <a href="https://www.linkedin.com/in/iasonas-georgiadis/">LinkedIn</a> or check more of my work at <a href="https://www.iasonasgeorgiadis.com/">iasonasgeorgiadis.com</a>.</p><p>♻️ If you enjoyed this article, feel free to follow or reach out. I’m always up for a conversation over coffee about good design and better handoffs</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f10c136ec11f" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/designing-with-claude-code-and-codex-cli-building-ai-driven-workflows-powered-by-code-connect-ui-f10c136ec11f">Building AI-driven workflows powered by Claude Code and other tools</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designing with MCP Server: Bridging Design Systems and AI for Developer-Friendly Prototypes]]></title>
            <link>https://medium.com/design-bootcamp/designing-with-mcp-server-bridging-design-systems-and-ai-for-developer-friendly-prototypes-4f08b0a0881d?source=rss-bc4df0160f4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/4f08b0a0881d</guid>
            <category><![CDATA[mcp-server]]></category>
            <category><![CDATA[design-systems]]></category>
            <category><![CDATA[ai-in-design]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[prototyping]]></category>
            <dc:creator><![CDATA[Iasonas Georgiadis]]></dc:creator>
            <pubDate>Mon, 07 Jul 2025 10:46:29 GMT</pubDate>
            <atom:updated>2025-07-10T14:10:24.668Z</atom:updated>
            <content:encoded><![CDATA[<h4>Exploring how Figma’s Dev Mode MCP Server and Cursor help bring tokens and components closer to production code</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kd2hDhW9sABchCP-yMyOsQ.png" /><figcaption>Figma’s MCP Dev Server to code</figcaption></figure><h4>TL;DR</h4><p>After previously exploring AI design tools, I found limitations in how well they integrated real-world design systems. In this guide, I demonstrate how I overcame these challenges by combining <strong>Figma’s Dev Mode MCP Server</strong> with <strong>Cursor</strong>, enabling seamless, code-aware prototyping directly from my existing design system.</p><p>The result is high-fidelity, developer-friendly prototypes that accurately reflect original designs, streamlining collaboration between design and engineering.</p><p>Last April, I wrote about <a href="https://medium.com/design-bootcamp/designing-with-prompts-a-product-designers-journey-into-exploring-ai-tools-116aefa70966">what it’s like to be a product designer exploring AI tools</a> such as <strong>Replit</strong>, <strong>Lovable</strong>, <strong>v0</strong>, and <strong>Bolt</strong> to enhance everyday workflows. My goal was to stress-test these tools to understand their capabilities and how they could meaningfully integrate into a design process by providing actual value without flashy gimmicks.</p><p>I concluded that they can’t yet fully integrate into a corporate workflow, but they can help explore and prototype some ideas quickly. The biggest limitation was the inability to incorporate your own design system or import high-fidelity Figma designs for fast prototyping.</p><p>The generated design typically relied on standard CSS libraries like <strong>Tailwind</strong> or <strong>MUI</strong> but lacked uniqueness, and let’s be honest, nobody wants to ship copy-paste designs like this, especially in large organizations.</p><p>I also emphasized that integrating your own design system into the AI tooling was essential and that it was only a matter of time before we got there. Now, it finally feels like that time has arrived.</p><h3>What didn’t work previously</h3><p>Being unable to import your own design system while prompting was the reason I remained skeptical, even after exploring all these tools. They felt great at drafting and prototyping rough ideas, but although they had an “Import from Figma” button, it never worked as expected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1MRwKb0epFlL5FUpXUq7Sw.png" /><figcaption><em>Subframe includes an “Import from Figma” option, but all it really does is paste a static image of the selected frame.</em></figcaption></figure><p>As a product designer, I want to build a design system that meets my accessibility criteria, branding guidelines, and specific organizational needs. I appreciate being able to prototype fast, using prompts, but I prefer to quickly prototype, reviewing my own Figma designs, and iterating directly in Figma.</p><p>The good news is that this is possible now.</p><h3>A new opportunity arises</h3><p>You might have already heard about it, but <strong>Anthropic</strong> recently launched the <strong>Model Context Protocol</strong> (<a href="https://docs.anthropic.com/en/docs/mcp">MCP</a>), an open protocol that standardizes how applications provide context to LLMs.</p><p>This means that LLMs like <strong>Claude</strong> and <strong>ChatGPT</strong> can seamlessly integrate with MCP-compatible tools and services, gathering context directly from sources, such as your Figma files. This became possible after <strong>Figma</strong> announced the beta release of the <a href="https://www.figma.com/blog/introducing-figmas-dev-mode-mcp-server/"><strong>Dev Mode MCP Server</strong></a>, which allows developers to bring context from Figma into agentic coding tools like <strong>Copilot in VS Code</strong>, <strong>Cursor</strong>, <strong>Windsurf</strong>, and <strong>Claude</strong><em> </em><strong>Code</strong>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*HqoQr0OMiofYgX6K" /><figcaption><em>Image created by </em><a href="https://www.figma.com/blog/introducing-figmas-dev-mode-mcp-server/"><em>Figma</em></a><em>.</em></figcaption></figure><p>For me, this felt like the missing link — finally, a meaningful way to expand AI capabilities. I explored how the MCP server could help me achieve better results, where my designs acted as the foundation and my design system as the backbone of every prototype I would generate.</p><p>In this article, I’ll share my thoughts and show how I managed to create a prototype from my <strong>Figma</strong> design, using <strong>Cursor</strong> and the <strong>MCP server</strong>.</p><h3>Dev Mode MCP Server vs. traditional AI tools</h3><p>What I liked about working with the <strong>Dev Mode MCP Server</strong> is that it doesn’t rely on vague data. Instead of relying on screenshots, you can now provide an actual Figma frame with all its data.</p><p>I have heard that many companies are keen to use AI tools such as Lovable, v0, Subframe, etc, attempting to generate designs quickly through prompts, although they’ll spend hours refining these prompts afterward to make the delivered prototype look and feel like the original. The reason is simple: none of these tools has native and full access to the Figma file.</p><p>Even if you succeed in making the final prototype resemble your original design after countless prompt iterations, you should be aware that the code under the hood is, in most cases, a mess. That comes up from the fact that all AI design tools out there rely heavily on CSS and React component libraries such as <strong>Shadcn</strong> (<a href="https://ui.shadcn.com/">https://ui.shadcn.com/</a>) or <strong>Tailwind</strong> (<a href="https://tailwindcss.com/">https://tailwindcss.com/</a>) to generate designs. I am not judging whether these libraries are good or bad; I am just mentioning it since it explains why the generated designs, in most cases, don’t look anything like yours.</p><p>More importantly, even if you do manage to prompt a visually polished result, the code will be using custom CSS classes that might make no sense to fellow developers or even you. You’ll often see colors hardcoded with random hex values and spacing defined in pixels rather than rems or tokens.</p><p>What is even more important than using meaningful classes or rem units instead of pixels is using your design tokens to populate the generated designs. As a product designer who highly values the power of a solid and cohesive design system while also exploring AI opportunities, this is exactly the direction we should be heading. And fortunately, it’s already starting to happen.</p><h3>Getting started with MCP and Cursor</h3><p>I chose to experiment with <strong>Cursor</strong>, an AI-powered code editor that supports MCP server integration. I connected to <strong>Figma’s MCP Server</strong> manually, but now it seems you can connect several connections with various supported tools, much more easily through <a href="https://docs.cursor.com/tools/mcp">Cursor’s page</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*znRWfcJLXYBfGs3h" /><figcaption><em>You can easily connect an MCP Server to Cursor through its page.</em></figcaption></figure><p>The next step was to enable the Dev Mode MCP Server in Figma, so both tools are now connected.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9f-Zr0tkvBRmHJzx" /><figcaption><em>You can easily enable the Dev Mode MCP Server in Figma through “Preferences”.</em></figcaption></figure><p>Once both tools are connected, you can now extract your designs into <strong>Cursor</strong> by providing the LLM of your choice full access to your variables, color styles, typography, spacing, etc.</p><h4>Preparing your designs for effective AI integration</h4><p>It’s tempting to think of AI as a magician pulling rabbits from hats. But prompting efficiently is becoming a skill since there is no magic behind the AI agents. For designers, prompting with well-structured design files now serves as a crucial step in achieving prototypes and components that are in sync with their designs and the code that fellow developers are using.</p><p>We all know this feeling: creating designs that look and feel good but paying no attention to the details, such as correctly naming our layers. However, doing this right is essential for the LLMs, so they can extract more context on how an Auto Layout frame is structured and what its place is in the overall design.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*rrWnqJsnGDESnytO" /><figcaption><em>I have been there, and I am not proud of this structure either.</em></figcaption></figure><p>Luckily, Figma offers the “Rename Layers” AI feature, which can help explore some draft concepts in a structured way, even if there is no time to do everything correctly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nA0mZWoEVqoCRl7z" /><figcaption><em>Figma’s “Rename Layers” feature has been life-saving.</em></figcaption></figure><p>Lastly, structuring also means using Auto Layout instead of random frames. This gives the LLM richer context about how the design elements should behave in code.</p><h4>Powered by your design system</h4><p>The final and most important piece is having a solid design system in place. This is where I evaluate the outcome, not just by visual similarity, but by achieving a true 1:1 match through design tokens.</p><p>That’s what makes all the difference: instead of relying on public CSS libraries, you are now using your own design system to generate code-ready components. Imagine prompting an LLM to recreate a component, and instead of guessing, it references your actual Figma variables and reuses them in code.</p><h3>Defining success criteria</h3><p>Like last time, I had to set up my expectations before I started. The goal was to use my existing design system, consisting of Figma variables, styles, and components, to create design tokens in code and prototypes that will mirror my designs.</p><p>This time, I didn’t focus only on creating something that seemed satisfactory quickly, but also on how well-structured the whole project was. I built a <strong>React app with Vite</strong>, installed <strong>Storybook</strong>, and tried to make it as cohesive as I could, considering I am not a developer myself.</p><p>My satisfaction was based on the following success criteria:</p><ul><li>Accuracy of the first generated prototype</li><li>Proper translation of Figma variables into design tokens</li><li>Correct application of design tokens within each component</li><li>Generation of Storybook stories for all components</li><li>Speed in reaching a satisfactory result</li><li>Overall quality and consistency of the output</li></ul><p>The key factors were:</p><ul><li>A 1:1 visual match between design and code</li><li>Readable, maintainable code that aligns with design tokens</li></ul><p>As mentioned before, I used Cursor and tried different agents such as <strong>Claude-4-sonnet</strong>, <strong>Gpt-4.1</strong>, <strong>Gemini-2.5-pro</strong>, and others. I ultimately chose Claude, which, in my case, produced the best results. I began with Cursor’s free version, but quickly upgraded to Pro, after running out of tokens early on.</p><h3>Testing the MCP Server in real projects</h3><p>The idea was to create an updated version of my portfolio website using <strong>Cursor</strong> and <strong>Dev Mode MCP Server</strong> to translate my designs into fully functional code, using my own assets and design tokens.</p><p>For the purposes of this article, I’ll focus on building the landing page and creating a documentation page in Storybook where I’ll host all the created components and test them in isolation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*joPomLDF1OQdWF4z" /><figcaption><em>The Figma design of my website portfolio.</em></figcaption></figure><p>I created my project and provided all the necessary assets, such as logos, images, etc. What feels natural working in a code editor is using terminal commands and easily connecting to your <strong>GitHub</strong> repository, which can happen directly from <strong>Cursor</strong> (or any other code editor such as <strong>VS Code</strong> or <strong>Windsurf</strong>).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*H_3hNodkgRng5GJc" /><figcaption><em>The Cursor’s UI with my project on the left and the AI agent on the right.</em></figcaption></figure><h3>Building design tokens</h3><p>I started by creating my design tokens. There are several ways to do this — either by exporting your Figma variables using a plugin or by defining them manually. In my case, I worked with a range of variables: <strong>color</strong> (primitive, semantic, component), <strong>sizing</strong> (paddings, margins, etc), and <strong>typography</strong> variables (font family, font size, and more).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*nECFARj4_PHq-LdP" /><figcaption><em>Some of the primitive color variables I use.</em></figcaption></figure><p>I also had several primitive numerical variables grouped under “<strong>sizing</strong>”, which were semantically translated into paddings, margins, radius, font size, and more.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*57-Bqcklm1qBKdtx" /><figcaption><em>Some of the primitive numerical variables I use.</em></figcaption></figure><p>The next step was to define corresponding CSS variables in Cursor and ensure they were used consistently when generating components.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*qXKPufgXJb2JwTcW" /><figcaption><em>Some of the primitive CSS variables.</em></figcaption></figure><p>I asked Cursor to generate some of the necessary dependencies, and I have to admit — it handled them quite well. I also discovered that creating <strong>Rules</strong> in Cursor helps provide persistent, reusable context to the LLMs at the prompt level. By defining a few targeted restrictions, I was able to guide the AI agents to follow specific implementation guidelines more consistently.</p><h4>Implementing dark and light mode support</h4><p>As you may have noticed before, the primitive color collection supported a dark mode for all colors. This led to a quite easy implementation of light and dark toggle in <strong>Cursor</strong>, where I asked the agent to make sure this functionality would be supported in code.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*q-6oWq1LsLa5s5vD" /><figcaption><em>Setting your Figma variables correctly not only allows you to design more efficiently but also sets the ground for easier implementation.</em></figcaption></figure><h3>Your design file as a powerful prompt</h3><p>Let’s revisit the design file one more time. It’s really important to structure it well, in the same way that would make sense if you’d hand it over to a developer. This means naming your layers, using Auto Layout to explain responsive behaviors, and variables instead of hardcoded values, while also setting up properties for your components.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yMF4bvQN4SZRONVO" /><figcaption><em>The “project-item” component and its properties.</em></figcaption></figure><p>This gives the LLM direct access to your components, making your prompts significantly more context-aware. Additionally, using your Figma variables consistently and predictably will ensure that your future builds will be using the right ones.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5xKQQCaGhGw5UwEq" /><figcaption><em>The project-item component in the Dev mode.</em></figcaption></figure><h3>Implementing components with Cursor</h3><p>Once everything was set up on the design side and the tokens were already exported on the Cursor side, I started prompting my way through the implementation of my React app.</p><p>I suggest starting small by creating basic components, such as buttons, and then moving onto larger components, such as the <strong>“article-item</strong>” shown below.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-FFR5JnHvZ1cehJ2" /><figcaption><em>The “article-item” component and its properties.</em></figcaption></figure><p>The model I used was <strong>Claude-4-sonnet</strong>, which I think provided the best results among the rest. I asked the agent to implement the design above by providing the Figma URL for this component.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*BEMS3WtiskAoEXyK" /><figcaption><em>The implementation of the “article-item” component on the left and the provided prompt to the right</em>.</figcaption></figure><p>What <strong>Cursor</strong> did at that point was to allow <strong>Claude</strong> to reach my design through the <strong>Dev Mode MCP Server</strong> and fetch all the necessary information before it proceeded with the implementation. It is worth noting that it didn’t have to make any assumptions as it would do from a screenshot, but got immediate access to the source (through the “<strong>get_code</strong>” tool) and also had a visual of what the design looks like (through the “<strong>get_image</strong>” tool).</p><h3>Evaluating the final prototype</h3><p>Honestly, the final result exceeded my expectations. I created a prototype that matched my design 1:1, then fine-tuned a few interactions directly in code.</p><p>Some minor differences can be spotted; however, I made some adjustments on the fly directly in Cursor. For example, the navigation pane on the left behaves responsively in the implementation, using the <strong>vw</strong> unit to calculate its width based on the viewport, while the font size scales accordingly.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*OhWoFeqgGfvB2JN4" /><figcaption><em>The Figma prototype of the original design as it was created in Figma (GIF).</em></figcaption></figure><p>My React app pulls inspiration directly from my Figma design, using all the tokens I created at the beginning. The code is easier to read, review, and refine, while visually it’s impressively accurate.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*2YmNep2doAvNtIhj" /><figcaption><em>The end result — being implemented by Cursor using the Dev Mode MCP Server (GIF).</em></figcaption></figure><p>What makes it even more interesting is that I also managed to generate a <strong>Storybook</strong> containing all the components and their interactions. I didn’t tweak it further, aside from asking the agent to create a story for each component. Everything was populated by the AI itself, and it made a lot of sense as a starting point.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*Rmc69eftBvDn7a5h" /><figcaption>The components in Storybook (GIF).</figcaption></figure><h3>My takeaway</h3><p>I think this is a major step in the right direction. The key isn’t to replace existing workflows with flashy AI tools, but to thoughtfully integrate AI into the systems and processes we already rely on. For teams that value UX and design thinking, this seems like the most viable path forward. Great products are built when designers have space to empathize with users and define problems before rushing into solutions or prototypes.</p><p>Most of us are already designing in Figma or building our design systems there, so using tools like MCP Server feels like the most natural way to introduce AI into our workflows.</p><p>I understand that not everyone can design and code components at the same time, especially without some front-end knowledge. But designers don’t need to become developers. What matters more is knowing how to communicate effectively, because that’s always been at the heart of great product teams.</p><h3>What’s next for AI in Product Design?</h3><p>This is the same section I used in my <a href="https://medium.com/design-bootcamp/designing-with-prompts-a-product-designers-journey-into-exploring-ai-tools-116aefa70966">previous article</a>, where I’m trying to foresee what’s coming next. Last time, I said that the integration of a custom design system was only a matter of time, and now it feels like we are already there.</p><p>What I would like to see next is the ability to reuse existing code or design components to create prototypes and accelerate ideation. This would allow designers to experiment really fast on prompting some rough ideas, without the need to prepare a draft design or use any tokens. When an idea seems good, they can come back to Figma and create high-fidelity designs to explore it further.</p><p>In my view, this is a true game changer, and it’s exactly where forward-thinking organizations should be heading. Not toward flashy prototypes, but toward reusable code that aligns with how teams already work.</p><p>Now isn’t the time to bypass the design or development process, but a time for designers and developers to refine their workflows together, using AI as a bridge between them.</p><p>And if you’re looking to keep pace with the rise of AI in product design, this is where to start.</p><h4>Thanks for reading!</h4><p>👋 I’m Iasonas, a Lead Product Designer, currently exploring how better tooling can bring design and development closer together. I write about design tools, AI-powered prototyping, and the intersection of UX and engineering.</p><p>🔗 Feel free to connect with me on <a href="https://www.linkedin.com/in/iasonasgeorgiadis/">LinkedIn</a> or check more of my work at <a href="https://iasonasgeorgiadis.com/">iasonasgeorgiadis.com</a>.</p><p>♻️ If you enjoyed this article, feel free to follow or reach out. I’m always up for a conversation over coffee about good design and better handoffs!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f08b0a0881d" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/designing-with-mcp-server-bridging-design-systems-and-ai-for-developer-friendly-prototypes-4f08b0a0881d">Designing with MCP Server: Bridging Design Systems and AI for Developer-Friendly Prototypes</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[Designing with Prompts: A Product Designer’s Journey into Exploring AI Tools]]></title>
            <link>https://medium.com/design-bootcamp/designing-with-prompts-a-product-designers-journey-into-exploring-ai-tools-116aefa70966?source=rss-bc4df0160f4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/116aefa70966</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[design-tools]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Iasonas Georgiadis]]></dc:creator>
            <pubDate>Wed, 09 Apr 2025 12:14:23 GMT</pubDate>
            <atom:updated>2025-07-07T10:47:16.517Z</atom:updated>
            <content:encoded><![CDATA[<h4>An inside look at how prompting is shaping the next wave of UX experimentation.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3cHGGveJe4Ifxwx42ehkSg.png" /><figcaption>Image created by ChatGPT 4o</figcaption></figure><p>I consider myself a skeptic. Not in a bad way; I get excited about many things, but I always try to put a second thought and ask myself: Is it really worth it, or is this just pure excitement?</p><p>The same applies to my job. I am a Product Designer, still looking for ways to make my working day more productive, more interesting, and more exciting. Have no doubt, though, working on digital products that are being used by millions of users every day is such an exciting endeavour, especially when you have to collaborate with many talented people in various fields, from engineering, to product management, and design.</p><p>In this article, I explore a few AI prompt-based prototyping tools to see how they respond to the same (or very similar) prompts. My goal is to understand their capabilities and how they might fit into, or even reshape, a product designer’s everyday workflow.</p><h3>What my current workflow looks like</h3><p>I love working with <strong>Figma, </strong>and<strong> </strong>I am always eager to catch up with all new features the time they get released. I test them early and try to find the most efficient way they can streamline my workflow at the time. Especially after the introduction of variables, our design team finally managed to find a way to communicate better with the developer teams.</p><p>However, we all know that technology evolves quickly, especially in the field of AI. It extends to a wide spectrum of different fields, from generating copyright content to editing and creating images, from writing code and deploying apps to designing digital products in a completely new way.</p><p>To me, this sounds exciting, but is it really worth it?</p><h3>AI innovation is a thing</h3><p>Although I don’t have a solid answer yet, I feel that AI creates new opportunities. An increasing number of companies are integrating AI into their products and services to position themselves early as leaders in AI-driven innovation within their industries.</p><p>Some of these initiatives seem like fancy wrapping of the same product, while some others are really groundbreaking. Not only that, but utilizing AI to streamline internal workflows makes even more sense today — though there is a risk that overexcitement can lead to unintended consequences.</p><p>That said, several AI tools can do different kinds of work, therefore, there are several ways out there to streamline your workflow. But how does this apply to product design?</p><h3>Knowing when and how to use AI tools</h3><p>Being a product designer feels quite exciting these days. There are more and more AI tools we can use, but they can sometimes feel overwhelming. Hence, knowing how and when to use these tools becomes a valuable skill for all product designers.</p><p>There are many AI design tools out there offering different capabilities; from helping with design system management (<strong>Zeroheight</strong>, <strong>Supernova</strong>, etc), to design &amp; prototyping (<strong>v0</strong>, <strong>Replit</strong>, <strong>Lovable</strong>, etc), accessibility checking (<strong>Envinved</strong>, <strong>Stark</strong>, etc), to image creation (<strong>Midjourney</strong>, <strong>Sora</strong>, <strong>Visual<em> </em>Electric</strong><em>,</em> etc) and more.</p><p>For this case, I tested the following AI prototyping tools to build a prototype.</p><p>The description for each comes from their official websites:</p><ul><li><strong>Bolt</strong> is an AI web development agent for full-stack application development (<a href="https://bolt.new/">https://bolt.new/</a>)</li><li><strong>Replit</strong> is a browser-based platform where you can effortlessly create and share apps without installation or setup (<a href="https://replit.com/">https:<strong>//</strong>replit.com/</a>)</li><li><strong>Lovable</strong> lets you chat to build real websites &amp; web apps and collaborate on interactive prototypes (<a href="https://lovable.dev/">https://lovable.dev/</a>)</li><li><strong>v0 by Vercel<em> </em></strong>is a powerful tool for generating high-quality UIs and code, and it’s also an educational asset for designing and creating on the web (<a href="https://v0.dev/">https://v0.dev/</a>)</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7HMQ40w0apMO_Efy" /><figcaption>Image created by ChatGPT 4o</figcaption></figure><p>All tools help you write code, design interfaces, and create prototypes by using simple prompts. After testing them for a while, I don’t think they can omit Figma completely from the current design workflow or even replace the collaboration with a developer or other designers.</p><p>However, they do make quick prototyping easier and give a preview of what the near future might look like.</p><h3>Putting AI tools to the test</h3><p>I wanted to test all the different tools at the same time and see which one provided the best results. The goal was to create a prototype of a web app that allows users to efficiently add entries in an automated way and be able to manually edit them if needed.</p><p>My satisfaction was based on the following success criteria:</p><ul><li>How designer-friendly the tool’s interface was</li><li>How accurate the first iteration was</li><li>How intuitive it felt to build a web app</li><li>How easily I could explain my thinking to the agent</li><li>How quickly the tool reached a satisfactory result</li><li>The overall quality of the output</li></ul><p>I would like to specify that I experimented with the free versions of all, so there was a limitation in the progress I could make in a day. However, I was still able to realise my preference early enough (spoiler alert: it’s <strong>Replit</strong>), and I don’t think that this restriction played a vital role in the early experimentation I wanted to conduct.</p><p>For what it’s worth, I believe that all these tools will evolve really fast in the days to come, so I didn’t mean to explore everything in depth, but more to familiarize myself with these tools and their capabilities. I genuinely believe that they will get better soon and will probably cover more needs, like integrating your own design system.</p><h3>“Designing” effective prompts</h3><p>All four tools were quite user-friendly. They remind me of ChatGPT, an AI agent that most people are very familiar with, and allow you to start right off by just describing what you want to make. There is no need to set up any dev environment or make any preparations beforehand.</p><figure><img alt="Replit’s welcome screen" src="https://cdn-images-1.medium.com/max/1024/1*BOdSqgYno2rhzIL2i7g-UQ.png" /><figcaption>Replit’s welcome screen</figcaption></figure><p>I started with my prompt, which I tried to make as specific as possible, yet short and direct. I wanted to provide a clear goal, some requirements, and a style direction.</p><p>My goal was to create a web app that allows users to easily track their job applications. To make it more intuitive, the user could paste a link from a job board (eg, LinkedIn), and the system would pre-fill most of the fields. The user would be able to review and edit this information before submitting it. Doing so, he would be able to see at a glance all his ongoing or rejected applications.</p><p>🤖 The prompt I tried was the following:</p><pre>Create a web app for users to track their job applications. <br><br>The user should be able to paste the link from a job posting site <br>(eg, from LinkedIn), and the system would automatically fill the <br>following fields:<br><br>- Company name<br>- Role<br>- Country<br>- City<br>- Date of application<br>- [Toggle] Status: Ongoing/Rejected<br><br>The user should be able to change this information manually if he wants to. <br><br>You figure out the best format to display this information and use MUI <br>as a design style framework.</pre><p>And here is the first feature I liked, coming from <strong>v0</strong><em>, </em>which allowed the agent to “enhance my prompt” before submitting it. Note that both <strong>Replit</strong> and <strong>Bolt </strong>offer a similar feature as well.</p><figure><img alt="The enhance prompt feature by v0" src="https://cdn-images-1.medium.com/max/1024/1*4h_B_86EtkHBSb7Sm-Oh8Q.png" /><figcaption>The enhance prompt feature by v0</figcaption></figure><p>🤖💪 By doing so, I ended up using the following refined prompt instead across all tools:</p><pre>Develop a web application enabling users to meticulously track <br>their job applications. The core functionality should allow users <br>to input a job posting link, such as from LinkedIn, and automatically <br>populate the following fields: company name, job role, country, city, <br>and the date of application. Implement a toggle feature to indicate <br>the application status, with options for &#39;Ongoing&#39; and &#39;Rejected&#39;. <br>Provide the user with the flexibility to manually edit any of the <br>automatically populated information. Design the application with <br>a user-friendly interface, determining the most effective format <br>for displaying the application data. Utilize Material UI (MUI) <br>as the design framework to ensure a consistent and visually appealing <br>user experience.</pre><h3>Working with the AI tools</h3><p>It was my intention not to provide any UX direction. I had in mind that a table format would work well, but I didn’t want to give any hint. I just wanted them to start from scratch and see which one of them was making the best decisions.</p><p>I also didn’t mean to do a thorough review, but a test to see which one of these tools provided a more robust solution, both UX and implementation-wise. It didn’t have to be perfect; I just wanted to see some proof of concept, something that starts well and can evolve into something greater.</p><p>Lastly, I set a limitation for this test: the number of prompts each one of these tools gave me for one day’s work of free use.</p><h4>Bolt</h4><p><strong>Bolt</strong> created a form with a table underneath, using the Material UI (MUI) library as requested. In terms of styling, everything looked in place, although regarding the layout, it wasn’t the best decision to take.</p><p>I tested the prototype myself to identify any usability issues and ensure it worked as intended. However, I found out that the automated solution where the system fetches information from the provided URL didn’t work as expected.</p><figure><img alt="The initial design as provided by Bolt." src="https://cdn-images-1.medium.com/max/1024/1*xNWpY58P3G1aandym9a7xQ.png" /><figcaption>The initial design as provided by <em>Bolt</em>.</figcaption></figure><p>It wasn’t a surprise to me, as it was a more complex task. I tried fixing this with some prompts (I used the same prompts for all tools when I faced the same issue), but I didn’t manage to fix it before I ran out of credits.</p><h4>Lovable</h4><p><strong>Lovable</strong> tried a completely different layout than the one I had in mind. It used a card format for displaying the job applications and claimed that it pulled inspiration from <em>Notion</em> and <em>Trello</em>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jut3uT4JLFra6nsOvDCWPQ.png" /><figcaption>The initial design as provided by <em>Lovable</em>.</figcaption></figure><p>Although the tool mentioned that it used a palette with blue as the primary color, this was not true. It didn’t follow MUI either and proceeded with its own design decisions.</p><figure><img alt="The “Add new job application” modal — Lovable" src="https://cdn-images-1.medium.com/max/1024/1*7OWolXDJfT7-YuwVx39Cog.png" /><figcaption>The “Add new job application” modal — Lovable</figcaption></figure><p>A feature I liked was the “Edit” button, which allows you to select a particular element in your preview and suggest or make changes on the spot. A similar feature also exists on <strong>Replit</strong>, <strong>v0</strong> and <strong>Bolt</strong>.</p><figure><img alt="You can easily prompt a change to a specific UI element — Lovable" src="https://cdn-images-1.medium.com/max/848/1*CmaWfqkP01nTTXDH7owf9w.png" /><figcaption>You can easily prompt a change to a specific UI element — Lovable</figcaption></figure><p>Besides that, the fetching job details from URLs functionality didn’t work well. I asked the agent to do some refinements since the data it pulled was incorrect, but unfortunately, it didn’t end up fixing this before my credits ran out again.</p><h4>v0 by Vercel</h4><p><strong>v0</strong> seemed to be a bit more confused. What is worth mentioning is that it followed a table approach with a button prompting the user to add applications. It didn’t use the MUI design system for styling either, and this was the first thing I noticed.</p><figure><img alt="The initial design as provided by v0." src="https://cdn-images-1.medium.com/max/1024/1*GoaxjS5sWAYpeFvH0T34IA.png" /><figcaption>The initial design as provided by <em>v0</em>.</figcaption></figure><p>This was an easy fix (done with one prompt), however, it resulted in some odd layout changes as well, while the fetching functionality kept not working.</p><figure><img alt="The second design iteration as provided by v0, utilizing MUI." src="https://cdn-images-1.medium.com/max/1024/1*Vu9SH1qzFd9QizOwBts9Nw.png" /><figcaption>The second design iteration as provided by <em>v0, utilizing MUI</em>.</figcaption></figure><p>v0 said it faced some implications that were related to the use of MUI, so I prompted it to use another design system if this would help it tackling this issue. Unfortunately, it didn’t manage to fix it after all.</p><h4>Replit</h4><p>And here comes my personal favorite. <strong>Replit</strong> managed to start well by creating a table format for the entries and some filtering options. It also provided an overview of total applications, as well as the ongoing and the rejected ones.</p><figure><img alt="The initial design as provided by Replit." src="https://cdn-images-1.medium.com/max/1024/0*XJBWviLeFlrfh15C" /><figcaption>The initial design as provided by <em>Replit</em>.</figcaption></figure><p>It used the MUI library to style the whole app, and although the fetching functionality didn’t work as expected, I managed to fix it with ~4 prompts.</p><figure><img alt="Replit’s fetching functionality in one of the iterations I explored." src="https://cdn-images-1.medium.com/max/800/1*wO19SM2nJXoUwsGM1v4RoA.gif" /><figcaption>Replit’s fetching functionality in one of the iterations I explored.</figcaption></figure><p>This is huge, considering the results from the other tools, being the only one that managed to fix it efficiently. To provide more context, please note that I used the same prompt sequence across all tools, making them more specific to each one of them along the way.</p><figure><img alt="The “Add a new job application” modal — Replit" src="https://cdn-images-1.medium.com/max/1024/0*FxvWCbSZJ7Y0rOri" /><figcaption>The “Add a new job application” modal — Replit</figcaption></figure><p>Since <strong>Replit</strong> tackled this issue really fast, I had the chance to dive into more details. I changed the button and its placement, and along with some other UI changes, I even had the chance to take some time for the edge cases.</p><figure><img alt="The latest design iteration accommodates various UX and UI changes — Replit" src="https://cdn-images-1.medium.com/max/1024/0*mgu7VEO5hf9vX_JM" /><figcaption>The latest design iteration accommodates various UX and UI changes — Replit</figcaption></figure><p>I added a validation at the submission level, so when an entry seems to be the same or similar to another one, the system highlights the differences and asks the user to confirm whether he wants to replace, keep both, or cancel the submission.</p><p>Seeing the web app in action, I also considered adding bulk actions to the table, such as exporting multiple entries into CSV format.</p><p>My point is that <strong>Replit</strong> seemed better at tackling more complex tasks than the rest, providing efficient back-end solutions, and allowing me to focus on things that matter to me the most as a designer.</p><h3>Key takeaways</h3><p>As mentioned before, I didn’t plan to find and suggest the best tool to use at the moment. My approach was to stretch-test some of the tools available out there to understand their capabilities.</p><p>In my opinion, <strong>Replit</strong> outperformed the rest. It felt quite easy for me to set a clear goal for the “end product” and get to a satisfying starting point. The result was far from perfect, but it was enough for me to start exploring edge cases and other opportunities that were coming up along the way.</p><p>As a product designer, I don’t think that these tools can skip the design thinking process and provide a valuable product on their own. They are great for prototyping ideas rapidly and giving you the time to evolve them.</p><p>What stands out is their ability to bypass technical restrictions easily; I just had to describe what I wanted to achieve. For example, I had no idea how to fix the fetching problem, I just described what I wanted to achieve and reviewed the result I was being given. All tools were iterating through different solutions fast, but I was satisfied with <strong>Replit</strong> more than the others.</p><h3>What’s next for AI in Product Design?</h3><p>Although there are some cases these tools cannot handle well at the moment, such as integrating your own design system or importing your high fidelity Figma designs to get prototypes fast, I believe it’s only a matter of time to get there. They are not able to fully integrate into a corporate workflow at the moment, but they can help explore and prototype some ideas fast.</p><p>My advice to other designers is that you should familiarize yourself with these tools without the need to be an expert on them now, as they will continue to evolve. The product designer role is going to evolve into incorporating AI tools in our everyday working life, but everything is still experimental. It is an exciting opportunity, for sure.</p><p>Is it worth it? I believe it is.</p><h3>Thanks for reading!</h3><p>👋 I’m Iasonas, a Lead Product Designer, currently exploring how better tooling can bring design and development closer together. I write about design tools, AI-powered prototyping, and the intersection of UX and engineering.</p><p>🔗 Feel free to connect with me on <a href="https://www.linkedin.com/in/iasonasgeorgiadis/">LinkedIn</a> or check more of my work at <a href="https://iasonasgeorgiadis.com/">iasonasgeorgiadis.com</a>.</p><p>♻️ If you enjoyed this article, feel free to follow or reach out. I’m always up for a conversation over coffee about good design and better handoffs!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=116aefa70966" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/designing-with-prompts-a-product-designers-journey-into-exploring-ai-tools-116aefa70966">Designing with Prompts: A Product Designer’s Journey into Exploring AI Tools</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[Empathy in UX design and effective communication]]></title>
            <link>https://medium.com/design-bootcamp/empathy-in-ux-design-and-effective-communication-3ad825956cf2?source=rss-bc4df0160f4f------2</link>
            <guid isPermaLink="false">https://medium.com/p/3ad825956cf2</guid>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[empathy]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[communication]]></category>
            <dc:creator><![CDATA[Iasonas Georgiadis]]></dc:creator>
            <pubDate>Fri, 31 May 2024 20:51:07 GMT</pubDate>
            <atom:updated>2025-07-07T10:47:42.997Z</atom:updated>
            <content:encoded><![CDATA[<h4>How being an empath can improve your everyday life as a person and designer.</h4><p>First things first, let me clarify that this is my first time writing an article, so please bear with me on this endeavor. I consider myself an empath, but I wasn’t always like that, at least not as much as I wanted to be. This seemed to change after I started working as a UX Designer.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3-rI6xsw781KVqAxU2NS7g.jpeg" /><figcaption>Image by <a href="https://www.interaction-design.org/literature/topics/empathize"><em>Interaction Design Foundation</em></a></figcaption></figure><p>After this statement, it’s time to introduce myself: my name is Iasonas and I am a<em> </em>Senior UX &amp; Product Designer. I am currently working at a multinational company, but before that, I worked in a fast-paced digital agency, starting as an intern.</p><p>You know, one of these places where time moves faster than usual, the weekends don’t last long (or don’t exist at all), and everything needs to get delivered ASAP.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/660/0*vkKHJxUm2dsd0p-q.jpg" /><figcaption>The Wolf of Wall Street (2013)</figcaption></figure><h3>How does empathy (not) feel like?</h3><p>Well, let me say that if my manager back then was an empath himself, he wouldn’t overload his intern with work that is not manageable. He would clearly understand that a just-graduated kid is not able to design dozens of advertising banners on his first day at work. He wouldn’t push him to start designing e-commerce websites the week after. And he wouldn’t be a manager at that agency.</p><p>Could this have been achieved differently? For sure. But this is how most of the agencies are. There is never time to lose, meaning there is never time for anyone to understand your feelings. I, however, had to understand the feelings of the users they were landing on the sports e-commerce website I was designing. They were in a hurry and they had a hobby: <em>running and buying running shoes</em>.</p><p>This was the first time I realized that helping others achieve their goals is something I love doing. Thus, I got more and more interested in UX design and started following the best practices I found through various research articles.</p><p>I felt I was caring for people I didn’t even know and I wanted to make their lives easier when they were using their laptops, phones, or tablets. This became my purpose:<strong> to make my designs accessible to a wide range of users, from the young to the elderly</strong>. And that was the moment when I dedicated myself to UX Design.</p><figure><img alt="A close image at the hands of someone browsing on his smartphone." src="https://cdn-images-1.medium.com/max/1024/0*rDINb-falhAGFanD" /><figcaption>Photo by <a href="https://unsplash.com/@elbwrits?utm_source=medium&amp;utm_medium=referral">Elly Brian</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>However, I must admit that this manager of mine pushed me to my limits, and helped in a way to reach my goals. He forced me to realize what I was lacking in my everyday life and what I was admiring the most: <strong>empathy</strong>.</p><blockquote>“Empathy: The ability to share someone else’s feelings or experiences by imagining what it would be like to be in that person’s situation.” — <a href="https://dictionary.cambridge.org/dictionary/english/empathy">Cambridge Dictionary</a></blockquote><h3>Empathy is understanding</h3><p>It is crucial for UX and Product Designers to understand their users and audience. We always try to balance our designs somewhere in between the business and the user&#39;s needs. Luckily, more and more companies nowadays are interested in investing into UX Research empowering their design processes, and moving to a more user-centric model.</p><blockquote>As a designer, I always aim to maintain this balance. Every company need a business plan for monetization but this means nothing if their audience is not able to use their products. And I make sure to communicate that to all stakeholders I get to talk with.</blockquote><p>Moving from that digital agency to my current company was a huge jump for me. The change in culture within the company made a significant difference in every aspect. Most importantly, I now had an <em>empathetic manager</em>. And this went as well as you would expect it to be.</p><figure><img alt="A happy guy stands with his hands open in the middle of a meadow." src="https://cdn-images-1.medium.com/max/1024/0*Xxv3LIGN_V0thTpk" /><figcaption>Photo by <a href="https://unsplash.com/@xangriffin?utm_source=medium&amp;utm_medium=referral">Xan Griffin</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I was now designing for a wider range of users and a different target audience. My work would now contribute to the scholarly world and scientific research, meaning I had to make sure to do my best to support this cause. I wanted to expand my understanding from people buying shoes and other everyday things to scientific authors, researchers, and publishers. I now had to empathize with another user group and do something I love doing: trying to understand people.</p><h3>What being empathetic means in UX Design</h3><p>Being empathetic will contribute to successful designs. First of all, empathy is the initial step in the <a href="https://www.interaction-design.org/literature/topics/design-thinking">design thinking process</a>. It allows designers to empathize with users’ needs and feelings and iterate their designs around points that matter.</p><p>I have witnessed many design iterations around a feature that users didn’t even care about and they never got to use. It looked cool, but it was not helpful. Being empathetic to the users, ensures you design and advocate for them. And this equals success for your product and business.</p><p>Additionally, it assists in doing better qualitative research. It allows you to create <a href="https://www.nngroup.com/articles/empathy-mapping/">empathy maps</a> and align with the rest of the team on a deep understanding of end users. Creating empathy maps not only helps you to understand the users better but to also create <a href="https://www.interaction-design.org/literature/topics/personas">user personas</a>.</p><figure><img alt="An empathy map split into 4 quadrants (Says, Thinks, Does, and Feels), with the user or persona in the middle." src="https://cdn-images-1.medium.com/max/922/0*99hVaj8vp5Hlzxkg.png" /><figcaption>Image by <a href="https://www.nngroup.com/articles/empathy-mapping/">NNgroup.com</a></figcaption></figure><blockquote>“Personas are fictional characters, which you create based upon your research in order to represent the different user types that might use your service, product, site, or brand in a similar way. Creating personas helps the designer to understand users’ needs, experiences, behaviors and goals.” — <a href="https://www.interaction-design.org/literature/topics/personas">Interaction Design Foundation</a></blockquote><p>By doing all this work, you give purpose to design. You put human behind the term ‘user’ and at the center; you design with a purpose, and you are transforming into a user-centric designer. <strong>What does it mean to be an empathetic designer?</strong> <strong>To effectively design for your target audience</strong>.</p><h3>Being empathetic helps you communicate better</h3><p>Over the last 11+ years, I have been working with various stakeholders such as designers, engineers, product and project managers. Communicating effectively was not always an easy task. Let me tell you that within a company with over 10.000 people scattered worldwide in different time zones, this becomes even more challenging.</p><figure><img alt="A laptop screen shows that a virtual meeting of many people is happening." src="https://cdn-images-1.medium.com/max/1024/0*TxSLey1n4MfrTs3A" /><figcaption>Photo by <a href="https://unsplash.com/@cwmonty?utm_source=medium&amp;utm_medium=referral">Chris Montgomery</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>This can be for various reasons, from different cultures to just having a bad day. Being empathetic in moments like these allows you to adapt to your listener’s needs or step back today suggesting to move a conversation or a meeting tomorrow.</p><blockquote>Coming up with solutions is always much appreciated. But you have to listen first before you understand the problem and jump in offering one.</blockquote><p>I had the chance to attend numerous meetings with cross-functional stakeholders while working on a project. On one of them, an engineer stated that <strong>the designs were not implementable</strong>, getting the project manager into a panic mode and suggesting designing everything from scratch. This would greatly increase the cost of the project and the delivery times would have to be re-estimated putting everything at risk.</p><p>I could clearly understand why a project manager would get panicked over something like this, but I couldn’t understand why the designs were not implementable. That was quite a statement. <strong>So, I asked for more information</strong>.</p><p>The engineer then clarified that they were not implementable <strong>within the estimated timeframe he had, </strong>meaning he needed more time. He was overwhelmed delivering for other projects at the same time, so he couldn’t do it so fast on his own. Now, we had the problem and thus we could start thinking of the solutions.</p><p>What I suggested was simplifying some design elements and making the implementation a bit easier at this point, by adding some improvements in a later phase. The project manager came up with the solution of adding more resources for a couple of weeks to assist the engineering part, and the project seemed back on track. Simple as that.</p><p>The problem had been heard, the situation had been assessed and some solutions were suggested. I know how it feels to struggle to deliver everything under strict deadlines while also trying for the best results, without having any time.</p><figure><img alt="Five people are sitting on a desk having a meeting in front of a monitor." src="https://cdn-images-1.medium.com/max/1024/0*IfeuxZS9zM8KHFZa" /><figcaption>Photo by <a href="https://unsplash.com/@jasongoodman_youxventures?utm_source=medium&amp;utm_medium=referral">Jason Goodman</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>I always appreciated when my colleagues valued my input, listened to my problems, and tried to help. I want to do the same for them; by being an empath who keeps learning how to communicate better.</p><h3>Empathy can help bonding within teams</h3><p>I have experienced empathy among colleagues and seen its benefits in shaping bonds and work effectiveness through understanding and respect for each other.</p><p>As mentioned before, I was lucky enough to get under an empathetic manager. In the teams I get to work with, I try to do the same. Not all approaches are effective in the same way for all people. I foster collaboration through open discussion while listening to the actual problems.</p><blockquote>Stepping back and admitting you don’t understand something leaves room for dialogue. And this is valuable for a team.</blockquote><p>I didn’t start as a Senior UX Designer, thus I know how it feels to be a Junior. It’s easy to get overwhelmed with information that more experienced people might digest more easily, and is hard not to try to hide your ignorance. This is the point where you need someone empathetic, to ask him questions and learn through your mistakes.</p><p>Additionally, after all these years I now understand how important is to communicate effectively with your colleagues. Working with developers grew my interest in learning the fundamentals of HTML5, CSS3, and JavaScript, so I can communicate with them better. Lastly, working closely with product and project managers made me realize how hard is to try to keep a project on track.</p><p>This world is not full of empaths. And this is fine. But, being one will definitely help you understand the world better, and this is a huge asset for you as a UX and Product designer and a person in general.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1000/0*QaGMx6MSGoz8z88r" /><figcaption>Good Will Hunting (1997)</figcaption></figure><p>It’s been clear to me now that a team consisting of empaths can not fail easily. And even if it does, the support and the open dialogue among its team members will help it recover quickly.</p><p>After all, we all have our bad days. Wouldn’t be easier if someone tried to make that bad day of ours a little better?</p><h3>Thanks for reading!</h3><p>👋 I’m Iasonas, a Lead Product Designer, currently exploring how better tooling can bring design and development closer together. I write about design tools, AI-powered prototyping, and the intersection of UX and engineering.</p><p>🔗 Feel free to connect with me on <a href="https://www.linkedin.com/in/iasonasgeorgiadis/">LinkedIn</a> or check more of my work at <a href="https://iasonasgeorgiadis.com/">iasonasgeorgiadis.com</a>.</p><p>♻️ If you enjoyed this article, feel free to follow or reach out. I’m always up for a conversation over coffee about good design and better handoffs!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3ad825956cf2" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/empathy-in-ux-design-and-effective-communication-3ad825956cf2">Empathy in UX design and effective communication</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>
    </channel>
</rss>