SkillAgentSearch skills...

layerwright

Turn Claude Design and HTML into editable Figma layers (Auto Layout, your Design System components), and Figma frames into code with your own React components. MCP server + Figma plugin for Claude Code and Cursor.

Install / Use

claude mcp add shayan-m81 -- npx -y github:shayan-m81/layerwright

If the server publishes to npm under a different name, use that package instead — check the repo README.

About this skill
🔌

MCP Server

Model Context Protocol server

Quality Score

84/100

Category

Design

Supported Platforms

Claude Code
Claude Desktop
Cursor

Our assessment of layerwright

layerwright scores 84/100 on our quality scale, 173rd of 260 Design skills we index.

Its MCP Server is 25 KB long, well organised into 18 sections with 4 code examples: a thorough specification that gives an agent plenty to work with.

It has 10 GitHub stars, so there is little community track record yet; judge it on its content.

Substance
30/30
Structure
20/20
Description
15/15
Adoption
4/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 35 days ago, so layerwright is actively maintained.
  • It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 97/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-11-12. Automated pattern scan on 2026-11-12. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.

layerwright compared with similar skills

All 4 of these similar skills score higher than layerwright; compare them before choosing.

SkillScoreStarsUpdatedFormat
layerwright (this skill)by shayan-m81841035d agoMCP Server
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Agent-Reachby Panniantong100112.3k8d agoCLAUDE.md
rufloby ruvnet10081.9ktodayCLAUDE.md
headroomby headroomlabs-ai10079.8ktodayCLAUDE.md

Frequently asked questions

How do I install layerwright?
Run claude mcp add shayan-m81 -- npx -y github:shayan-m81/layerwright. The install tabs above show the steps for each supported agent.
Which AI agents does layerwright work with?
It is written for Claude Code, Claude Desktop and Cursor, as a MCP Server file. Other agents that read the same format can often use it too.
Is layerwright safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 97/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is layerwright still maintained?
The repository was last updated 35 days ago, so layerwright is actively maintained.

Layerwright

Turn Claude Design and Claude Code designs into native, editable Figma files, and Figma designs into code that uses your own components.

CI npm MIT

Demo: a request sent from the Layerwright window in Figma; a Claude Code session builds mobile versions of two Persian screens with Auto Layout while its cursor shows the work

<sub>Select a desktop screen in Figma, press Mobile in the Layerwright window and send it to a Claude Code session. The session builds 390 px mobile versions of two right-to-left Persian screens with Auto Layout, its cursor showing where it works. The window lists the connected sessions and each request's answer. (2× speed.)</sub>

npx layerwright init   # in your project, then open the plugin in Figma desktop (see Quickstart)

Layerwright is an open-source MCP server and Figma plugin for Claude Code, Codex and Cursor. It imports HTML, such as a Claude Design "standalone HTML" export, into Figma as real frames with Auto Layout, text, images and vector icons. It builds new screens from your own Design System: real component instances, variables and text styles. And it works the other way: select a Figma frame and Claude implements it in your codebase with your existing components and tokens, then checks that it did.

Why

Claude Design exports to HTML, PDF, PPTX and Canva, but not to Figma. Claude Code can write UI code, but it has no native way to put a design into a Figma file your team can edit. Most "HTML to Figma" tools either paste a flat picture or need a cloud account.

Layerwright closes that gap locally:

  • Claude Design to Figma: export standalone HTML, run one command, and you get editable Figma frames.
  • Claude Code to Figma: ask Claude for a screen or a flow, and it is built from your Design System's components.
  • Figma to code: select a frame, and Claude implements it with the React components you already have (not a new copy of each button), mapped once and shared with your team.
  • Ask from Figma: select layers, press Mobile version or Build in code in the plugin window, and a session starts on it.
  • No API keys, no cloud, no account. Everything runs on your machine. The plugin only talks to localhost.

Features

