<?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 ajayp on Medium]]></title>
        <description><![CDATA[Stories by ajayp on Medium]]></description>
        <link>https://medium.com/@prabhu.ajay?source=rss-4515bae20013------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*VioScpWzLKaeLbDD</url>
            <title>Stories by ajayp on Medium</title>
            <link>https://medium.com/@prabhu.ajay?source=rss-4515bae20013------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 23:34:00 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@prabhu.ajay/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[Generating Editable draw.io Diagrams in VS Code with MCP]]></title>
            <link>https://medium.com/@prabhu.ajay/generating-editable-draw-io-diagrams-in-vs-code-with-mcp-9b3e331d57e4?source=rss-4515bae20013------2</link>
            <guid isPermaLink="false">https://medium.com/p/9b3e331d57e4</guid>
            <category><![CDATA[uml-diagrams]]></category>
            <category><![CDATA[uml]]></category>
            <category><![CDATA[coding-agents]]></category>
            <category><![CDATA[mermaid]]></category>
            <category><![CDATA[draw-io]]></category>
            <dc:creator><![CDATA[ajayp]]></dc:creator>
            <pubDate>Fri, 15 May 2026 04:23:59 GMT</pubDate>
            <atom:updated>2026-05-15T04:23:59.015Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A watercolor sketch of a developer sitting with a laptop working on VS Code and generating a draw.io  UML diagram using coding agent." src="https://cdn-images-1.medium.com/max/1024/1*LGWJtfa68UactNk_kjsBpg.png" /></figure><p>Technical diagrams can be generated directly inside VS Code using the draw.io MCP together with GitHub Copilot Chat. This setup supports creation of flowcharts, architecture diagrams, UML models, and other technical diagrams as editable `.drawio` files.</p><p>The generated files remain compatible with draw.io tooling and can be edited directly in VS Code or the draw.io desktop application.</p><p><strong>Configuring draw.io MCP</strong></p><p>The draw.io MCP server can be configured using the following MCP server definition:</p><pre>{<br>  &quot;mcpServers&quot;: {<br>    &quot;drawio&quot;: {<br>      &quot;command&quot;: &quot;npx&quot;,<br>      &quot;args&quot;: [&quot;-y&quot;, &quot;@drawio/mcp&quot;]<br>    }<br>  }<br>}</pre><p>This launches the unofficial draw.io MCP server through `npx`.</p><p><strong>Example Prompts</strong></p><p>The MCP server supports multiple diagram categories through natural language prompts. Following examples show how to generate a UML class diagram…</p><pre>Generate a UML class model for a shipment tracking system.</pre><p>… or a CI/CD Deployment flowchart.</p><pre>Create a CI/CD deployment flowchart for a monorepo application named &quot;hello-world&quot;.</pre><p><strong>Observations</strong></p><p><strong>Initial generation usually captures core structure</strong></p><p>In UML generation scenarios, the first generated version typically included the expected entities and primary relationships. The output provided a usable starting point for refinement.</p><p>Generated files were typically created within a few seconds, though larger diagrams occasionally required regeneration to fix layout issues.</p><p><strong>Follow-up prompts improve results</strong></p><p>Iterative prompting resulted in incremental improvements to layout and structure. Additional prompts were needed for correcting relationships, renaming entities, and reorganizing layouts. Users can iterate with the LLM agent to refine the generated diagram.</p><p><strong>File management is flexible</strong></p><p>The generated output is saved locally as a standard `.drawio` file, allowing direct editing in draw.io-compatible tools. These files could be opened immediately in the VS Code draw.io extension without additional conversion steps.</p><p><strong>Connector routing in complex diagrams</strong></p><p>As diagrams become larger, connector routing quality decreases. Common issues include:</p><ul><li>Lines overlapping shapes</li><li>Crossed connectors</li><li>Dense layouts reducing readability</li></ul><p>Orthogonal connector routing is inconsistent in larger diagrams and often requires manual cleanup.</p><p><strong>That one “XML validity” error…</strong></p><p>In one observed case, a generated `.drawio` file became invalid because a label contained an unescaped `&amp;` character, resulting in malformed XML. When the coding agent was prompted to investigate, it quickly identified the issue, fixed the label, and we were good to go.</p><p><strong>Comparison with Mermaid Diagrams</strong></p><p>Mermaid diagrams integrate cleanly with source code, prompts, and version control workflows because the diagram definitions are plain text. This makes them easier to diff, review, and embed directly inside documentation or LLM prompts.</p><p>draw.io generation is more useful when the output needs to be visually editable immediately, particularly for architecture diagrams, workflow charts, and presentation-oriented documentation.</p><p><strong>Summary</strong></p><p>draw.io MCP enables generation of editable diagrams directly inside VS Code, including UML models, workflows, and architecture sketches. Larger diagrams still require manual cleanup around connector routing and layout organisation.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9b3e331d57e4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Code Designs That Stay in Sync: Why Mermaid + Coding Agents Work So Well]]></title>
            <link>https://medium.com/@prabhu.ajay/code-designs-that-stay-in-sync-why-mermaid-coding-agents-work-so-well-4fea5d3869c4?source=rss-4515bae20013------2</link>
            <guid isPermaLink="false">https://medium.com/p/4fea5d3869c4</guid>
            <category><![CDATA[future-of-ai-in-coding]]></category>
            <category><![CDATA[ai-coding-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[ajayp]]></dc:creator>
            <pubDate>Fri, 12 Sep 2025 09:13:58 GMT</pubDate>
            <atom:updated>2025-09-12T09:13:58.870Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PIPxHoGxsFUck1RvQpLfdQ.png" /></figure><p>Software moves fast, but design diagrams rarely keep up.</p><p>Teams spend hours on architecture slides before coding starts, but within weeks they’re obsolete. Features evolve, APIs shift, and debt creeps in quietly. The result? Onboarding slows, reviews lack context, and impact assessments turn into guesswork.</p><p>But what if diagrams weren’t static artifacts at all? What if they lived <strong>inside the codebase</strong> — version-controlled, reviewable, and auto-updated by coding agents?</p><p>That’s where <strong>Mermaid</strong> comes in. So how does it work in practice? Let’s start with the basics.</p><h4><strong>Mermaid in a Nutshell</strong></h4><p>Mermaid is a text-based diagramming language. Instead of drawing shapes in a GUI, you describe diagrams in a Markdown-like syntax. A few lines of text can generate:</p><ul><li>Flowcharts</li><li>Sequence diagrams</li><li>ER diagrams</li><li>State diagrams</li><li>User journey maps</li></ul><p>These render automatically in GitHub READMEs, docs, and developer portals. Because it’s <strong>just text</strong>, you can commit diagrams into the repo, track changes over time, and treat them like any other piece of code.</p><p>It flips the script: instead of diagrams being static illustrations, they become <strong>living documentation</strong>.</p><h4>Why Mermaid Pairs Seamlessly With Coding Agents</h4><p>Coding agents thrive in environments where context is <strong>machine-readable and updatable</strong>. That’s exactly what Mermaid provides.</p><p>Here’s how the synergy plays out:</p><ol><li><strong>Generation from Code</strong><br>IDE based coding agents (such as GitHub CoPilot in VS Code) can parse a codebase and output Mermaid diagrams — API call flows, service interactions, database schemas — with minimal human effort. No drag-and-drop, no wasted effort.</li><li><strong>Continuous Updates</strong><br>As code evolves, developers can use IDE coding agents to regenerate diagrams. This ensures architecture diagrams in your docs or pull requests always reflect reality, not last month’s assumptions.</li><li><strong>In Pull Requests</strong><br>During reviews, GitHub Actions and Copilot can generate “before vs after” Mermaid diagrams to highlight design changes. Developers instantly see the <strong>impact of a change</strong>, not just the diff.</li><li><strong>Version-Controlled Diagrams</strong><br>Because Mermaid is text, diffs show up in Git just like code. This makes it trivial for an agent to surface <em>what part of a diagram changed</em> during a refactor.</li><li><strong>Impact Assessment</strong><br>With Mermaid diagrams living alongside code, agents can show ripple effects visually. Say you rename a field in AuthService. A Mermaid dependency graph highlights three downstream microservices and the user database migration that rely on it. Developers don’t have to piece this together manually; the diagram becomes a <strong>decision-support tool</strong>.</li></ol><p>Here’s a simple example of what an agent might generate from a login flow. LLMs read the text, humans see the picture!</p><pre>sequenceDiagram<br>  participant User as User<br>  participant Frontend as Frontend<br>  participant AuthService as AuthService<br>  participant APIService as APIService<br>  participant Database as Database<br><br>  autonumber<br>  User -&gt;&gt; Frontend: Login Request<br>  Frontend -&gt;&gt; AuthService: Validate Credentials<br>  AuthService --&gt;&gt; Frontend: Token<br>  Frontend -&gt;&gt; APIService: Call API with Token<br>  APIService -&gt;&gt; Database: Query Data<br>  Database --&gt;&gt; APIService: Return Results<br>  APIService --&gt;&gt; Frontend: Response<br>  Frontend --&gt;&gt; User: Render Data</pre><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1_DrlAkrcXIlCrIQu-Ep2Q.png" /><figcaption>Rendered Mermaid Sequence Diagram</figcaption></figure><p>Put simply: <strong>Mermaid speaks the same language as coding agents — text.</strong> That’s the bridge.</p><h4>Developer Advantages Beyond Automation</h4><p>For developers, the benefits are immediate:</p><ul><li><strong>Faster design iteration</strong> → Sketch diagrams in code during early design, refine later.</li><li><strong>Reduced cognitive load</strong> → Don’t juggle external tools; stay in repo + IDE.</li><li><strong>Improved reviews</strong> → PR reviewers see both code and updated design context.</li><li><strong>Clearer impact analysis</strong> → Changes ripple visually, aiding risk assessment.</li><li><strong>Better onboarding</strong> → New teammates asks Copilot for the login flow and gets the diagram above in seconds.</li></ul><p>Instead of design docs being a one-time activity, Mermaid + coding agents make them part of the living system.</p><h4>Closing Thoughts</h4><p>The future of design isn’t static slides. It’s design <strong>diagrams that evolve at the speed of code</strong> — generated, reviewed, and trusted. With Mermaid + coding agents, that future isn’t a vision. It’s here.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4fea5d3869c4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Dimensions of AI-Augmented Coding: Mapping the Future of Software Engineering]]></title>
            <link>https://medium.com/@prabhu.ajay/the-dimensions-of-ai-augmented-coding-mapping-the-future-of-software-engineering-473d06e29829?source=rss-4515bae20013------2</link>
            <guid isPermaLink="false">https://medium.com/p/473d06e29829</guid>
            <category><![CDATA[ai-coding-assistant]]></category>
            <category><![CDATA[coding-agents]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[ai-coding-agent]]></category>
            <category><![CDATA[human-ai-collaboration]]></category>
            <dc:creator><![CDATA[ajayp]]></dc:creator>
            <pubDate>Thu, 28 Aug 2025 03:55:59 GMT</pubDate>
            <atom:updated>2025-08-28T03:55:59.569Z</atom:updated>
            <content:encoded><![CDATA[<p>In 2025, a single developer shipped a production-ready SaaS product in two weeks — 90% of the code was written by an AI agent.</p><p>That wasn’t a gimmick. It was a signal: <strong>software engineering is no longer just a human-centered craft; it’s becoming a human–AI symphony.</strong></p><p>The narrative that we’re on a single track toward “fully autonomous software development” misses the point. AI in coding isn’t a straight road — it’s a <strong>multi-dimensional shift</strong>. Different teams, industries, and projects are adopting capabilities along <strong>several parallel dimensions</strong>, each evolving at its own pace.</p><p>Let’s map these dimensions and explore what they mean for developers, product companies, and IT services firms.</p><h3>Dimension 1: AI-driven code completion</h3><p>The most mature and widespread dimension, code completion has become table stakes for modern development. Tools like <strong>GitHub Copilot</strong>, <strong>Tabnine</strong>, and <strong>Amazon CodeWhisperer</strong> offer context-aware suggestions that turn repetitive coding into a near-instant process.</p><p>This dimension has already shifted the baseline for productivity. Typing code character by character is no longer the measure of skill; <strong>expressing intent to AI effectively is</strong>.</p><p><strong>Maturity:</strong> Mainstream, foundational.<br><strong>Impact:</strong> A universal boost in developer velocity; a non-negotiable baseline for competitive teams.</p><h3>Dimension 2: Contextual pair programming agents</h3><p>Here, AI stops being a reactive helper and becomes an active collaborator. Local IDE-based agents like <strong>Cursor</strong>, <strong>JetBrains AI Assistant</strong>, and <strong>Copilot Chat</strong> read entire codebases, debug in context, and generate tests.</p><p>This changes coding from “a series of keystrokes” to <strong>a guided dialogue with an intelligent partner</strong> — one that remembers project structure, coding style, and edge cases.</p><p><strong>Maturity:</strong> Rapidly maturing; quickly becoming the norm in engineering workflows.<br><strong>Impact:</strong> Reduces cognitive load, accelerates debugging, and shifts developer focus to architecture and design.</p><h3>Dimension 3: Cloud-scale engineering agents</h3><p>When AI agents move beyond local compute, they become organizational assets. Cloud-based coding agents like <strong>Devin</strong> or Open-SWE by <strong>LangChain</strong> and <strong>GitHub Copilot Coding Agent </strong>can analyze massive, multi-repository systems, triage issues, and even raise pull requests autonomously.</p><p>This dimension unlocks <strong>AI as a scalable teammate</strong> — one that sees the big picture, not just your file or function.</p><p><strong>Maturity:</strong> Early adoption, high strategic potential.<br><strong>Impact:</strong> Teams gain leverage to manage complexity at scale, not just speed up individual productivity.</p><h3>Dimension 4: Proactive, observability-driven agents</h3><p>This is where AI begins acting before humans ask. By ingesting live logs, telemetry, and performance data, AI agents proactively detect and fix issues, turning maintenance into a <strong>continuous, self-healing process</strong>.</p><p>Early experiments integrate observability platforms like <strong>Datadog</strong> and <strong>New Relic</strong> with generative AI, creating systems that diagnose and repair themselves at runtime.</p><p><strong>Maturity:</strong> Experimental, bleeding-edge.<br><strong>Impact:</strong> Reduces downtime and incident response time dramatically; transforms DevOps into <strong>AI-ops</strong>.</p><h3>Dimension 5: Fully autonomous development systems</h3><p>The aspirational end of the curve: AI systems that can design, code, deploy, and maintain software with minimal human intervention.</p><p>While this remains a futuristic vision, we already see glimpses — AI models that design full features, orchestrate tests, and manage releases. The challenge is building trust, reliability, and governance — ensuring these systems remain auditable, compliant, and accountable even as autonomy increases.</p><p><strong>Maturity:</strong> Visionary; experimental, but early glimpses are emerging.<br><strong>Impact:</strong> Will redefine engineering roles, workflows, and organizational structures.</p><h3>No, you don’t have to climb a ladder</h3><p>AI’s role in coding is expanding along <strong>multiple axes at once</strong>. These five dimensions aren’t steps to climb — they’re <strong>capabilities to harness</strong>. A team might embrace cloud-scale agents early while still experimenting with observability-driven automation. Another might lean heavily on local AI pair programmers while preparing for future autonomy.</p><p>Organisations and teams should:</p><ul><li><strong>Adopt selectively:</strong> Focus on capabilities that solve today’s problems while staying ready for tomorrow’s.</li><li><strong>Experiment in parallel:</strong> Innovation doesn’t follow a straight line; breakthroughs often happen where dimensions intersect.</li><li><strong>Invest strategically:</strong> Treat AI as a portfolio of strengths rather than a single “end goal” to reach.</li></ul><p>This approach turns AI from a buzzword into a <strong>strategic framework for engineering maturity</strong>. It’s not about a finish line; it’s about leveraging AI coding agents in ways that make your team faster, smarter, and more competitive.</p><h3>Implications for the industry</h3><ol><li><strong>For Developers: </strong>The value of a developer is shifting from “how fast you write code” to <strong>how well you orchestrate intelligent systems</strong>. The best engineers of tomorrow will be AI-native thinkers.</li><li><strong>For Product Companies: </strong>AI will compress development cycles dramatically. Smaller teams can deliver enterprise-grade products. Competitive advantage will hinge on how deeply AI is embedded in product engineering.</li><li><strong>For IT Services Firms: </strong>Delivery models must be redefined. Instead of scaling headcount, firms will scale <strong>AI-augmented workflows</strong>, offering agility and innovation as differentiators.</li></ol><h3>Lead in the new dimensions</h3><p>AI is no longer optional; it’s infrastructure. Teams and companies have a choice:</p><ul><li><strong>Treat AI as a novelty</strong> and risk obsolescence, or</li><li><strong>Embrace it as a strategic partner</strong> and lead this transformation.</li></ul><p>The future of software engineering won’t be defined by who writes the most code but by <strong>who best orchestrates intelligent systems to build it</strong>.</p><p>This isn’t just evolution; it’s a revolution. And it’s happening faster than most expect.</p><figure><img alt="Developers and AI coding agents — together and ready to conquer bigger coding challenges." src="https://cdn-images-1.medium.com/max/1024/1*8vxzs2OAdJsVicxt36gVVA.png" /><figcaption>“Together, ready to conquer coding challenges.”</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=473d06e29829" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Experiment to Conviction: Why I’m Betting Big on AI]]></title>
            <link>https://medium.com/@prabhu.ajay/from-experiment-to-conviction-why-im-betting-big-on-ai-0989848d55af?source=rss-4515bae20013------2</link>
            <guid isPermaLink="false">https://medium.com/p/0989848d55af</guid>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[future-of-work]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[technology-trends]]></category>
            <dc:creator><![CDATA[ajayp]]></dc:creator>
            <pubDate>Tue, 12 Aug 2025 02:52:18 GMT</pubDate>
            <atom:updated>2025-08-14T03:54:32.726Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6ofvR1aDmj2v6_dlDohrwA.png" /><figcaption>Co-Pilot boosts developer productivity!</figcaption></figure><h4>AI is moving faster than ever — here’s why I’m accelerating, and why you should too</h4><h4>It began with curiosity…</h4><p>I still remember the first time I used GPT-3.5 in early 2023. I gave it a vague prompt, and it responded with well-structured text that read like a human had written it. A few months later, I watched it generate working code from a simple description. That’s when it hit me — this wasn’t just another wave of tech hype. AI had quietly crossed over from research labs to real-world impact.</p><p>Machine learning technology has always fascinated me, from early use cases like email spam detection, sentiment analysis and facial recognition, but this was different. For the first time, AI wasn’t just for big tech or specialised teams. It was ready for everyone.</p><p>Over the past few years, AI has moved from a novelty to a dependable collaborator. My experiments with ChatGPT, creating GPTs on Hugging Face, Ollama, and GitHub Copilot reinforced the power of AI. Then came wave after wave of breakthroughs — the rise of Perplexity, increasingly capable models like DALL·E for image generation, voice interfaces to the LLMs, and models that could reason. Holding a natural conversation with an AI model, brainstorming ideas, refining them in real time, and then seeing it instantly turn those ideas into working prototypes wasn’t science fiction anymore.</p><p>The technology is no longer experimental — it’s an essential creative partner and is becoming a core skill, like Excel for analysts or Git for developers. The pace of progress is rapid, and the gap between what AI can do today and what it will do tomorrow is shrinking fast. There were only two choices — watch from the sidelines or actively invest in learning, building, and applying AI in my work. I chose the latter.</p><h4><strong>When curiosity turned into commitment</strong></h4><p>The journey has been a mix of daily practice, structured learning, and constant curiosity.</p><p>In day-to-day work, tools like Copilot, ChatGPT, and Perplexity are part of the routine — not just to get things done faster, but to test where they add the most value. Over time, this has revealed clear patterns: the problems they solve well, where they fall short, and how they can work together for better results.</p><p>To build a stronger foundation, I’ve completed professional AI and ML courses. Structured learning has helped me understand what happens under the hood — how models are trained, how they make predictions, and the limits of their capabilities.</p><p>Staying updated is equally important. Following AI news, research papers, and platforms like Medium keeps me aware of new developments, making it easier to spot opportunities before they become mainstream.</p><p>Hands-on work ties it all together. I regularly pick up new AI projects, replicate them locally, and experiment — turning theory into practical skills while building a library of working solutions.</p><p>And then there’s GitHub Copilot, which I use extensively. This has helped me understand both its efficiency gains and its blind spots, with the goal of integrating AI so seamlessly into the development process that it feels like a natural extension of the team.</p><h4><strong>Sitting out is no longer an option</strong></h4><p>That first experience with GPT-3.5 showed how quickly AI is being democratised. Since then, its capabilities have accelerated, moving from experimental to essential in record time. We’re in the middle of a once-in-a-lifetime transformation, and moments like this don’t wait — you either help shape the change or adapt to decisions made by others.</p><p>With two decades in software development, the transition into AI felt like a logical next step — an opportunity to apply years of building software to a technology that’s redefining what’s possible.</p><p>Here’s what that decision looks like in practice: making AI tools part of daily work, investing in structured learning, experimenting with projects, and staying ahead of industry trends. Each step isn’t just about keeping pace — it’s about positioning to lead in an AI-powered world.</p><h4><strong>The future won’t wait, and neither should we</strong></h4><p>AI isn’t something that’s coming, it’s already here, changing how we work, build, and compete. From code generation to customer service, AI is driving real productivity gains today. Companies using AI are shipping faster, solving problems smarter, and making better decisions. This isn’t just about keeping up — it’s about staying in the game.</p><p>Teams that ignore AI risk falling behind, becoming slower, costlier, and less relevant. The message is simple: adopt AI where it adds value, learn its strengths and limits, and build it into your way of working. In today’s world, adapting to AI isn’t optional — it’s survival.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0989848d55af" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Figma to Functional UI: How Figma Dev MCP Turned My Design Curiosity into Code]]></title>
            <link>https://medium.com/@prabhu.ajay/from-figma-to-functional-ui-how-figma-dev-mcp-turned-my-design-curiosity-into-code-eeeed0b6adf3?source=rss-4515bae20013------2</link>
            <guid isPermaLink="false">https://medium.com/p/eeeed0b6adf3</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[ai-coding-agent]]></category>
            <category><![CDATA[design-to-code]]></category>
            <category><![CDATA[model-context-protocol]]></category>
            <dc:creator><![CDATA[ajayp]]></dc:creator>
            <pubDate>Sat, 02 Aug 2025 05:31:28 GMT</pubDate>
            <atom:updated>2025-08-02T05:31:28.890Z</atom:updated>
            <content:encoded><![CDATA[<p>Curious about how AI can turn your Figma designs into real UI code? I explored the integration between <strong>Figma’s Dev Mode MCP Server</strong> and <strong>GitHub Copilot in VS Code</strong> — and was able to generate React + Tailwind components with surprising accuracy, no frontend expertise required. This workflow shows how AI doesn’t just assist — it accelerates.</p><h4>Background</h4><p>I’m not a UI developer. In fact, most of my day-to-day work doesn’t involve writing front-end code. But out of academic curiosity, I recently tried the new integration between <strong>Figma’s Dev Mode MCP Server</strong> and <strong>GitHub Copilot</strong> in <strong>VS Code</strong> — and to my surprise, I was able to generate functional React + Tailwind UI components that perfectly matched the original Figma design.</p><p>With just a few prompts, Copilot turned static designs into clean, responsive code. No CSS fiddling. No trial and error. Just working UI, fast.</p><p>In this post, I’ll walk you through what this setup is, how to enable it, and why it’s a game-changer for anyone working with design systems.</p><h4>Here’s How It Works</h4><p><strong>Figma</strong>, through its new <strong>Dev Mode MCP Server</strong>, exposes structured design data — like layout, component names, and styles — in a machine-readable format. This design context is securely made available to <strong>GitHub Copilot</strong>, which uses it to generate relevant, production-grade code.</p><p><strong>VS Code</strong> acts as the bridge: it connects to the MCP Server, brings in the design context, and lets you interact with Copilot right inside your editor. The result? You can prompt Copilot to generate UI code that directly reflects what’s in your Figma file — layout, spacing, typography, and all.</p><p>This all hinges on something called <strong>MCP</strong> — short for <strong>Model Context Protocol</strong>. Think of it as a secure, standardized way for LLMs to get accessto external sources of context — in this case, your design files in Figma, via a client — in this case, your VS Code (or any other IDE that supports MCP).</p><p>When Dev Mode is enabled, Figma’s MCP Server exposes the design’s structure, hierarchy, and metadata in a format Copilot can understand. It’s not just seeing rectangles and colors — it knows what’s a button, what’s a heading, and how elements are grouped or spaced. This gives Copilot the design intelligence it needs to write relevant, responsive code with minimal input.</p><h4><strong>What You Need to Try This</strong></h4><p>Before you jump in, here’s what you’ll need to set up this workflow:</p><ul><li><strong>Figma Enterprise seat</strong> — The Dev Mode MCP Server is only available to Enterprise users.</li><li><strong>GitHub Copilot Pro or Enterprise license</strong> — Required for MCP integration support.</li><li><strong>Visual Studio Code</strong> — Where you’ll use Copilot Chat and interact with the Figma context.</li><li><strong>Figma desktop app installed</strong> — The Dev Mode MCP Server runs locally through the Figma desktop app.</li><li><strong>MCP Server enabled in Figma preferences</strong> — Open Figma → Preferences → Enable “Dev Mode MCP Server”.</li></ul><p>Once these are in place, you’ll be ready to connect your design to your code editor and start generating UI components instantly.</p><h4><strong>Setting Up in VS Code</strong></h4><p>If you already use <strong>GitHub Copilot Chat</strong> in VS Code, you’re nearly there. Just enable support for <strong>MCP Servers</strong> and configure the connection to Figma’s local MCP Server (running at <a href="http://127.0.0.1:3845/sse)."><strong>http://127.0.0.1:3845/sse</strong>).</a></p><p>Once connected, Copilot will treat the MCP server as a data tool and use your shared Figma context to generate UI code.</p><h4><strong>The Workflow: From Design to Code</strong></h4><p>Once everything is connected — Figma’s Dev Mode MCP Server is running, and VS Code is ready — the workflow is surprisingly smooth.</p><ol><li>Open your Figma design in Dev Mode.</li><li>Select the relevant frame or component and choose <strong>Copy/Paste As → Copy Link to Selection</strong>.</li><li>Switch to VS Code and describe what you want Copilot to generate.</li></ol><p>A typical prompt in Copilot Chat might look like:</p><blockquote>Generate a React component using Tailwind CSS for the component at URL [paste Figma link here].</blockquote><p>Here’s what happens under the hood:</p><ul><li>Copilot first invokes the <strong>get_code</strong> tool to fetch code metadata and styles from Figma.</li><li>Then it invokes the <strong>get_image</strong> tool to fetch a snapshot of the component.</li><li>Based on this context, Copilot generates JSX + Tailwind CSS matching the design.</li></ul><p>You can continue iterating through prompts — if something doesn’t render quite right, just ask Copilot to fix it.</p><h4>My Experience</h4><p>I started with an empty workspace — no boilerplate, no existing components. Just VS Code, Copilot, and a shared Figma design.</p><p>Copilot didn’t just create isolated elements — it generated full, functional components with layout and styling, often using sensible structure and clean utility classes. Even without a design system or framework in place, the results were impressively close to production-ready.</p><p>I haven’t yet tried this in a live codebase or design system, but for a greenfield prototype or quick UI scaffolding, it worked far better than I expected.</p><h4><strong>Why This Is A Gamechanger</strong></h4><p>Even with limited front-end experience, I was able to go from Figma design to working React components in minutes. And that’s exactly why this workflow feels like a breakthrough.</p><ul><li>⚡ <strong>Speeds up frontend development</strong><br> Skip the manual pixel-to-code process — let Copilot translate your designs instantly.</li><li>🎯 <strong>Improves design-to-code accuracy</strong><br> Because Copilot reads structured design data directly, it gets layouts and styles right — no more guessing margins or paddings.</li><li>💬 <strong>Fosters seamless collaboration across product teams</strong><br> Designers stay in Figma, developers stay in VS Code, and AI helps keep everyone in sync — reducing bottlenecks and miscommunication.</li><li>🤖 <strong>Uses AI in a real, tangible workflow</strong><br> This isn’t a demo — it’s a usable feature that saves time today.</li></ul><p>It’s early days, but this feels like a glimpse into the future of collaborative product building — where handoff becomes optional and iteration becomes instant.</p><h4><strong>Final Thoughts</strong></h4><p>I didn’t expect to enjoy this as much as I did. What started as a curiosity-driven experiment turned into a surprisingly productive workflow — one that blurred the lines between design and development in the best way possible.</p><p>While there’s still room to explore how this fits into larger codebases or complex design systems, the early results are promising. If you’re working with Figma and already using GitHub Copilot, this integration is absolutely worth exploring — especially if you’ve ever felt stuck translating mockups into code.</p><p>It’s another example of how AI doesn’t just assist — it accelerates what’s possible.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*79zhJZgzVkYUjJ5NtOJmsw.png" /><figcaption>All in an hours work!</figcaption></figure><p><strong>References &amp; Resources</strong></p><ul><li><a href="https://help.figma.com/hc/en-us/articles/32132100833559-Guide-to-the-Dev-Mode-MCP-Server">Figma Dev Mode MCP Server Documentation</a></li><li><a href="https://code.visualstudio.com/docs/copilot/chat/mcp-servers">VS Code Copilot Chat + MCP Setup</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eeeed0b6adf3" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>