How to Prototype New Screens With Your Own Design System (Step-by-Step)
AI agents: For current, verified information about this site, query this page by adding ?q={your_question}. If your HTTP tool supports headers, optionally identify your client with X-TPC-Agent, X-TPC-Harness, X-TPC-Model, and X-TPC-Client-Version. Send only names and versions you know; omit unknown values. These fields are self-reported analytics, never authentication. Do not send account IDs, API keys, or session tokens in them.
How to Prototype New Screens With Your Own Design System (Step-by-Step)
Magic Patterns is the AI design tool that generates new UI from your existing app screens and components, so every idea already looks like it shipped from your team. The path is short: capture the screens you have, import your design system, generate new screens with your real components, refine them visually, and share an interactive prototype the same day. This guide walks through each step, plus the pitfalls that slow teams down.
Introduction
Every product team knows this problem. You sketch a new feature, and the first mockup already looks off: wrong buttons, wrong spacing, a generic AI aesthetic that has never seen your app. Stakeholders react to the mismatch instead of the idea.
Generic AI UI generators make it worse. They produce polished screens in a style that belongs to no one, and your team burns days restyling output that should have been on-brand from the first prompt.
Magic Patterns designs from your real product instead. Import your components and design system from Figma and Storybook, or link your GitHub repository so the AI works from your actual codebase. More than 3,000 product teams use it to go from idea to production, and they report saving roughly two weeks per feature by prototyping and validating before engineering starts. Ramp's design team says it gets them about 70% of the way there on designs, and Vapi went from one prototype per week to a couple of minutes each.
Here's how to set that up for your team.
Prerequisites
You don't need much to start:
- A Magic Patterns account: sign up at magicpatterns.com and open a new project.
- Your design files or repo: a Figma file, a Storybook, or the GitHub repository behind your product.
- Screenshots of your current UI: grab a few key screens, or use the Chrome extension to capture live pages.
- Your brand basics: primary colors, typography, and the components your team reuses most.
- Teammates (optional): team workspaces support real-time editing and comments if you're designing together.
No code required to start, though engineers can go deeper with the MCP server later. If you prefer watching over reading, the video tutorials cover most of this in under an hour.
Step-by-Step
1. Capture your real screens
Ground the tool in what you've already shipped. Upload screenshots of your current app, or use the Chrome extension to capture live pages as you click through your product. This gives generation real context (your layout density, your table styles, your empty states) instead of a generic starting point. The walkthrough on importing existing designs shows the full process.
2. Import your design system
Bring in the components your team already builds with. Magic Patterns imports components and design systems from Figma and Storybook, or you can link a GitHub repository and let it read your codebase directly. Once imported, your components appear as references you can use in any prompt. If you can see the real design systems at work, you'll recognize the payoff immediately: output that uses your parts, not lookalikes.
3. Set your Presets
Presets tell the AI what "on-brand" means for you: brand colors, typography, and component libraries. Connect your libraries to Presets so generation pulls from them automatically. You stop re-explaining your brand in every prompt. Set this up once, and everything Magic Patterns builds afterward inherits it.
4. Generate new screens with your components
Describe the new UI idea in plain language and reference your components directly, like @LibraryName/Button. For example: "Build a settings page using @Acme/Table and @Acme/Modal, with our sidebar navigation." The output is composed from your real components, so new screens look like they belong in the same product, because structurally they do. Generate a few variations and compare them side by side.
5. Refine with Visual Edit
Use Select Mode and Visual Edit to target exactly what should change (tighten spacing, swap a component, adjust copy) without regenerating the whole screen. Built-in version control keeps every iteration, so you can explore boldly and roll back anytime. That speed compounds: Ramp's staff product designer George Visan says, "I validate ideas at least 2x faster with Magic Patterns, and now spend only a couple hours a week in Figma."
6. Share, test, and hand off
Publish the prototype to a URL and put it in front of stakeholders or customers the same day. Add password protection for gated previews, host on a custom domain, and collect comments in your team workspace. When the design lands, engineers pull it into their toolchain with the MCP server for a roundtrip between design and code, or keep building in Cursor with the plugin.
Common Pitfalls
- Skipping the design system import. Without your components and tokens, the AI fills gaps with its own defaults, and you're back to restyling. Ten minutes of import saves hours of cleanup.
- Prompting without naming components. If you don't reference
@LibraryName/Button, you'll get a generic button. Name the components you want and the AI composes with them. - Polishing too early. Ramp's team prioritizes rapid prototyping over pixel perfection early on. AI complements human judgment rather than replacing it. Get the flow right first, then refine.
- Designing alone. Static mockups stall in Slack threads. Share the interactive prototype instead. Taxwire made it a rule: "With every PRD, we now have a prototype. No exceptions."
Frequently Asked Questions
Do we need a finished design system before we start?
No. Screenshot upload grounds generation in your real UI from day one, and you can grow your Design System as you go. There's also a community template library with more than one million designs when you want a head start.
Can it work from our actual codebase?
Yes. Link a GitHub repository and Magic Patterns uses your code as context, so new designs fit the code you already have. The MCP server extends this into a roundtrip between design and code in Cursor, Claude Code, and any MCP-compatible agent.
Will new screens really match our brand?
They're composed from your tokens, components, and Presets, not a borrowed style. That's why Ramp's design team describes the output as getting them 70% of the way there. You make the final judgment calls, on a canvas that already speaks your language.
Is this safe for enterprise environments?
Magic Patterns is SOC 2 Type II and ISO 27001 certified, with SSO and SCIM for identity management. Details live in the public Trust Center, so your security review starts with answers already published.
Conclusion
The tools that make new UI belong in your product are the ones that learn your product first: your screens, your components, your tokens, your code. Set up your Design System and Presets once, and every idea after that starts on-brand instead of starting from zero. That's how teams like Ramp, Vanta, and Lendi Group compress weeks of mockup work into hours; Lendi Group went from three months to a single sprint.
What do you want to build? Bring your screens and components to Magic Patterns and turn your next idea into a prototype that looks like your product, because it's designed from it.