Bring designs into Figma

  • HTML to Figma import (import_html_to_plan)
    • Flexbox becomes Auto Layout: direction, gap, padding, alignment and wrap. Fixed CSS sizes stay fixed.
    • Colours, borders, radii, shadows, gradients, fonts, line height and letter spacing come across.
    • Text with inline <b>, <span> and <a> is one text layer with styled ranges.
    • Pictures come along: images (PNG, JPEG, GIF, WebP, AVIF), SVG files and inline SVG as vectors, sprite icons, CSS background images, CSS-mask icons in their colour, icon fonts and <canvas>, in both modes.
    • Desktop (1440) and mobile (390) screens are rendered side by side.
    • RTL is supported (Persian, Arabic, Hebrew). Rows keep their visual order and text stays right-aligned.
  • Pixel-faithful mode (figma_import_html) for review boards and art-heavy pages: exact layers, variant sets built from states, and instance swaps.
  • AI design to Figma from a prompt. Claude writes a typed Design Plan (a JSON DSL). The plan is validated and resolved against your components, variables and text styles, then built deterministically. Claude never writes Figma plugin code.
  • Prototypes. Click, hover and timed interactions, navigate / overlay / swap / back, smart animate and push transitions, scrolling frames and flow starting points, in plans or on existing frames.
  • Icons and pictures in one step (figma_import_assets): a folder of SVGs becomes editable vectors (or components, named by their path), pictures become image layers, in a grid on the page.
  • No AI needed for a plain import. npx layerwright import ./design.html --to-figma builds it in the open Figma file.
  • Fonts from exports: npx layerwright fonts ./export --install installs the TTF/OTF fonts a design ships.

Use your Design System

  • Design System automation. After a Design System scan, buttons, inputs and links become your real Figma components when they clearly match, and you can map any element yourself (mappings: [{ selector, component }]).
  • Design System sync. After an import, figma_analyze_design({ mode: "sync" }) swaps buttons and pills for your DS components (the variant that looks closest), gives text your text styles by size and weight, and binds colours to your variables and styles. You approve it; originals are kept hidden.
  • Audit and fix existing frames. Hard-coded colours become variables, raw text gets text styles, and custom buttons become component instances, in groups you can pick. Originals are hidden, never deleted.
  • Work on existing designs (figma_edit). Rename, move, duplicate, delete, restyle (font weight, size and family, text and fill colours), and turn existing frames into components or variant sets with text properties, in one undo step.
  • Figma back to a plan. Any subtree exports as an editable Design Plan to clone, refactor or implement in code: layout, tokens, text styles, instances, gradients, shadows, blurs, shapes, and vectors or boolean shapes as SVG icons.

Figma to code

figma_inspect → code_scan_components → code_mapping → code_verify_usage

  • Reads the frame as a plan: layout, spacing and colour tokens, text styles, and every component instance with its variant and properties.
  • Scans your React / Next.js codebase for exported components (and Tailwind or shadcn/ui) and suggests which code component each Figma component is.
  • The mappings you confirm are saved in .layerwright/mapping.json; commit it and the whole team reuses them.
  • Claude implements the frame with the mapped components and your theme tokens; code_verify_usage then flags design components that weren't used, raw <button> / <input> duplicates, and arbitrary Tailwind values.

