> ## Content Index
> Fetch the complete content index at: https://www.everydayux.net/llms.txt
> Use this file to discover other available public pages before exploring further.

# A guide to today’s AI design tools
- URL: https://www.everydayux.net/ai-design-tools-guide/
- Published: 2026-11-17T13:54:00.000Z
- Updated: 2026-11-17T13:53:59.000Z
- Description: Design and code are coming together fast, and every tool divides the work with AI differently. A practical guide to today’s AI design tools, grouped by what they help you do and where you can step in and take control.
- Author: Jess Eddy
- Tags: AI, Design process

A new design tool seems to arrive every week. Many look alike and make similar promises. What’s changing is how closely design and code are coming together, and how much of the process you can hand to AI.

Generate a screen from a prompt, build it yourself on a canvas with code and components, or ask an agent to refine an existing product. Each tool divides the work differently. You might sketch a layout, ask an agent to build it, then step in to refine the result.

> We now have more design tools than open tabs in our browsers, and they’re multiplying faster than we can bookmark them.

Paper, Pencil, and Figma each bring design and code together in different ways. Figma’s MCP lets an agent use existing designs as a reference. Pencil stores design files alongside the code in your repo. Paper’s HTML and CSS canvas follows the browser’s layout rules, and its component system is still on the roadmap. Wonder brings a page from your running app onto the canvas as editable layers and lets you work with your own coding agent.

I’ve put together a guide to what today’s AI design tools help you do. You can generate directions, design on a canvas built around code, work on an existing product, or give a coding agent a place to explore. Each approach gives you different places to step in and take control.

I’ve been experimenting more with Paper and am excited to see where it goes. I’m also about to build a product from scratch with an engineer, and I’m eager to try Dessn to design in production once we have a working frontend. And I’m already prototyping faster than ever with Claude and UI libraries.

---

## Explore directions from a prompt

Describe what you want to build and get a few screens you can react to. This is useful early in a project, when you’re still figuring out what the product could look like or need something concrete to discuss with your team. Some tools can also use your design system or repo for context.

[Stitch](https://stitch.google.com/?ref=everydayux.net)  
Google Labs calls it “vibe design.” Describe an interface in writing or out loud, then steer the design agent as it works on an infinite canvas. You can also export the design rules as a DESIGN.md file for other design and coding tools to follow.

[Magic Patterns](https://www.magicpatterns.com/?ref=everydayux.net)  
Prototype new features in the style of the product you already have. Bring in a brief, visual references, and your own components, then compare directions on one canvas and hand the one you choose to your coding agent.

[Superdesign](https://superdesign.dev/?ref=everydayux.net)  
A design agent for exploring product UI. Start with a prompt in the web app or give it a design task from Claude Code or Cursor. Each direction can branch into a new draft, so you can compare versions on the canvas and bring the one you pick back into your build.

[MagicPath](https://www.magicpath.ai/?ref=everydayux.net)  
A shared workspace where your team and its agents design together. Give MagicPath one brief, and several agents can build different screens at the same time. As the screens come together, you can make visual edits across several at once and share the result as a working prototype.

[Figma Make](https://www.figma.com/make/?ref=everydayux.net)  
Figma’s prompt-to-app tool turns an idea or an existing Figma design into a working prototype or web app. You can keep refining it in chat or point to an element in the preview and adjust it directly. The desktop beta also lets you work in your local codebase.

---

## Design on a code-based canvas

This is the closest category to the way many designers already work. You can lay out a screen, adjust spacing, and style elements by hand. What sits underneath the canvas varies. It might be HTML and CSS, a working React component with states you can test, or a design file an agent can read and edit alongside you.

[Paper](https://paper.design/?ref=everydayux.net)  
Paper brings designers, agents, code, and data onto a canvas built on HTML and CSS. Lay out designs with the same rules the browser uses, then ask your agent to bring in real content or sync tokens, styles, and components between the canvas and your codebase.

[pen.dev, formerly Pencil](https://www.pen.dev/?ref=everydayux.net)  
Bring in a web page as editable layers or start from a Figma file, then switch between making adjustments yourself and asking an agent to work on the canvas. Designs are saved in a documented .pen format that uses JSON.

[Lunagraph](https://www.lunagraph.com/?ref=everydayux.net)  
Lay out the states of a flow side by side, then turn the design into a React component with props, state, and interactions. You can keep refining it on the canvas, share the flow as a clickable prototype, or hand the React code to an engineer or coding agent.

---

## Design in production

Start with a page or component that is already in production. Depending on the tool, you can bring it onto a canvas as editable layers, prototype with your app’s components and styles, or select an element in the running app and ask an agent to change it in the source code.

[Dessn](https://www.dessn.com/?ref=everydayux.net)  
Dessn’s pitch is “Design in production.” It runs a preview from a copy of your production frontend with a mocked backend. Your team can pull real pages onto a shared canvas to explore changes, prototype, review, and QA with the components and styles your app already uses.

[Wonder](https://wonder.design/?ref=everydayux.net)  
Bring a page or component from your running app onto the canvas as editable layers. Explore with the agent subscription you already use, adjust details by hand, then ask that same agent to apply the changes back in your codebase.

[Subframe](https://www.subframe.com/?ref=everydayux.net)  
Subframe puts a design canvas, a browser, and a coding agent in one app. Inspect a detail in your running product, or capture a page onto the canvas to explore a bigger change. Once you’ve picked a direction, the agent can implement it in your local codebase.

[Gui](https://usegui.com/?ref=everydayux.net)  
Point to an element in your app and tell your coding agent what to change. The agent edits the source, and Gui lets you compare the result with the previous version before you keep it, undo it, or ask for another pass. It’s an open-source Mac app in alpha.

[Tenor](https://tenor.design/?ref=everydayux.net)  
Tenor picks up where your coding agent’s first pass leaves off. Bring in a working React component or start from a visual reference, then talk through changes to its layout, behavior, or details. You can compare variations and take the React code for the one you choose back into your build.

---

## Give your coding agent a canvas

If you already build with Claude Code, Codex, or Cursor, a shared canvas gives you somewhere to compare working versions side by side and leave feedback on the one you mean. It also changes how you spend your time. More of the work happens when you brief the agent, review what it made, and decide what to keep. That can feel like a relief, or like losing the part of the work you enjoy most.

[Doop](https://doop.design/?ref=everydayux.net)  
Bring your own agent to an open-source canvas and watch it design alongside your team. Agents can pick up comments, revise a frame in place, and check their own work with screenshots. You can also trigger follow-up work, like generating new ad sizes when a design is approved.

[Twombly](https://twombly.app/?ref=everydayux.net)  
Give each direction your coding agent explores its own live frame. Share the canvas so teammates can follow each other’s cursors, leave comments on a specific version, or talk it through in a voice huddle. The agent can read those comments and update the frame they refer to.