<?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[designengineer.pro - Medium]]></title>
        <description><![CDATA[Guides for designers learning to code, ship apps and become design engineers. From the authors of The Craft of Design Engineering. designengineer.pro - Medium]]></description>
        <link>https://medium.com/designengineer-pro?source=rss----d89aa3149cb7---4</link>
        <image>
            <url>https://cdn-images-1.medium.com/proxy/1*TGH72Nnw24QL3iV9IOm4VA.png</url>
            <title>designengineer.pro - Medium</title>
            <link>https://medium.com/designengineer-pro?source=rss----d89aa3149cb7---4</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 20:40:31 GMT</lastBuildDate>
        <atom:link href="https://medium.com/feed/designengineer-pro" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Your First Pull Request as a Designer: A Step-by-Step Playbook]]></title>
            <link>https://medium.com/designengineer-pro/your-first-pull-request-as-a-designer-a-step-by-step-playbook-060787a57754?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/060787a57754</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[github]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 17:54:19 GMT</pubDate>
            <atom:updated>2026-11-06T17:54:19.696Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*gu-CTEypT9az-bkF" /><figcaption>Photo by <a href="https://unsplash.com/@marvelous?utm_source=medium&amp;utm_medium=referral">Marvin Meyer</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>There is a specific moment when a designer stops being someone who files tickets and becomes someone who ships: the first pull request that gets merged into a real product. It is usually small. A spacing fix, a copy change, a focus state that was never built. It also changes how engineering sees you, permanently.</p><p>Here is how to make that first one go well.</p><h3>1. Pick something boring</h3><p>Your first PR should not be a redesign. Pick a change you could describe in one sentence and verify by looking at one screen: wrong padding on a card, a typo, a missing hover state, an icon with a tiny tap target. Boring changes get merged. Ambitious first PRs sit in review for weeks.</p><h3>2. Ask where the code lives</h3><p>Before you touch anything, ask an engineer two questions: how do I run this locally, and where would you look for this component? Five minutes of their time saves you an afternoon of searching. Most teams are delighted to be asked.</p><h3>3. Branch, change, run</h3><p>Create a branch named after the change, make the edit (with Cursor or Claude Code if you like), and then actually run the app and look at it. Not the code. The screen. Check it at mobile width, in dark mode if you have one, and with keyboard focus.</p><h3>4. Keep the diff tiny</h3><p>AI tools love to be helpful and will often “tidy up” files you did not ask them to touch. Before you commit, read the diff. If it changed forty lines to fix a margin, revert the extras. A reviewer can approve a five-line diff in two minutes. A hundred-line diff from a designer gets read very carefully.</p><h3>5. Write the description like a designer</h3><p>This is where you have an edge. A great PR description has:</p><ul><li><strong>What changed</strong> in one or two sentences.</li><li><strong>Why</strong>, with a link to the ticket or a user problem.</li><li><strong>Before and after screenshots</strong>. Engineers rarely include these. You always should.</li><li><strong>How to check it</strong>: which screen, which state, which width.</li></ul><h3>6. Treat review as a to-do list</h3><p>Comments are not criticism, they are tasks. Answer each one, either with a fix or a short reason. If a reviewer asks for a change you disagree with, explain the design reasoning with evidence, then accept the decision gracefully. How you handle review is what earns you the next PR.</p><h3>7. Watch it ship</h3><p>When it merges, check the change in staging or production. Close the loop with whoever reported the issue. Congratulations: you did not hand off intent and hope it landed. You shipped it.</p><h3>From one PR to a habit</h3><p>The first PR is the hardest because everything is unfamiliar: the repo, the tooling, the review culture. The <strong>designengineer.pro course</strong> takes that unfamiliarity away by having you ship two complete apps first, a React Native mobile app in Module 03 and a native macOS app in Module 04, before Module 05 shows you how to be a top contributor in your organisation’s production codebase without breaking it.</p><p>You also get two 1:1 calls with Sunal and Shashi to work through your own situation, plus lifetime access and a 7-day refund. <a href="https://designengineer.pro/">Join the course at designengineer.pro →</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=060787a57754" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/your-first-pull-request-as-a-designer-a-step-by-step-playbook-060787a57754">Your First Pull Request as a Designer: A Step-by-Step Playbook</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Accessibility You Can Actually Ship: A Practical Checklist for Design Engineers]]></title>
            <link>https://medium.com/designengineer-pro/accessibility-you-can-actually-ship-a-practical-checklist-for-design-engineers-717aeefcbc63?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/717aeefcbc63</guid>
            <category><![CDATA[web-accessibility]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[accessibility]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[inclusive-design]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 17:52:56 GMT</pubDate>
            <atom:updated>2026-11-06T17:52:56.654Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*bNN1FERWFOCSlaUl" /><figcaption>Photo by <a href="https://unsplash.com/@haberdoedas?utm_source=medium&amp;utm_medium=referral">Haberdoedas</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Accessibility is the thing that never appears in a Figma file. Contrast does, sometimes. But focus order, keyboard behaviour, screen reader labels and what happens when someone zooms to 200%: none of it lives in the design. It lives in the code, which means it is decided by whoever writes the code. If that is you now, it is your job.</p><p>The good news: most real-world accessibility failures come from a short list of mistakes. Fix these and you are ahead of most products.</p><h3>1. Use the real element</h3><p>A div with a click handler looks like a button and behaves like nothing. A &lt;button&gt; gets keyboard support, focus and a role for free. Same for links, inputs, checkboxes and headings. When an AI tool generates a clickable div, change it. This single habit fixes a huge share of problems.</p><h3>2. Never remove the focus ring without replacing it</h3><p>outline: none is one of the most common lines in CSS and one of the most damaging. Keyboard users rely on focus to know where they are. Style it to match your brand with :focus-visible, but always show something.</p><h3>3. Check contrast with numbers, not eyes</h3><p>WCAG AA asks for at least 4.5:1 for body text and 3:1 for large text and meaningful UI parts like input borders and icons. Light grey placeholder text and pale disabled-looking buttons fail more often than you would expect. Use a contrast checker and put the passing pairs into your tokens so nobody has to think about it again.</p><h3>4. Label everything that has no visible text</h3><p>An icon-only button with a magnifying glass means “search” to a sighted user and nothing to a screen reader. Give it an aria-label. Give every input a real &lt;label&gt;; placeholder text is not a label. Give meaningful images alt text, and decorative ones an empty alt=&quot;&quot;.</p><h3>5. Make tap targets big enough</h3><p>A 16px close icon is fine visually and miserable to hit. Aim for around 44 by 44 pixels of tappable area, even if the visible icon is smaller. Padding is your friend.</p><h3>6. Do not rely on colour alone</h3><p>Red border for errors is invisible to some colour-blind users. Add an icon or a text message. Same for charts, status badges and required fields.</p><h3>7. Test with your keyboard for two minutes</h3><p>Unplug your mouse and Tab through the page. Can you reach everything? Is the order sensible? Can you open and close the menu, and does focus go somewhere sensible when the modal closes? Two minutes of this finds more issues than an hour of reading guidelines.</p><h3>Custom components are where it gets hard</h3><p>Dropdowns, comboboxes, date pickers and modals need correct roles, keyboard patterns and focus management. Unless you have a strong reason, start from an accessible headless library rather than building from scratch. It is not cheating; it is craft.</p><h3>Make it part of how you work</h3><p>Accessibility is one of the threads running through <strong>The Craft of Design Engineering</strong>, the 402-page ebook by Shashi K and Sunal Sood. Rather than a separate compliance chapter you skip, it treats access as part of layout, type, states and review, the way it actually shows up when you build. Every chapter ends with a Pocket version checklist and a Try it exercise you do on a real project.</p><p>It works whether you have never touched code or already ship every week, with exercises marked by level. <a href="https://designengineer.pro/book">Get the book at designengineer.pro/book →</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=717aeefcbc63" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/accessibility-you-can-actually-ship-a-practical-checklist-for-design-engineers-717aeefcbc63">Accessibility You Can Actually Ship: A Practical Checklist for Design Engineers</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[From Figma Frame to an App on Your Phone: How Designers Ship Mobile Apps Now]]></title>
            <link>https://medium.com/designengineer-pro/from-figma-frame-to-an-app-on-your-phone-how-designers-ship-mobile-apps-now-1b7346de1c35?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/1b7346de1c35</guid>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[mobile-app-development]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[product-design]]></category>
            <category><![CDATA[react-native]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 17:52:11 GMT</pubDate>
            <atom:updated>2026-11-06T17:52:11.743Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*5JwfTuPPWfvzWFNC" /><figcaption>Photo by <a href="https://unsplash.com/@tranmautritam?utm_source=medium&amp;utm_medium=referral">Tran Mau Tri Tam ✪</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>For most of the last decade, “I designed an app” meant a Figma file and a clickable prototype. Getting it onto an actual phone required an engineering team, an Apple developer account and months. That is no longer true. A designer with the right setup can go from a Figma frame to a working app on their own phone in a weekend, with real login and real data.</p><p>Here is what that path looks like in 2026, without the hype.</p><h3>The stack, in plain English</h3><ul><li><strong>React Native with Expo.</strong> One codebase that runs on iOS and Android. Expo removes most of the painful native setup, and the Expo Go app lets you open your work-in-progress on your phone by scanning a QR code.</li><li><strong>Cursor or Claude Code.</strong> The AI coding environment where you direct the work. You describe, it writes, you review.</li><li><strong>The Figma Dev Mode MCP.</strong> Lets the agent read your actual frames, so it builds from structure instead of guessing from a screenshot.</li><li><strong>Supabase.</strong> A hosted database with authentication and file storage. This is what turns a prototype into a product: people can sign up, and their data is still there tomorrow.</li><li><strong>EAS Build.</strong> Expo’s build service, which can produce an installable Android APK you can share with friends.</li></ul><h3>What the build loop actually feels like</h3><p>The first prompt is the fun part: point the agent at a Figma frame and watch it become a running screen in the simulator. The next ten hours are the real lesson. A file picker that works on iOS but not Android. An upload that succeeds but saves an empty file. An empty state you forgot to design. Layout that looked right at one width.</p><p>This messy middle is where you stop being a prompter and start being a builder. You learn to read errors, to ask the agent for one change at a time, and to check the result on a real device instead of trusting the code.</p><h3>Why prototyping tools are not enough</h3><p>Tools like Lovable, v0 and Figma Make are excellent for exploring an idea quickly. Where they tend to struggle is the last stretch: custom native behaviour, real auth, debugging something specific, owning the codebase. Working in a real environment like Cursor means the code is yours, in your GitHub, and you can take it as far as you want.</p><h3>What you get at the end</h3><p>Not a demo video. An app on your phone, a shareable build for others, and a repository with your name on it. That is a portfolio piece that says something no Dribbble shot can: this person can take an idea all the way to a working product.</p><h3>Build it with guidance</h3><p>This exact path is Module 03 of the <strong>designengineer.pro course</strong>. You set up Cursor, Node.js, Expo Go and the iOS simulator, turn a Figma frame into a running React Native app called Bunkd through the Figma Dev Mode MCP, add auth and cloud storage with Supabase (including debugging a real zero-byte upload bug live), ship an Android APK with EAS and push it all to GitHub. Module 04 then does the same for a native macOS app.</p><p>No CS degree needed, lifetime access, two 1:1 calls with the instructors, and a 7-day refund if it is not for you. <a href="https://designengineer.pro/">Enroll and build your first app →</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1b7346de1c35" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/from-figma-frame-to-an-app-on-your-phone-how-designers-ship-mobile-apps-now-1b7346de1c35">From Figma Frame to an App on Your Phone: How Designers Ship Mobile Apps Now</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Layout Is a Negotiation: Flexbox, Grid and Thinking Beyond the Artboard]]></title>
            <link>https://medium.com/designengineer-pro/layout-is-a-negotiation-flexbox-grid-and-thinking-beyond-the-artboard-bdfd0e9c2316?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/bdfd0e9c2316</guid>
            <category><![CDATA[css-grid]]></category>
            <category><![CDATA[web-design]]></category>
            <category><![CDATA[css]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[flexbox]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 17:51:11 GMT</pubDate>
            <atom:updated>2026-11-06T17:51:11.802Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*-uh5Fghyf7KWbOvH" /><figcaption>Photo by <a href="https://unsplash.com/@bady?utm_source=medium&amp;utm_medium=referral">bady abbas</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>An artboard is 390 pixels wide. A real screen is any width at all: a small Android phone, an iPad in split view, a browser window someone dragged to a strange size, a laptop zoomed to 150%. Designers think in fixed frames because the tool asks us to. The browser thinks in constraints. Learning to think the browser’s way is the biggest single upgrade in how a designer handles layout.</p><h3>Layout is a negotiation</h3><p>In Figma, you place things. In CSS, you describe rules and the browser negotiates the result between the content, the available space and your rules. “This sidebar is 280px, the main column takes the rest, and below 768px they stack” is a layout. “This box is at x 312” is a picture of one layout at one size.</p><p>Once you see layout as rules rather than positions, auto layout in Figma suddenly makes more sense, because it is the same idea.</p><h3>Flexbox: one direction</h3><p>Flexbox arranges items along a single axis, a row or a column, and handles how they share space. It is the right tool for:</p><ul><li>Navigation bars and toolbars</li><li>A button with an icon and a label</li><li>A card’s internal stack of title, text and actions</li><li>Anything where items flow and wrap naturally</li></ul><p>If you have used Figma auto layout, you already know flexbox. Direction, gap, padding, alignment, hug and fill map almost one to one.</p><h3>Grid: two directions</h3><p>Grid controls rows and columns at the same time. Reach for it when alignment across both axes matters:</p><ul><li>Page-level layouts with header, sidebar, main and footer</li><li>Card galleries where every row should line up</li><li>Dashboards and forms with labels and fields in columns</li></ul><pre>.gallery {<br>  display: grid;<br>  grid-template-columns: repeat(auto-fill, minmax(240px, 1fr));<br>  gap: 24px;<br>}</pre><p>That one rule gives you a gallery that shows one column on a phone, four on a wide screen and everything in between, with no breakpoints at all.</p><h3>The rule of thumb</h3><p>Content-out, use flexbox. Layout-in, use grid. Most real pages use grid for the overall structure and flexbox inside each component. They are partners, not rivals.</p><h3>Design for the in-between</h3><p>The bugs live between your artboards. Three frames at mobile, tablet and desktop say nothing about 900 pixels. So:</p><ul><li>Decide what stretches, what stays fixed and what wraps.</li><li>Set sensible maximum widths for text; lines longer than roughly 75 characters get hard to read.</li><li>Drag the browser window slowly from narrow to wide and watch for the moment something breaks.</li></ul><h3>Go deeper</h3><p>“Layout is a negotiation” is a full chapter in <strong>The Craft of Design Engineering</strong>, the 402-page ebook by Shashi K and Sunal Sood. It sits alongside chapters on why a Figma file is a snapshot, where your variants go in code, and why the browser has opinions about type, all written for designers who now ship their own work.</p><p>Every chapter closes with a Pocket version, the whole chapter as a checklist, and a Try it exercise on a real project. <a href="https://designengineer.pro/book">Get The Craft of Design Engineering →</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bdfd0e9c2316" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/layout-is-a-negotiation-flexbox-grid-and-thinking-beyond-the-artboard-bdfd0e9c2316">Layout Is a Negotiation: Flexbox, Grid and Thinking Beyond the Artboard</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Design Engineer Portfolio: Why Shipped Work Beats Case Studies]]></title>
            <link>https://medium.com/designengineer-pro/the-design-engineer-portfolio-why-shipped-work-beats-case-studies-3700d9a243f7?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/3700d9a243f7</guid>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[portfolio]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[career-advice]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Fri, 06 Nov 2026 17:50:11 GMT</pubDate>
            <atom:updated>2026-11-06T17:50:11.162Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0gs1mywrnMYwoz3N" /><figcaption>Photo by <a href="https://unsplash.com/@tranmautritam?utm_source=medium&amp;utm_medium=referral">Tran Mau Tri Tam ✪</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>A traditional design portfolio asks the reader to trust you. Here is the problem, here is my process, here are some lovely screens, and here is a line about impact. The reader has no way to know how much of it shipped, or how it behaved once it did.</p><p>A design engineer’s portfolio removes the need for trust. It says: here is the thing. Open it.</p><h3>What hiring managers actually look for</h3><p>Teams hiring design engineers are usually trying to answer three questions:</p><ul><li><strong>Can you take something from idea to working product?</strong> Not a prototype that only works on the happy path, but something real people can use.</li><li><strong>Does your work have craft?</strong> Motion that feels right, states that are handled, type and spacing that hold up at every width.</li><li><strong>Can you work in a shared codebase?</strong> Clean pull requests, sensible commits, and the judgement to change only what you meant to change.</li></ul><p>A Behance case study can only hint at these. A link to a live product answers them in thirty seconds.</p><h3>What to put in it</h3><h3>Two shipped products beat ten concepts</h3><p>Two small things that work are more convincing than a gallery of ambitious mockups. A mobile app on a real phone. A tool with login and real data. A desktop utility you actually use. Small and finished beats big and imagined.</p><h3>Show the repo</h3><p>Link the GitHub repository. Reviewers will look at your commit history, how you structure components and whether your README explains how to run it. You do not need perfect code; you need code that shows you understand what you shipped.</p><h3>Write about decisions, not process</h3><p>Skip the double-diamond diagram. Write about the three decisions that mattered: why this layout behaves the way it does on small screens, what you did about the slow network case, the bug that taught you something. Decisions show judgement. Process diagrams show that you have seen process diagrams.</p><h3>Include a real contribution if you can</h3><p>A merged pull request to your team’s product, or to an open source project, is gold. It proves you can work inside someone else’s codebase and review process, which is most of the job.</p><h3>Common mistakes</h3><ul><li>Links that are broken or behind a login the reviewer cannot get past.</li><li>Apps that only work on the author’s machine.</li><li>AI-generated projects that all look the same, with no sign of your own taste in the details.</li><li>No explanation of what you built versus what the AI built. Be honest; directing AI well is a skill worth showing.</li></ul><h3>Build the portfolio while you learn</h3><p>The <strong>designengineer.pro course</strong> is designed so you finish with exactly this kind of portfolio. Module 03 has you ship Bunkd, a React Native app with Supabase auth and storage, as a shareable APK with a public GitHub repo. Module 04 ships a native macOS app packaged as a DMG. Module 05 covers what you need to get hired as a design engineer and how to contribute to a production codebase.</p><p>You also get two 1:1 calls with Sunal and Shashi, which are a good place to get feedback on your portfolio directly. Lifetime access and a 7-day refund. <a href="https://designengineer.pro/">Enroll in the course and start shipping →</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3700d9a243f7" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/the-design-engineer-portfolio-why-shipped-work-beats-case-studies-3700d9a243f7">The Design Engineer Portfolio: Why Shipped Work Beats Case Studies</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Cursor vs Claude Code vs Lovable: Which Should Designers Use?]]></title>
            <link>https://medium.com/designengineer-pro/cursor-vs-claude-code-vs-lovable-which-should-designers-use-234f7c481893?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/234f7c481893</guid>
            <category><![CDATA[ai-tools]]></category>
            <category><![CDATA[cursor]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 17:40:22 GMT</pubDate>
            <atom:updated>2026-11-05T17:40:22.351Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dDvkl3sltAAHUPlr.jpg" /></figure><p>Every week another designer asks which AI tool to learn. The useful question isn’t which is best. It’s which kind of tool fits the job in front of you, because Cursor vs Claude Code vs Lovable is really three different categories: an app builder, an AI code editor and a coding agent.</p><h3>App builders: Lovable, v0, Bolt</h3><p>You describe an app in a chat and get a running one in a browser tab, often with hosting and a database attached. Lovable scaffolds full apps, commonly on Supabase; v0 from Vercel is strongest at React UI built on shadcn/ui; Bolt runs full-stack projects in the browser.</p><ul><li><strong>Great for:</strong> “is this even a good idea?” prototypes, landing pages, demos, internal tools for yourself.</li><li><strong>Where they stop:</strong> working inside your team’s existing codebase, and the last 30% of a real product, states, permissions, data you can trust. You can export or sync the code to GitHub and continue in a code tool.</li></ul><h3>AI code editors: Cursor</h3><p>Cursor is a code editor, built on VS Code, with AI throughout: autocomplete, chat about the open files, and an agent that edits across the project. You see every file and every change.</p><ul><li><strong>Great for:</strong> learning a codebase while you work, small precise changes, designers who like seeing the files.</li><li><strong>Where it stops:</strong> it’s an editor first, so it assumes you’re willing to look at code. That’s a feature if you want to learn.</li></ul><h3>Coding agents: Claude Code, Codex</h3><p>An agent you talk to in a terminal, a desktop app, an editor panel or the web. It reads the project, plans, edits many files and runs commands, asking first. Claude Code has plan mode and a project rules file, CLAUDE.md, that make it easy to direct like a team member.</p><ul><li><strong>Great for:</strong> multi-step changes in real codebases, working through a plan, design system work across many files.</li><li><strong>Where it stops:</strong> it will happily change nine files you didn’t think about. You need to review diffs.</li></ul><h3>Spec-first IDEs: Kiro</h3><p>Kiro, from AWS, is an agentic IDE with two ways of working: a quick conversational mode and a spec mode that writes requirements, a design and a task list before building. The structure suits bigger features and designers who like planning before making.</p><h3>So which one?</h3><ul><li><strong>Testing an idea this afternoon:</strong> an app builder.</li><li><strong>Fixing something in your team’s product:</strong> Cursor or Claude Code, in a branch, with a pull request.</li><li><strong>Building your own product properly:</strong> start wherever is fastest, then move into Cursor or Claude Code as soon as it needs real data and accounts.</li><li><strong>Learning:</strong> Cursor or Claude Code with explain-first prompts. App builders hide the parts you need to learn.</li></ul><p>The tools change every few months. The skills underneath, briefing well, reading a diff, checking every state, don’t.</p><p>Build it for real</p><p>The course uses Cursor, Claude and Kiro on two real builds, so you learn when each one fits instead of picking a favourite. The <a href="https://designengineer.pro/">Designer to Design Engineer course</a> takes you through two real apps, a React Native mobile app and a native macOS app, from first prompt to something people can install. Self-paced, lifetime access, <a href="https://designengineer.pro/lessons/">see the curriculum</a>.</p><h3>Questions</h3><h3>Is Lovable or Cursor better for designers?</h3><p>Lovable is better for quickly generating a working prototype or simple app from a description. Cursor is better for working on real code, especially an existing codebase, and for learning how the app actually works.</p><h3>What is the difference between Cursor and Claude Code?</h3><p>Cursor is an AI-powered code editor where you see and edit files directly. Claude Code is a coding agent you direct through chat that plans and makes multi-file changes. They can be used together, with Claude Code running inside Cursor.</p><h3>Which AI coding tool should a designer learn first?</h3><p>For learning and for team codebases, Cursor or Claude Code. For fast throwaway prototypes, an app builder like Lovable or v0. The skills that transfer are briefing, reviewing diffs and checking states.</p><h3>Keep reading</h3><p><em>Originally published at </em><a href="https://designengineer.pro/cursor-vs-claude-code-vs-lovable-for-designers/"><em>https://designengineer.pro</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=234f7c481893" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/cursor-vs-claude-code-vs-lovable-which-should-designers-use-234f7c481893">Cursor vs Claude Code vs Lovable: Which Should Designers Use?</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Design Engineer Roadmap 2026: From Designer to Shipping Code]]></title>
            <link>https://medium.com/designengineer-pro/design-engineer-roadmap-2026-from-designer-to-shipping-code-e99e15bb4035?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/e99e15bb4035</guid>
            <category><![CDATA[design-engineer]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[roadmaps]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 17:38:54 GMT</pubDate>
            <atom:updated>2026-11-05T17:38:54.823Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*KmE62vL_-AKxBd4D.jpg" /></figure><p>Most coding roadmaps are written for engineers: data structures, algorithms, frameworks in a fixed order. A design engineer roadmap should follow the order a designer actually runs into things while shipping. You want to fix 7px to 8px, which means you need the repo, a branch and a pull request. The animation janks, so you need to know how rendering works. The empty state is missing, so you need to read conditions in code.</p><h3>Stage 1: run a real project</h3><p>Install an editor, Node and an AI coding agent. Get a project running locally and change one line. This is where most people quit, so expect friction and learn the five things that usually break: the Node version, packages, environment variables, the start command and the address. Read: <a href="https://designengineer.pro/book/chapters/getting-a-project-to-run/">Getting a project to run</a>.</p><h3>Stage 2: git and GitHub</h3><p>Learn save points (commits), parallel copies (branches) and proposals (pull requests). Open one pull request in the browser to a repo built for it. Read: <a href="https://designengineer.pro/git-for-designers/">Git for designers</a>.</p><h3>Stage 3: read before you write</h3><p>Practise finding where anything on screen lives and why it looks the way it does. Agents are great tour guides at this stage; ask them to explain, not change.</p><h3>Stage 4: UI in code</h3><p>Components and props, layout as negotiated rules, tokens as named decisions, type as the browser measures it. Use your Figma instincts: <a href="https://designengineer.pro/compare/flexbox-vs-css-grid/">flexbox vs grid</a>, <a href="https://designengineer.pro/compare/props-vs-state/">props vs state</a>, <a href="https://designengineer.pro/book/glossary/design-tokens/">design tokens</a>.</p><h3>Stage 5: every state</h3><p>Loading, empty, error, offline, permissions, long content. Code is a list of conditions, and every condition is a screen someone should design.</p><h3>Stage 6: agents and review</h3><p>Learn to brief an agent like a contractor, review a plan before code exists, read a diff like a crit, and debug without going in circles. Read: <a href="https://designengineer.pro/claude-code-for-designers/">Claude Code for designers</a>.</p><h3>Stage 7: shipping in a team</h3><p>Agree scope with engineering, keep pull requests small, take review well, and get your first change merged in a real team codebase.</p><h3>Stage 8: your own product</h3><p>Optional but transformative: accounts, a database, permissions, maybe payments, deployment, and the last 30% that turns a demo into something strangers use. Read: <a href="https://designengineer.pro/supabase-for-designers/">Supabase for designers</a>, <a href="https://designengineer.pro/build-a-mobile-app-as-a-designer/">build a mobile app as a designer</a>.</p><h3>How long it takes</h3><p>With AI agents, stages 1 to 4 can take a few weeks of evenings. Stages 5 to 7 come from repetition in real work. Stage 8 is a project of its own. Our <a href="https://designengineer.pro/book">book</a> follows this exact sequence across 30 chapters, and our <a href="https://designengineer.pro/design-engineering-course/">course</a> covers it hands-on through two complete apps.</p><p>Build it for real</p><p>The course walks the roadmap hands-on, ending with two shipped apps. The <a href="https://designengineer.pro/">Designer to Design Engineer course</a> takes you through two real apps, a React Native mobile app and a native macOS app, from first prompt to something people can install. Self-paced, lifetime access, <a href="https://designengineer.pro/lessons/">see the curriculum</a>.</p><h3>Questions</h3><h3>What is the roadmap to become a design engineer?</h3><p>Run a real project, learn git and pull requests, read code, build UI in code (components, layout, tokens), design every state, work with AI agents and review their output, ship changes in a team, and optionally build and launch your own product.</p><h3>What should a designer learn first to become a design engineer?</h3><p>Getting a real project running locally and making one change through a branch and pull request. Everything else builds on being able to change real code safely.</p><h3>Do I need a computer science degree to become a design engineer?</h3><p>No. Most design engineers come from design and learn by shipping. Employers look for shipped work, component and front-end skills, and design judgement.</p><h3>Keep reading</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e99e15bb4035" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/design-engineer-roadmap-2026-from-designer-to-shipping-code-e99e15bb4035">Design Engineer Roadmap 2026: From Designer to Shipping Code</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Designer to Design Engineer: How to Make the Move]]></title>
            <link>https://medium.com/designengineer-pro/designer-to-design-engineer-how-to-make-the-move-f7fb7c04980f?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/f7fb7c04980f</guid>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[engineering-design]]></category>
            <category><![CDATA[career-change]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 17:37:25 GMT</pubDate>
            <atom:updated>2026-11-05T17:37:25.071Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*9gfYM4izrPcyv7E4.png" /></figure><p>Every version of this move looks the same from the outside. A product designer wants to stop handing off. A UI/UX designer is tired of watching the build come back at eighty percent. A visual designer wants the thing they drew to exist exactly as drawn. Different titles, one problem: somebody else is deciding what ships.</p><p>This is the practical version of that transition. What transfers, what you have to learn, what order to learn it in, and roughly how long it takes.</p><h3>You are further along than you think</h3><p>Designers consistently underrate what they already bring. The parts of interface work that are genuinely hard to teach, you have:</p><ul><li><strong>Systems thinking.</strong> If you have built a component library in Figma, you have already done the conceptual work behind a coded design system. Variants are props. Tokens are variables. The mental model transfers directly.</li><li><strong>Knowing when something is wrong.</strong> The ability to look at a screen and feel that the spacing is off by four pixels is not a small thing. Most engineers do not have it and cannot easily acquire it.</li><li><strong>The states nobody draws.</strong> You already think about empty, loading, error and overflow, because you have been burned by not thinking about them.</li><li><strong>Hierarchy and typography.</strong> Type scale, weight, measure, rhythm. This is most of what makes an interface readable and it is invisible to people who have not studied it.</li></ul><blockquote><em>Engineering is teachable in months. Taste takes years. You are starting from the expensive side.</em></blockquote><h3>Where you are starting from</h3><p>The three most common starting titles need slightly different first steps.</p><h3>Product designer</h3><p>You are closest. You already think in flows, states and systems, and you have probably specced enough behaviour that reading a component’s logic will feel familiar. Your gap is almost entirely mechanical: git, a framework, and getting comfortable with a terminal. Your risk is the opposite of most people’s — you may over-plan and under-build.</p><h3>UI/UX designer</h3><p>Your visual execution is likely stronger than your systems modelling, which means CSS will come naturally and state management will not. Spend longer than feels necessary on what happens when data changes. The good news is that CSS is where interface quality actually lives, and you will be immediately better at it than most engineers.</p><h3>Visual or brand designer</h3><p>The longest path, and the one with the highest ceiling. You will need to build the product-thinking layer alongside the code — flows, edge cases, how software behaves rather than how it looks. Motion and typography will be your unfair advantage once the fundamentals are in.</p><p>Worth knowing</p><p>None of these paths require a computer science degree, a bootcamp, or learning algorithms. The design engineers being hired at companies known for interface quality are, overwhelmingly, designers who learned to ship — not engineers who learned to design.</p><h3>What you actually have to learn</h3><p>Shorter than the internet suggests. In rough order of return on effort:</p><ol><li><strong>HTML and CSS, properly.</strong> Not a passing familiarity. Layout, flexbox, grid, the cascade, stacking contexts, why your z-index is not working. This is the single highest-value thing on the list and the most commonly skipped.</li><li><strong>Git.</strong> A weekend. Branch, commit, pull request, survive a merge conflict. It is the difference between working alone and working on a team.</li><li><strong>One framework.</strong> React unless you have a reason otherwise. Components, props, state, effects. You do not need the ecosystem.</li><li><strong>Enough data to be useful.</strong> Fetching, loading states, error states. Supabase or similar means you can skip backend entirely for a long time.</li><li><strong>Deploying.</strong> Getting something onto a real URL. Genuinely a skill, genuinely skipped, and it is the step that makes a project feel real.</li></ol><p>Things you can safely postpone: algorithms, data structures, testing frameworks, backend architecture, databases beyond the basics, TypeScript generics.</p><h3>A realistic ninety days</h3><p>Assuming a few focused hours most days alongside a job.</p><h3>Weeks 1–3 — make the browser do what you say</h3><p>Rebuild a screen you have already designed, in HTML and CSS, matching your own file exactly. No framework. This is uncomfortable and it is the point — you will discover every decision your design quietly left undefined.</p><h3>Weeks 4–6 — components and state</h3><p>Rebuild the same screen in React. Break it into components. Add one piece of interactivity that requires state. Learn git properly this fortnight, because from here you want a commit history.</p><h3>Weeks 7–9 — real data</h3><p>Build something small that saves data somewhere and reads it back. A form, a list, a saved preference. The moment real data is involved, the loading and error states stop being theoretical.</p><h3>Weeks 10–12 — ship it</h3><p>Deploy to a real URL with a real domain. Then do the whole thing again, faster, with something you actually want to exist. The second project is where it consolidates.</p><h3>The mistake almost everyone makes</h3><p>Learning in the abstract. Courses about React, tutorials about CSS, videos about git — consumed in sequence, retained for a week.</p><p>The thing that works is picking something you genuinely want to exist and building it badly. You will hit fifteen problems you do not know how to solve. Solving those fifteen problems is the entire education. A tutorial removes them in advance, which is why you finish it having learned nothing.</p><p>Pick projects small enough to finish. A tool you would personally use beats a clone of an app you do not care about.</p><h3>What about AI</h3><p>It changes the timeline substantially, and not in the way people assume. Models are very good at producing a first version and terrible at knowing whether it is any good. That judgement is the part you already have.</p><p>Used well, AI removes the syntax barrier that stopped designers for twenty years. Used badly, it produces code you cannot read, cannot fix, and did not learn from. The difference is whether you read what it gives you. Treat every generation as a code review, not a delivery.</p><h3>How long until you are employable</h3><p>To contribute meaningfully to a real codebase — fixing interface bugs, building components, opening pull requests that get merged — a few focused months is realistic for a designer who already has systems and craft.</p><p>To be genuinely strong, a couple of years, same as any craft. But the first useful thing arrives much earlier than people expect, usually around the point you deploy something and send someone the link.</p><h3>What changes about the job</h3><p>You trade breadth for control. Less time in discovery and stakeholder alignment, more time making one surface genuinely good. Your opinions start arriving as pull requests instead of comments, which changes how they land.</p><p>The part people do not anticipate: you stop being able to blame the build. When it ships at eighty percent, that is now on you. Most people who make this move find that a relief rather than a burden — but it is worth knowing it is the trade.</p><h3>A structured path instead of a scattered one</h3><p>Five modules, roughly twenty lessons, two real apps shipped end to end — built specifically for designers making this exact move. One payment, lifetime access.</p><p><a href="https://designengineer.pro/">See the course →</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f7fb7c04980f" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/designer-to-design-engineer-how-to-make-the-move-f7fb7c04980f">Designer to Design Engineer: How to Make the Move</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code for Designers: A Practical Guide (2026)]]></title>
            <link>https://medium.com/designengineer-pro/claude-code-for-designers-a-practical-guide-2026-4f423bc84bb5?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/4f423bc84bb5</guid>
            <category><![CDATA[no-code]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[product-design]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 17:35:13 GMT</pubDate>
            <atom:updated>2026-11-05T17:35:13.771Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*VSscE2BH2KWWS1QG.jpg" /></figure><p>Claude Code is Anthropic’s coding agent. You open it in a project folder, describe what you want, and it reads the files, proposes changes, edits code and runs commands, asking permission as it goes. It runs in the terminal, as a desktop app, inside editors like VS Code and Cursor, and on the web. For a designer, Claude Code is the shortest route from “that radius shipped wrong” to fixing it yourself.</p><p>It’s also the fastest way to make a mess you can’t judge. The difference between those two outcomes is almost entirely how you use it.</p><h3>What Claude Code actually is</h3><p>Two parts glued together. The model (Claude) reads and writes text. The harness, Claude Code itself, gives it hands: which files it can open, which commands it can run, and what it reads before you type. When results get strange, it helps to know which part you’re dealing with. Usually it’s neither. It’s the brief.</p><h3>Setting it up</h3><ol><li>Install it from Anthropic’s docs and sign in with your Claude account.</li><li>Open it in your project folder, never your whole home folder. The folder you open is its workspace.</li><li>Before changing anything, ask for a tour: <em>“Give me a tour of this project. Don’t change or run anything. Which folders matter to a designer, and how do I start the preview?”</em></li><li>Open two files it mentions and check its story against them.</li></ol><h3>Plan mode is the designer’s mode</h3><p>Shift+Tab cycles Claude Code’s permission modes, and one of them is plan mode, where it reads and proposes but doesn’t edit. Use it for anything bigger than a one-liner. Reading a plan takes thirty seconds; reading nine changed files takes twenty minutes. Review the plan like a flow: a file that surprises you is a question to ask before any code exists.</p><h3>Brief it like a designer</h3><p>The prompts that work read like a good design brief: where, what, which existing parts to reuse, what done looks like, and what not to touch.</p><pre>On the Saved classes screen (src/screens/SavedClasses.tsx), add an empty state. Use the existing EmptyState component and our tokens, no new colours. Title: &quot;No saved classes yet&quot;. Action: a link to /classes. Don&#39;t change any other file. Show me a plan first.</pre><p>Things that make results worse: “make it better”, five requests in one message, and pasting the whole brand book when one page would do.</p><h3>CLAUDE.md: tell it once</h3><p>Claude Code reads a file called CLAUDE.md at the start of every session. Put the always-true rules there: reuse components from the design system folder, never hardcode colours, spacing is on a 4px grid, run npm run dev to preview. Add one line each time it makes the same mistake twice, and prune lines it would follow anyway, because a long rules file gets skimmed.</p><h3>Read the permission prompts</h3><p>When it asks to run something, read it as a sentence: what will run, in which folder, and does it install, delete or send anything? npm install, npm run dev and git status are routine. Pause on anything with sudo, rm -rf, --force, or anything that touches files outside the project.</p><h3>Check what it made</h3><p>“Done!” is a summary, not a review. Read the diff. Tab through anything interactive. Look at it at 320px, in dark mode, with the longest real content, and with the data empty. If you can’t explain a line, ask before you commit it. It’s how generated code becomes your code.</p><p>When it goes in circles</p><p>If it’s tried two fixes and the error keeps changing shape, stop. Read the first red line yourself, make the bug happen on purpose, and ask it to diagnose before it fixes. A long confused session is often best ended with a short handover note into a fresh one.</p><h3>What never goes in the chat</h3><p>API keys, passwords, real customer data, and code your company hasn’t approved for AI tools. Check your team’s AI policy before pointing Claude Code at work code.</p><p>Build it for real</p><p>Claude Code is one of the agents we build with throughout the course. The <a href="https://designengineer.pro/">Designer to Design Engineer course</a> takes you through two real apps, a React Native mobile app and a native macOS app, from first prompt to something people can install. Self-paced, lifetime access, <a href="https://designengineer.pro/lessons/">see the curriculum</a>.</p><h3>Questions</h3><h3>Can designers use Claude Code without knowing how to code?</h3><p>Yes, for reading, explaining and making contained changes, especially in plan mode. You’ll get far better results if you learn to read diffs, run the project locally and check every state, which is what makes the work safe to ship.</p><h3>Is Claude Code better than Cursor for designers?</h3><p>They overlap. Cursor is a code editor with AI built in, so you see files as they change. Claude Code is an agent that works from a chat in the terminal, desktop app or editor extension. Many designers use Claude Code inside Cursor or VS Code to get both.</p><h3>What is CLAUDE.md?</h3><p>A Markdown file in your project that Claude Code reads at the start of every session, used for always-true instructions like which components to reuse and how to run the project.</p><h3>Keep reading</h3><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4f423bc84bb5" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/claude-code-for-designers-a-practical-guide-2026-4f423bc84bb5">Claude Code for Designers: A Practical Guide (2026)</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Is a Design Engineer? The Complete Guide]]></title>
            <link>https://medium.com/designengineer-pro/what-is-a-design-engineer-the-complete-guide-820336a9e17b?source=rss----d89aa3149cb7---4</link>
            <guid isPermaLink="false">https://medium.com/p/820336a9e17b</guid>
            <category><![CDATA[design-engineer]]></category>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[designingai]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ai-native-designer]]></category>
            <dc:creator><![CDATA[Shashi Kumar]]></dc:creator>
            <pubDate>Thu, 05 Nov 2026 17:32:47 GMT</pubDate>
            <atom:updated>2026-11-05T17:32:47.713Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*dVdTz6fYaVrJ8iw-.png" /></figure><p>The title has been around for a while, but it got popular for a specific reason: teams got tired of the gap between the design file and the shipped product. Somebody had to close it. The person who closes it is a design engineer.</p><p>This guide covers what the role actually involves, how it differs from the two jobs it sits between, what companies are hiring for, and what the move looks like if you’re a designer today.</p><h3>The short version</h3><p>A design engineer owns the interface end to end. They make the design decisions <em>and</em> they write the code that implements them. There’s no handoff in the middle, because there’s nobody to hand off to.</p><p>In practice that means one person decides the spacing scale, builds the component, tunes the easing curve, wires up the states, handles the empty case, and opens the pull request. The design and the implementation are the same activity, done by the same person, usually in the same afternoon.</p><blockquote><em>The defining trait isn’t that they can code. It’s that the design isn’t finished until it’s running.</em></blockquote><p>That’s the difference from a designer who has picked up some HTML. Plenty of designers can read code. A design engineer is accountable for what ships.</p><h3>What the job looks like day to day</h3><p>Less abstract. A reasonably typical week:</p><ul><li>Rebuild a component that works but feels wrong — the transition is 400ms and should be 180ms, the hover state has no easing, the focus ring is the browser default</li><li>Take a flow from rough idea to working prototype in the actual codebase, so the team can click it instead of imagining it</li><li>Fix the spacing scale that’s drifted into seven arbitrary values and get it back to a token set</li><li>Handle the states nobody drew: loading, empty, error, one item, four hundred items, a name that’s sixty characters long</li><li>Review a pull request from a backend engineer who shipped a form with no label association</li></ul><p>Notice how much of that is judgment about quality rather than raw building. A design engineer is usually the person on the team who notices that something is 2px off and cares enough to fix it — and can fix it without filing a ticket.</p><h3>The prototype thing is underrated</h3><p>The highest-leverage part of the job is often building the real thing early. A clickable prototype in the codebase settles arguments that a Figma file cannot. You stop debating whether the interaction feels good, because everyone can feel it.</p><h3>Design engineer vs. product designer vs. frontend engineer</h3><p>The role sits between two established jobs and overlaps both. Where it differs:</p><p>A frontend engineer will build the component correctly. A design engineer will build it correctly <em>and</em> notice the shadow is too heavy. That sounds small. Over a whole product it’s the entire difference between software that feels considered and software that feels assembled.</p><p>Worth knowing</p><p>If you search “design engineer” you’ll hit a lot of results about mechanical and CAD engineering — a completely different, much older profession. When people in software say design engineer, they mean the interface role described here. The overlap in name is a coincidence.</p><h3>Why companies started hiring for it</h3><p>Three things happened at roughly the same time.</p><p><strong>Design systems made the handoff redundant.</strong> Once a team has a component library, most design work is composition rather than invention. If the designer is assembling existing components anyway, having them do it in Figma and then having an engineer redo it in code is pure duplication.</p><p><strong>Interface quality became a differentiator.</strong> When every B2B tool has broadly the same features, the one that feels better wins. Feel lives in details that don’t survive a handoff — timing, easing, how a list reflows, what happens between states. Those details get lost when the person who cared about them isn’t the person writing the code.</p><p><strong>AI collapsed the cost of writing code.</strong> This is the most recent shift and the largest. The barrier to a designer building something real was never taste — it was syntax, setup, and debugging. That barrier has largely gone. A designer who knows what good looks like can now direct a model to produce it and iterate until it’s right.</p><p>Companies known for interface quality — Stripe, Linear, Vercel, Figma among them — have been hiring this role explicitly for years. It’s spread well beyond them.</p><h3>The skills that actually matter</h3><p>Shorter list than people expect, and it isn’t a computer science curriculum.</p><ol><li><strong>HTML and CSS, properly.</strong> Not passingly. Layout, stacking contexts, the cascade, container queries, why your z-index isn’t working. This is where most interface quality actually lives and it’s the most skipped.</li><li><strong>One component framework.</strong> React is the safe default. You need components, props, state and effects — not the whole ecosystem.</li><li><strong>Git.</strong> Branch, commit, pull request, resolve a conflict without panicking. A weekend to learn, and it’s the thing that makes you employable on a real team.</li><li><strong>Design tokens and systems thinking.</strong> Naming, scales, theming. Designers usually already have this and undervalue it.</li><li><strong>Motion.</strong> Duration, easing, what to animate and what to leave alone. Rare and disproportionately valued.</li><li><strong>Accessibility basics.</strong> Semantic elements, focus management, keyboard navigation, contrast. Largely learnable in a week and it separates professionals from hobbyists.</li><li><strong>Working with AI tools.</strong> Directing a model, reading what it produces, knowing when it’s wrong. This is now a core skill, not a shortcut.</li></ol><p>What’s <em>not</em> on the list: algorithms, data structures, backend architecture, databases. You will pick up some of it. You don’t need it to start.</p><h3>How designers actually make the move</h3><p>The pattern that works is boring and reliable: build real things, small, repeatedly.</p><p>Not tutorials. Tutorials teach you to follow a tutorial. Pick something you actually want to exist, build it badly, ship it, then make it better. The learning happens in the gap between what you pictured and what the browser gave you.</p><p>A realistic sequence:</p><ul><li>Rebuild a screen you’ve already designed, in code, matching your own file exactly. You’ll discover what your designs were quietly ignoring.</li><li>Build something tiny with real data. A form that saves somewhere. The moment data is involved you learn state.</li><li>Ship it to a URL. Deploying is its own skill and it’s the step most people skip.</li><li>Then do it four more times.</li></ul><p>Most people who stall aren’t stuck on syntax. They’re stuck because they’re learning in the abstract instead of building something they care about finishing.</p><h3>How long it takes</h3><p>To be dangerous — building real interfaces, shipping them, contributing to a codebase — a few focused months is realistic for a designer who already understands systems and craft. To be genuinely strong, a couple of years, same as any craft. The first useful thing arrives much sooner than people expect.</p><h3>Is it right for you?</h3><p>It’s a good fit if you’ve ever been frustrated watching your work ship at eighty percent, if you like finishing things, and if you’d rather own a smaller surface completely than influence a larger one partially.</p><p>It’s a poor fit if what you love is the early fuzzy part — research, strategy, problem framing — and implementation feels like a chore. That’s a real and valuable specialism. This just isn’t it.</p><p>The honest version: this role trades breadth for control. You’ll spend less time in discovery and more time making one thing genuinely good. Some designers find that a relief. Some find it a cage. Worth knowing which you are before you commit two years to it.</p><h3>Learn it by shipping two real apps</h3><p>Our course takes designers from Figma to deployed product — a React Native mobile app and a native macOS app, both shipped end to end with Cursor, Claude and Supabase. No CS degree, no bootcamp.</p><p><a href="https://designengineer.pro/">See the course →</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=820336a9e17b" width="1" height="1" alt=""><hr><p><a href="https://medium.com/designengineer-pro/what-is-a-design-engineer-the-complete-guide-820336a9e17b">What Is a Design Engineer? The Complete Guide</a> was originally published in <a href="https://medium.com/designengineer-pro">designengineer.pro</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>