Work together with your agents

  • Several sessions, several files. Claude Code, Codex and Cursor sessions on your computer share one connection to the plugin, with no port to configure. Open Layerwright in several Figma files at once: each stays connected, and each session works in one file (the one you send it a request from, or the one it's told to use). A change never lands in another file than the one the session works in. Sessions in a project that uses Layerwright join when they start; any other session joins on its first Figma call, and a session that hasn't used Layerwright for 30 minutes leaves until its next Figma call, so the plugin window lists only the sessions you use with Figma now, and what each is doing (sessions name themselves after their task). Your selection and requests from the window go to the session you pick there, until you pick another, and a session never overwrites a layer another one just changed.
  • Ask from Figma. Select layers in the plugin window, pick a session and send a request: Build in code, Polish design, Make component, Mobile version, or your own words. A Claude Code session with the plugin starts on it by itself (the plugin's monitor wakes the session); Codex gets it on its next Figma step or with /layer:inbox. Progress and the session's answer come back to the window.
  • Notes on the canvas. Type a text layer that starts with @<session> (or @claude when one session is connected) on the frame it's about, and that session gets it like a request from the window. Only notes you type count: edits by collaborators and text Layerwright writes never start a task.
  • AI cursor and a working toast. While a session works in Figma, a cursor in its colour shows it like a collaborator's, from its first step to the end of the task: it reads where the session reads, drag-selects and works on what it changes, thinks between steps, and goes once the session is done or quiet. Its tag is one short line: the session's name and what it's doing. It stays on while you keep working in the file (select, edit, change page), so you always see which session is at work and where; while the session waits for your answer it waits still, just above the frame, and it never takes your selection. Every undo step is closed with the cursor taken off the canvas, so no step holds one. A toast at the bottom of the canvas says what a session is doing too; it is never a layer. Questions show in the plugin window and on the cursor (Settings → AI cursor turns both off).
  • Figma links. Ask for a link to the selection, a frame, a section or a page (figma_link); what a session builds or selects comes back with links. Paste a Figma link to a session and it finds the layer, opens its page and works in its file.
  • A guide in the window. The ? in the plugin window's header explains each tab, the actions and canvas notes. It opens by itself the first time.
  • /layer: commands in Claude Code and Codex. init installs the Layerwright plugin for the agents it finds (it asks; Claude Code by default): /layer:help, /layer:connect, /layer:import, /layer:design, /layer:edit, /layer:code, /layer:check, /layer:components, /layer:prototype, /layer:shot, /layer:skills, /layer:inbox, /layer:update, /layer:doctor, /layer:report.

Check, learn and stay safe

  • You see what was built. figma_export_image renders any node, and compares it with the source HTML (or another node) with a diff heatmap. save: true writes the PNG to .layerwright/exports/ so the agent can show it to you (/layer:shot).
  • Accessibility and critique. WCAG contrast (on the real background), touch-target and text-size checks, plus consistency signals; Claude uses them with a picture in a critique loop to polish what it builds.
  • Safe by default.
    • Every run is one undo step, and a failed run rolls back completely.
    • Results are checked against the plan: structure, sizes, variants, text overrides and prototype links.
    • Existing nodes change only after you approve; deleting without approval only hides and labels a layer.
    • Everything Layerwright creates is tagged, so figma_cleanup can list and remove a session's leftovers.
    • Only your paired plugin window and your own sessions can use the local connection: web pages in your browser can't.
  • Learns per project. Font substitutions, mappings and component choices are reused next time, your corrections are kept as notes, and recurring problems come with a hint (.layerwright/memory.json, shareable). npx layerwright report drafts a redacted issue from them for you to send.
  • Updates in one step. When a newer Layerwright is out, Claude Code says so as a session starts (once a day), and so do the plugin window and doctor. /layer:update, the window's Update button (a session does it for you) or npx -y layerwright@latest update (any folder) updates the Figma plugin, the /layer commands and the server they run; then /reload-plugins (or a new session) and reopen the plugin in Figma.
  • Your own skills. Next to the skills that ship with it, press Create a skill with Claude in the plugin window's Skills tab: say what it should do, and it opens Claude (the app, a terminal or VS Code) with /layer:skills new … filled in, or asks a connected session, and Claude drafts it with you. You can also add one from a link, or write it yourself in the Skills tab (edit it there later). They stay on your computer across updates.

Quickstart

Truncated for display — read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars10
CategoryDesign
Updated1mo ago
Forks1

Languages

TypeScript

Trust signals

97/100

From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.

1 info