Most people get mediocre output from Figma's AI agent and blame the agent. The output is mediocre because the prompt is, and the gap between a junior prompt and a senior one is enormous, larger than the gap between two designers using the tool the same way. Give the agent "make a dashboard" and you get the average dashboard. Give it what a senior designer would actually specify and you get something worth using. The tool didn't change. The instruction did.
Prompting a design agent well is not about clever phrasing or magic words. It's about supplying the judgment the agent doesn't have, in the order it needs it. This piece gives you the framework a senior designer's prompts follow, shows weak-versus-strong prompt pairs so you can feel the difference, and covers how prompting changes when you're building reusable agent skills rather than one-off requests.
Why most agent prompts underperform
Most people get mediocre output from Figma's AI agent and blame the agent.
The core misunderstanding is treating the agent like a search engine, where a few keywords should produce the right result. A design agent isn't retrieving a right answer; it's generating one from whatever you gave it, and a thin prompt gives it almost nothing to work with except its training average. So it returns the average, which is the generic output everyone complains about.
A senior designer, briefing a junior, would never say only "make a dashboard." They'd say who it's for, what it needs to do, what it must include, what to avoid, and what "good" looks like. That's not because juniors are dim; it's because the work requires those decisions, and someone has to make them. When you prompt an agent, you're the senior and the agent is the junior, and every decision you leave out is a decision the agent makes for you, badly, by defaulting to the mean. Underperforming prompts are underspecified prompts. The fix is to specify.
This is the same principle behind the brief becoming the real deliverable: the value has moved into the instruction, and a vague instruction wastes the tool.
The senior prompt framework
Strong prompts, across any design agent, tend to include the same four things, in roughly this order. Think of it as the brief you'd give a junior, compressed.
Context: who and what for. Name the actual user and their situation, and the product context. "A first-time user setting up their account on mobile" tells the agent something specific to design for; "a user" tells it nothing, so it designs for a generic nobody. Context is what steers the agent off the average toward your actual case.
Task and outcome: what this needs to achieve. State the job as a result, not just a noun. Not "a settings page" but "a settings page where a user can change their plan and update payment in the fewest steps." The outcome gives the agent something to optimize toward instead of just a category to fill.
Constraints: the boundaries. This is where you name your design system, the states that must exist, and what to avoid. "Use our existing components and tokens, include empty and error states, no gradient hero" does more to raise quality than any amount of adjectives, because it fences the agent out of its worst defaults and into your system.
References and acceptance criteria: the target and the test. Give a concrete reference the agent understands ("structured like a Stripe settings page, calmer") so it anchors to something real, and state how you'll judge the result ("done means a user can change their plan in two clicks and never sees a blank screen"), which doubles as your review checklist. This is the same discipline as prompt engineering for designers, pointed at the Figma agent specifically.
Supply those four and the agent has what a junior would need to do the job well. Skip them and you've asked a junior to read your mind.
Weak versus strong, in practice
The framework is abstract until you see it applied. Here are paired prompts, the kind of request most people type, and the senior version of the same request.
Weak: "Make a pricing page." Strong: "A pricing page for a B2B SaaS product with three tiers, aimed at a decision-maker comparing us to competitors. The goal is to make the middle tier the obvious choice for most teams. Use our existing components and color tokens. Include a comparison of what's in each tier, an FAQ section, and a clear single call to action per tier. Avoid a busy hero; keep it scannable. Reference the calm structure of Linear's pricing page. Done means someone can tell in ten seconds which tier fits them."
Weak: "Design an onboarding flow." Strong: "A three-step onboarding flow for a first-time user of a project-management app on desktop, whose goal is to create their first project and invite one teammate. Each step should do one thing and show progress. Include the empty state a brand-new account starts from and a skippable path for users who want to explore first. Use our design system. Reference the low-friction feel of a good consumer app onboarding. Done means a new user reaches their first created project without confusion."
Weak: "Make this look better." Strong: "Improve the visual hierarchy of this screen so the primary action is unmistakable and the secondary information recedes. Keep our tokens and spacing scale, don't introduce new colors. The problem is that everything currently has equal weight. Reference how a well-designed dashboard uses one clear focal point per view."
Read the strong prompts and notice they're not longer for the sake of it. Every added sentence supplies a decision the agent would otherwise get wrong: who it's for, what success is, which system to use, what to avoid, what to aim at. That's the whole skill.
Prompting for skills and connectors
There's a second mode of prompting worth understanding, because Figma's agent can now do more than answer one-off requests. When you're building a reusable agent skill, a saved capability the agent can repeat, or wiring the agent to external sources, the prompting shifts from describing one output to describing a repeatable process.
The difference is that a one-off prompt specifies a result, while a skill prompt specifies a procedure and its rules: what the skill should do every time, what inputs it takes, what standards it must always apply. A skill that generates on-brand social assets, for instance, needs its constraints baked in once, the tokens, the formats, the do-nots, so every future run inherits them, rather than you re-specifying them each time. Getting these reusable skills right is its own topic, covered in the piece on the Figma agent building its own skills, but the prompting principle carries over: the more of your judgment you encode into the skill up front, the better and more consistent every run is. A vague skill produces vague output forever; a well-specified one turns your standards into something the agent applies automatically. In practice you create a skill by asking the agent to build one from the context in a file, then invoke it with a slash command, and the agent can also connect to outside tools like Notion, Slack, GitHub, and Atlassian to pull in real context.
Five things worth prompting the agent for
Once you prompt well, some jobs pay off more than others, because the agent is strongest at high-volume, pattern-following work that used to eat a designer's afternoon. Five where a well-specified prompt reliably saves real time:
Generating variations on a screen you've already designed, to explore alternatives fast, when you hand it the original plus clear constraints and let it vary within them.
Producing the states you'd otherwise build by hand, empty, loading, error, when you name them explicitly and give real copy direction rather than letting it invent placeholder text.
Filling out a set from a pattern: turning one designed card into a coherent grid, or one form field into a full form, given the system to follow, so you design the unit and let the agent multiply it.
Drafting the first version of a standard layout, a settings page, a pricing table, a standard form, so you refine from something rather than start from a blank frame, with your constraints supplied up front.
Applying a consistent change across many elements when you can state the rule precisely, which turns a tedious sweep into a single instruction.
The common thread is that each rewards specification and punishes vagueness, and each hands the agent the repetitive part while you keep the judgment. That division, agent does the volume, you supply the standard and the review, is where the tool actually earns its place in a real workflow. It's the same trade the tested scorecard of Figma's AI features evaluates feature by feature.
Start Monday
Take one request you gave the agent recently that produced disappointing output, and rewrite it using the four-part framework: add the user and context, state the outcome, name your constraints and required states, and give a reference plus what "done" means. Run both versions and put the outputs side by side. The difference will be obvious, and it will retrain how you prompt faster than any list of tips, because you'll have felt the gap yourself. Then save your best prompts, they become a starting point you reuse, and the seed of the reusable skills that make good output automatic.
The agent is only as good as the judgment you give it. Stop typing categories and start giving it the brief you'd give a junior, and the same tool that produced generic output starts producing work worth shipping. The magic was never in the prompt phrasing. It's in the decisions you stopped leaving out.