UI/UX Design Basics for MarketersWireframes, UI patterns and prototypes · Lesson 9 of 21
Figma and AI design tools: from prompt to tested prototype
Video lecture
Figma and AI design tools: from prompt to tested prototype
The narrated lecture is in production
Every chapter is scripted and ready. Browse the chapters and read the full transcript now — the video will appear here when it’s published.
Chapters
Transcript of the narration, chapter by chapter.
0:00 Figma and AI design tools
You can now type a sentence and get a working landing page prototype in under a minute. That's real, and it's changing how marketing teams work. But here's the catch. The same tools will happily invent testimonials, skip focus states, use gray text nobody can read, and produce a page that looks exactly like everyone else's. In this lecture, you'll learn the core Figma concepts every marketer should know, what today's AI design tools actually do, a workflow that keeps humans in charge, and how to audit AI output before it reaches a customer.
0:41 Why it matters
Why does this matter for marketers? Speed. You can explore five layout ideas before lunch, test an interactive calculator with real users before a developer writes a line of code, and brief developers with precise designs instead of screenshots. But speed without judgment just produces bad pages faster. Think of AI design tools like a very fast junior designer who has seen millions of websites but never met your customers. Brilliant at drafts. Terrible at knowing what your audience worries about, what's legally true, or what your brand stands for. You're the art director.
1:22 Figma essentials
First, the Figma basics. Frames are containers for screens or sections, like artboards. Auto layout makes frames stack and space their contents automatically, so sections reflow when copy changes. Components and variants are reusable elements with properties like type and state. Change the main one and every copy updates. Styles and variables store named colors, type and spacing, including modes like light and dark. Prototyping links frames into clickable flows. Dev Mode gives developers measurements and code hints. And FigJam is the whiteboard for research, flows and workshops. You've already used several of these in earlier lessons.
2:04 AI inside Figma
Now the AI layer inside Figma. Figma's AI tools can generate first-draft layouts from a prompt, rename and organize layers, rewrite or translate text, generate or edit images, and wire up quick prototype connections. The feature called First Draft generates editable wireframes and designs from a description. And from May twenty twenty-six, Figma introduced an agent, in beta and rolling out gradually, as the new entry point for that work, with re-prompting and bulk edits. These features use AI credits, which vary by plan and seat. Features and limits change often, so always check Figma's current documentation.
2:46 Prompt-to-prototype tools
Next, prompt to prototype. Figma Make turns a prompt, and optionally an existing design, into a working interactive prototype or web app built from code. You can try it on the free Starter plan, with more capability on paid plans. Outside Figma, Google's Stitch generates multi-screen interface designs and exports to Figma, and code-first tools like Vercel's v0 and Lovable generate working front ends from prompts. Website builders such as Framer and Webflow have AI generation too. Here's the key idea. These tools are superb for exploration and throwaway prototypes. They are not a substitute for research, accessibility checks or brand judgment.
3:30 Figma MCP server
For teams with developers, there's one more piece: the Figma MCP server. MCP, the Model Context Protocol, is an open standard that lets AI assistants connect to tools and data. Figma's MCP server lets AI coding tools like Claude Code, Cursor or Copilot in VS Code read real design context. The layer structure, the auto layout rules, the variables and the components. Not just a screenshot. And with Code Connect, design components map to the matching components in your codebase. So when an assistant builds a page, it reuses your real button instead of inventing a new one. That's how design systems survive the AI era.
4:16 Worked example 1: creator waitlist (illustrative)
Worked example one, simple. A creator in London wants to test a new fitness program. She writes a content priority list from her DMs, then prompts Figma Make for a mobile waitlist page with a short quiz. She generates three versions. She keeps the quiz from one and the structure from another, and rebuilds the page with her saved brand colors. Her audit catches two problems: an invented ten thousand members badge, and low-contrast gray body text. Both get fixed. Five followers try the prototype over video. Three misunderstand one quiz question, so she rewrites it before building the real page.
5:00 Worked example 2: agency audit page (illustrative)
Worked example two, a business scenario with illustrative details. A marketing agency in Riyadh offers free ad account audits. The strategist writes a detailed prompt: audience, goal, content order, the headline, three benefits, a how it works section, placeholder testimonials clearly marked, an FAQ, and constraints. Sixteen pixel body text, forty-four pixel buttons, brand teal buttons with white text, visible focus styles, no fake urgency, no invented numbers. The first output ignores the content order and uses a default template. She re-prompts, then audits. The teal and white pairing needs checking against four point five to one. The developer then builds it through the MCP server using real components.
5:47 Watch me do it: prompt, generate, audit
Watch me do it. I start with my content priority list, not the tool. In the prompt, I describe the audience, the one primary action, the content in order, and hard constraints: minimum text size, button height, brand color, visible focus, no fake urgency, no invented statistics. I generate three options and treat each as a sketch. Then I run the audit checklist. Does the structure follow my list? Any invented claims, numbers or logos? Text contrast at least four point five to one? Targets big enough, focus visible, fields labeled? Does it work at three hundred twenty pixels wide? Finally, I rebuild the winner with our components.
6:34 Rules for AI design
A few rules keep you safe. Privacy: don't paste customer data or unreleased plans into tools your organization hasn't approved, and check each tool's data-use settings. Intellectual property: don't prompt a tool to copy a competitor's site or a living designer's distinctive style. Use your own brand assets and licensed images. Truthfulness: AI tools invent testimonials, statistics and client logos. Remove them. Fake proof is a consumer protection problem, not just a design flaw. And accessibility: generated designs often miss focus states, labels and contrast. Audit every single time.
7:13 Common mistakes and measures
Common mistakes. Prompting with a vibe, like make it modern, instead of your content and constraints. Accepting the tool's default template structure. Shipping AI output straight to customers without an audit. Letting generated designs drift from your components and brand variables, so every page looks slightly different. And confusing speed with success. How do you measure success? Time from idea to testable prototype, the number of options explored, and above all, usability test results and live metrics. AI speed only counts if the page performs at least as well as your hand-built baseline and passes the accessibility audit.
7:56 Recap and try this now
Let's recap. Know the Figma essentials: frames, auto layout, components, variables, prototyping and Dev Mode. Use AI tools like Figma's AI, Figma Make, Stitch, v0 and Lovable for fast exploration, and treat their output as sketches. Prompt with your research and constraints. Audit every output for invented claims, accessibility and structure. And if you have developers, use the MCP server and Code Connect so code reuses your real components. Try this now. Write a content-rich prompt for one landing page, generate three options, run the audit checklist on the best one, and rebuild it with your own components or saved styles.
Why this lesson exists
In 2025 and 2026 design tools changed faster than at any point in the previous decade. Figma added AI features across its products, prompt-to-app tools appeared, and AI coding assistants began reading design files directly. For marketers this is good news: you can explore ideas, prototype landing pages and brief developers faster than ever. It is also a risk: it has never been easier to ship something generic, inaccessible or off-brand. This lesson gives you a practical map of the tools and a workflow that keeps humans in charge of the decisions that matter.
Tool names, plans and limits change often. The features described here were checked against the vendors' official documentation in September 2026; check current docs and your plan before relying on a specific feature.
The core Figma concepts every marketer should know
| Concept | What it is | Why it matters to marketers |
|---|---|---|
| Frames | Containers for screens or sections (like artboards) | One frame per screen or state; presets for phones and desktop |
| Auto layout | Frames that stack and space children automatically | Sections reflow when copy changes; consistent spacing |
| Components and variants | Reusable elements with properties (type, state) | Change once, update everywhere; states designed once |
| Styles and variables | Named colors, type, spacing and modes (for example light/dark) | Brand consistency; tokens developers can reuse |
| Prototyping | Links and interactions between frames | Clickable flows for usability tests |
| Dev Mode | Inspection view for developers with measurements and code hints | Smoother handoff |
| FigJam | Online whiteboard | Research synthesis, flows, workshops |
The AI layer: what exists now
AI inside Figma Design. Figma's AI tools can generate first-draft layouts from a prompt, rename and organize layers, rewrite or translate text in designs, generate or edit images, and create quick prototype connections. Figma's "First Draft" feature generates editable wireframes or designs from a description using Figma-built libraries; from May 2026 Figma introduced an agent (in beta and rolling out gradually) as the new entry point for this kind of work, with re-prompting, bulk edits and feedback on flows. AI features consume AI credits, which vary by plan and seat type.
Figma Make (prompt to prototype or app). Figma Make turns a prompt, and optionally an existing design, into a working, interactive prototype or web app built from code. It is available to try on the free Starter plan with more capability on paid plans; each prompt uses AI credits. Use it to test an interaction (a pricing calculator, a quiz, an onboarding flow) with real users before anyone writes production code.
Figma MCP server. The Model Context Protocol (MCP) is an open standard that lets AI assistants connect to tools and data. Figma's MCP server lets AI coding tools such as Claude Code, Cursor or VS Code with Copilot read design context — the layer structure, auto-layout rules, variables and components — instead of guessing from a screenshot. With Code Connect, components in the design can be mapped to the matching components in the codebase, so generated code reuses them. Figma offers a remote (hosted) server and a desktop server; the remote server can also read the code behind Figma Make files.
Other prompt-to-UI tools. Google's Stitch (a Google Labs experiment launched in 2025) generates multi-screen UI designs from text or images, exports to Figma and produces front-end code. Code-first tools such as Vercel's v0 and Lovable generate working web front ends from prompts. Website builders such as Framer and Webflow also include AI generation. These are useful for fast exploration and throwaway prototypes.
A human-in-charge AI design workflow
1. Research first Content priority list, user goals, anxieties (lessons 1–3)
2. Prompt with context Audience, goal, content list, brand tokens, constraints
3. Generate 3+ options Treat each as a sketch, not an answer
4. Pick and rebuild Rebuild the chosen direction with your components and variables
5. Check Accessibility (contrast, targets, focus, labels), claims, brand, legal copy
6. Test Clickable prototype or Make prototype with 5 target users
7. Hand off Dev Mode + MCP/Code Connect so code reuses real componentsHands-on: prompt a landing-page prototype, then audit it
Use Figma Make, Stitch or a similar tool. A strong prompt includes your content, not just a vibe:
Create a mobile-first landing page prototype for a free 30-minute ad-account audit
offered by a small marketing agency in Riyadh (English version; Arabic version later).
Audience: owners of e-commerce stores spending on Meta and Google ads.
Primary action: "Book my free audit" (opens a scheduler step).
Content, in this order:
1. Headline: "Free 30-minute ad account audit — find wasted spend before your next campaign"
2. Three benefits (recorded audit, three priority fixes, no obligation)
3. How it works: Book → share read-only access → audit call
4. Three testimonials (use obvious placeholders: "[Real testimonial with permission]")
5. FAQ: "Do you need admin access?", "Is my data safe?", "What happens after?"
6. Final CTA
Constraints: body text 16px minimum; buttons at least 44px tall; brand color #0F766E for
buttons with white text; visible focus styles; one primary CTA per section; no fake
urgency, no invented statistics or logos.Then audit the output before showing anyone:
AI OUTPUT AUDIT
[ ] Structure follows our content priority list (not the tool's default template)
[ ] No invented claims, numbers, logos, awards or testimonials
[ ] Text contrast >= 4.5:1; UI components >= 3:1 (check the brand color pairing)
[ ] Tap targets >= 24x24 CSS px minimum, ~44-48px preferred; focus visible
[ ] Form fields have visible labels; errors described in text
[ ] Works at 320px wide without horizontal scrolling
[ ] Copy is in plain language; legal/pricing text reviewed by a human
[ ] Rebuilt (or mapped) with our components and variables before handoffHands-on: connect Figma to an AI coding assistant (for teams with developers)
- In Figma, enable the MCP server (see Figma's MCP server guide for the current steps for the remote or desktop server).
- In your AI coding tool, add the Figma MCP server using the configuration from Figma's documentation, and authenticate.
- Select a frame in Figma, copy its link, and ask the assistant: "Implement this frame using our existing Button and Card components; use our design tokens; do not hard-code colors."
- Review the generated code like any pull request: accessibility, responsiveness, performance and tracking.
Risks and rules
- Privacy and confidentiality. Don't paste customer data or unreleased plans into tools your organization hasn't approved; check each tool's data-use settings.
- Intellectual property. Don't prompt tools to copy a competitor's site or a living designer's distinctive style; use your own brand assets and licensed images.
- Truthfulness. AI tools happily invent testimonials, statistics and client logos. Remove them. Fake proof is a consumer-protection problem, not just a design flaw.
- Accessibility. Generated designs often miss focus states, labels and contrast. Audit every time.
Worked example: a creator's course waitlist in one afternoon
A fitness creator in London wants to test demand for a new program. She writes a content priority list from her DMs, prompts Figma Make for a mobile waitlist page with a short quiz, and generates three variations. She keeps the quiz from one, the structure from another, and rebuilds the page with her saved brand colors. The audit catches an invented "10,000 members" badge and low-contrast gray text, both fixed. Five followers try the prototype over video calls; three misunderstand one quiz question, so she rewrites it. Only then does she build the real page in her website builder. (Illustrative scenario.)
How to measure success
Measure time from idea to testable prototype, the number of options explored before choosing, and — most importantly — the outcomes from usability tests and live metrics. AI speed only counts if the result performs at least as well as your hand-built baseline and passes the accessibility audit.
Key takeaways
- Learn the core Figma concepts: frames, auto layout, components and variants, variables, prototyping and Dev Mode.
- AI tools (Figma AI and its agent, Figma Make, Stitch, v0, Lovable) are fast for exploration; treat output as sketches, not answers.
- Prompt with your research: audience, goal, content order, brand tokens and constraints.
- Audit every AI output for invented claims, accessibility, structure and brand before testing or handoff.
- The Figma MCP server and Code Connect let AI coding assistants reuse your real components and tokens.
Check your understanding
Quick questions to lock in the lesson. They don’t count towards your certificate.
Put it into practice
Write a content-rich prompt for one landing page, generate three options in Figma Make, Stitch or a similar tool, run the AI output audit checklist on the best one, and rebuild it with your own components or saved styles.
Enrol for free to save your progress
Reading is always free. Enrol to keep your place, take the final assessment and earn a verifiable certificate.