ByFigma agent skills are reusable, plain-English instructions you teach the Figma AI agent once and then trigger anytime with a forward slash, so you never have to re-explain the same design workflow twice. Figma rolled the feature out through 2026, alongside a library of 50-plus ready-made skills and the ability to author your own. This guide covers what skills actually do, how to build one, and how to use them without breaking your design files.
If you have used the Figma agent to generate layouts or clean up a file, you already know it can lose context between chats or need the same instructions repeated every session. Skills fix that specific problem. Once you understand how they are structured, you can turn any repeatable task, from accessibility checks to type-scale generation, into a one-word command.
What Are Figma Agent Skills?
These are saved sets of instructions, written in plain English, that you teach the Figma agent and can then invoke in any chat by typing a forward slash followed by the skill’s name, according to Figma’s help center documentation. A skill can be as simple as a formatting rule or as complex as a multi-step design system audit, and once saved it behaves like a custom command built specifically for your files.
The feature exists because the Figma agent, like most AI design agents, does not retain project-specific conventions between sessions unless you tell it every time. The feature solves that by packaging your team’s conventions, naming rules, spacing systems, or QA steps into something the agent can recall on demand, rather than something a designer has to type out from memory in every new chat.
How Do You Create a Custom Figma Agent Skill?
Open a Figma file, start a chat with the Figma agent, and ask it directly to turn a task into a skill, for example by describing a workflow and adding “make this a skill I can reuse.” The agent drafts the instructions based on the context in your file and saves it so it can be triggered later with a slash command, per Figma’s own walkthrough in Figma’s “Try These 10 Skills” blog post.
- Open the Figma agent chat panel inside the file where the workflow already happens.
- Describe the task you want repeated, as specifically as you would explain it to a new teammate.
- Ask the agent to save the instructions as a skill, giving it a short, memorable name.
- Test the skill by triggering it with a forward slash in a new chat to confirm it behaves as expected.
- Refine the wording if the output drifts, since skills are just editable text instructions, not locked code.
Because a skill is plain-English text rather than a script, editing one is as simple as rewriting the instructions and saving again. That makes them far more approachable for design teams than building a custom plugin, which requires actual code.
What Does a Real Figma Agent Skill Look Like?
It helps to see a concrete example rather than an abstract description. Imagine a product design team that always wants new form screens to follow the same pattern: labels above fields, 16px vertical spacing between inputs, error text in red directly below the affected field, and a primary button pinned to the bottom of the frame. Instead of typing that out every time, the team writes it once as a skill named /form-layout.
From then on, any designer on the team can select a rough wireframe and type /form-layout, and the agent applies the exact spacing, label position, and error-state rules the team defined, without anyone needing to remember or re-explain the spec. That is the practical value of a skill like this: it turns a paragraph of tribal knowledge into a single reusable command that behaves the same way for every designer who uses it.
Why Did Figma Build Agent Skills?
Design tools in 2026 are converging around the same idea: real-time collaboration merged with AI generation, so teams can prompt, refine, and approve work inside the same workspace instead of bouncing between a chat window and the canvas. Figma agent skills are Figma’s answer to a specific weakness in that model, which is that AI agents tend to forget project-specific conventions the moment a chat session ends.
By letting teams save those conventions as named, triggerable skills, Figma is effectively building an institutional memory layer on top of its AI agent. A new hire can run the same /accessibility-check or /make-a-type-scale skill a senior designer built months earlier and get identical, consistent output, which matters more as more of the actual pixel-pushing work shifts from manual editing to prompting.
How Do Figma Agent Skills Fit Alongside Canva and Adobe’s AI Tools?
Figma is not alone in pushing AI deeper into the design workflow. Canva has been merging multiplayer editing with AI generation through features covered in our Canva Magic Studio guide, and Adobe has taken a different approach centered on licensed training data for tools like the generative features detailed in our Photoshop Generative Fill guide. They sit in a slightly different lane from both: rather than generating new visual content from a prompt, skills mostly encode process and consistency rules for work you are already doing.
That distinction matters when deciding which tool to reach for. If you need to generate a brand-new image or layout from a text prompt, Canva’s and Adobe’s generative tools are built for that. If you need every designer on a team to apply the same spacing, naming, and QA rules to work that already exists in Figma, agent skills are the more direct fit, since they operate on your actual file rather than producing a new asset from scratch.
What Are Some Practical Skill Ideas by Design Role?
The most useful skills tend to be narrow and specific to a role’s daily repeat work rather than broad, general-purpose commands. A few starting points, organized by the kind of designer building them:
- UI designers: a skill that audits spacing tokens across a screen and flags any value outside the design system’s approved scale.
- Brand designers: a skill that checks logo clear-space and minimum size rules before a file is exported for a partner.
- Product designers: a skill that generates empty-state, loading-state, and error-state variants for any screen you select.
- Design system maintainers: a skill that scans a file for components not pulled from the shared library and lists them for cleanup.
- Accessibility leads: a skill that checks color contrast and tap-target size against WCAG guidelines before a frame ships.
Start with whichever task on this list you personally repeat most often in a given week. A skill only pays off once it replaces a task you would otherwise redo by hand, so the best first skill is rarely the most impressive one, it is the most boring, repetitive one.
How Do You Trigger a Skill in the Figma Agent?
Type a forward slash in the Figma agent chat box, and a list of your saved and library skills appears, similar to how slash commands work in Slack or Notion. Selecting one runs its saved instructions immediately, without you needing to retype the workflow. You can also browse the full library from Figma’s AI skills panel and add community-published skills to your own account before triggering them the same way.
What Are the 10 Featured Figma Skills to Start With?
Figma highlighted ten starter skills to show off what the feature can do, covering common jobs like design QA and type systems. Two of the most useful for daily work are /image-audit, which checks every image in a file for export-readiness, and /make-a-type-scale, which builds a full type scale from a piece of selected text, both documented in Figma’s official skills blog post.
/image-audit: flags images that are missing alt text, oversized, or not export-ready./make-a-type-scale: generates a consistent type scale starting from one selected text layer.- Accessibility-check style skills: scan a frame for contrast and tap-target issues before handoff.
- Form-layout skills: apply consistent spacing and input patterns across a set of form screens.
- Design-system audit skills: check components against your library for drift or duplicate styles.
None of these require writing a line of code. They work the same way whether you are polishing an onboarding flow you built with Figma Motion animations or organizing components with Figma’s nested folders.
How Do Figma Agent Skills Compare to Figma Make and Plugins?
Skills, Figma Make, and plugins all extend what you can do inside Figma, but they solve different problems and require different amounts of technical effort. The table below compares them directly.
| Feature | What It Does | Skill Required | Best For |
|---|---|---|---|
| Figma agent skills | Reusable, slash-triggered instructions for the AI agent | Plain English, no code | Repeatable design workflows and QA steps |
| Figma Make | Generates working prototypes and apps from prompts | Plain English, no code | Turning an idea into a functional prototype |
| Figma plugins | Adds custom functionality via installed code | JavaScript development | Deep, permanent customization of the editor |
In practice, many teams use all three together: a plugin for a permanent tool they rely on daily, Figma Make for spinning up a quick prototype, and Figma agent skills for the smaller, repeatable steps in between, like the kind of AI-assisted image editing covered in our guide to Figma’s AI image editing tools.
Can Skills Reference Other Skills?
Yes. Skills can call other skills, which lets you chain several small workflows into one larger command. Figma’s own example describes a /new-feature skill that invokes /form-layout to lay out input sections and then /accessibility-check to review the result, turning a multi-step process into a single slash command instead of three separate requests.
That chaining is where skills start to resemble small, composable programs rather than one-off prompts. A design system team could build a handful of narrow skills, one for spacing, one for naming, one for accessibility, and then combine them into a single onboarding-flow skill that runs the whole checklist automatically.
Figma’s community skills library lets you publish a skill you built and browse ones other teams have shared, so you can reuse patterns for common jobs like dashboard layouts, onboarding flows, and settings pages without writing them from scratch, according to Figma’s help documentation. Publishing works similarly to sharing a component library: once a skill is public, anyone can add it to their own agent and trigger it inside their own files.
For teams that do not want to publish publicly, skills can also stay private to a single file or organization, which is the more common setup for anything involving proprietary naming conventions or internal design-system rules that should not leave the company.
How Long Does It Take to Build a Useful Skill Library?
Most teams do not sit down and plan a full skill library in one sitting. A more realistic path is opportunistic: the next time you catch yourself typing the same instructions into the agent for the third time in a week, that is the signal to stop and save it as a skill instead. Over a month or two, a small design team typically ends up with somewhere between five and fifteen skills covering their most common repeat work, which is usually enough to remove the bulk of the copy-pasted instructions people were keeping in a shared doc before.
The bigger time investment is not writing the first draft of a skill, it is refining the wording after watching it run a few times. Because the underlying instruction is plain English rather than code, small ambiguities show up as inconsistent output rather than an error message, so expect to revise a new skill two or three times before it behaves reliably across different files and different starting layouts.
What Should You Avoid When Writing Skill Instructions?
The most common mistake is writing a skill the way you would write a mission statement instead of a checklist. Instructions like “make the design feel more premium” give the agent nothing concrete to check itself against, while instructions like “increase card padding to 24px and switch body text to a 16px/24px line-height pairing” leave far less room for inconsistent results between runs.
A second mistake is bundling too many unrelated steps into one skill. A single command that tries to handle layout, copywriting, accessibility, and export settings all at once is harder to debug than three or four smaller, named skills that each do one job well and can be chained together, the same way the earlier /new-feature example combines /form-layout and /accessibility-check into a larger workflow.
What Are the Limitations and Risks of Using Agent Skills?
Because a skill is a plain-English instruction rather than deterministic code, the agent can still interpret it inconsistently between runs, especially for vague or ambiguous wording. Skills work best when they are specific: naming exact layer names, exact spacing values, or exact contrast ratios, rather than general goals like “make it look clean.”
There is also a review step you should not skip. Community-published skills run inside your files with the same permissions as any other agent action, so treat an unfamiliar public skill the way you would treat an unfamiliar plugin: read what it claims to do before running it on a production file, and test it on a duplicate file first if the instructions are unclear.
Frequently Asked Questions
What exactly are Figma agent skills?
Figma agent skills are saved, reusable instructions for the Figma AI agent that you trigger with a forward slash command, instead of retyping the same workflow request in every chat.
Do I need to know how to code to build a Figma agent skill?
No. Skills are written in plain English inside a chat with the Figma agent, unlike plugins, which require JavaScript development to build and maintain.
Can I use skills that other designers have published?
Yes. Figma’s community skills library lets you browse and add skills published by other teams, covering common patterns such as dashboard layouts, onboarding flows, and settings pages.
How is a skill different from a Figma plugin?
A plugin is installed code that extends the editor permanently, while a skill is a plain-English instruction the AI agent follows only when triggered, with no development environment required.
Can one skill trigger another skill?
Yes. Skills can reference and invoke other skills, so you can chain several narrow workflows, like layout, accessibility, and naming checks, into a single multi-step command.
Are Figma agent skills available on the free plan?
Access to the Figma agent and its skills library depends on your Figma plan and AI credit allowance, so check your account’s current plan details in Figma directly, since availability has changed as the feature has rolled out through 2026.
Figma agent skills turn one-off AI prompts into a permanent, shareable part of your design workflow. Start with one or two of the ten featured skills, get comfortable with how specific the instructions need to be, and then build a small library of your own for the tasks your team repeats most, whether that is generating a type scale or reviewing image exports before handoff.
Subscribe for Newsletter
