More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Figma Workflow — Implement, Review, Optimize in 4 Phases

    2

    Implementing a Figma design in a single pass usually leaves visual drift, type errors, duplicated markup and loose Tailwind classes behind.

    $15

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    Figma Workflow — Implement, Review, Optimize in 4 Phases

    Figma Workflow — Implement, Review, Optimize in 4 Phases

    Example session with this skill installed

    /figma-workflow https://www.figma.com/design/QZhp5dSdNjU2fdjCiKkqyA/figma-enhance?node-id=10-2 — target file: src/pages/index.astro

    • Read your context and instructions
    • Compiled the figma workflow
    • Generated the app files

    The project is a fresh Astro 7 + Tailwind v4 starter with only the demo Welcome component in it. The Figma frame is a 1440 × 3365 landing page for a private-villa resort (header, hero, villa spaces, location, reservation, footer) that had already been tidied and componentized in Figma. The skill detected an Astro project, ran four phases one after another, and finished with one combined report.

    Phase 1 — Implementation

    Read the design context and tokens through the Figma MCP server, then built the page in src/pages/index.astro, replacing the starter content.

    • 4 components: SiteHeader, SiteFooter, CtaButton, VillaCard (the villa card is used three times, the CTA button three times)
    • 5 images saved as local webp files and used through Astro's <Image />; no Figma asset URL is left in the code
    • Fonts, colors and four text sizes added to @theme; spacing already mapped to Tailwind's default scale
    • data-node-id carried onto the matching elements

    Phase 2 — Review

    Compared the implementation with the Figma screenshot of the same node.

    • One real difference found and fixed: the header rendered 951px wide and the footer 755px instead of the full 1440px, because of a stray items-start on the root wrapper. Removing it put both back at 1440px with their inner elements at the Figma positions.
    • Every other section matched Figma within 1px on position, size and padding; total page height is 3364px against 3365px in Figma.
    • Type check: 0 errors, 0 warnings, 0 hints.

    Phase 3 — Optimization

    • Three repeated line-height values and two corner-radius values moved into @theme tokens (--leading-caption, --leading-small, --leading-body, --radius-brand, --radius-media)
    • The three section labels became one SectionEyebrow component
    • Values used only once (for example max-w-[720px]) were left inline on purpose

    Phase 4 — Tailwind Review

    • Arbitrary pixel values that divide cleanly by 4 were converted to scale utilities (min-h-[760px] became min-h-190, max-w-[720px] became max-w-180)
    • The language switcher links were wrapped in a proper <ul><li> list
    • Values off the 4px grid and one-off line heights were left as they are

    Final state

    CheckResult
    astro check0 errors, 0 warnings, 0 hints
    Biome checkno fixes needed
    buildsucceeds, 1 page
    data-node-id in the built HTML91, all unique
    Figma asset URLs left in code0

    What was not checked

    The review looked at the desktop layout and at one narrow width (500px); tablet and a true 390px phone width were not checked. Accessibility was reviewed by reading the code (landmarks, heading order, alt text, labels); color contrast and keyboard navigation were not measured. The language link points to a page that does not exist yet, and the footer policy links are # placeholders, as the design has no destinations for them.

    figma-workflow-implement-review-optimize-app.zip

    ZIP · project files

    Generated

    Example file from a real run - the skill writes it into your workspace.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Implementing a Figma design in a single pass usually leaves visual drift, type errors, duplicated markup and loose Tailwind classes behind. This skill splits the job into phases, each run by its own sub-agent with a focused prompt, and starts the next one only after the previous one has reported back.

    Who it is for

    People who already have a working environment: an Astro, React or plain-HTML project with a guidelines file (CLAUDE.md or AGENTS.md), and an agent connected to the Figma MCP server. This skill does not build that environment for you.

    Results depend on your Figma file

    The skill can only build what the design gives it. Without variables it falls back to arbitrary values, and without components the code is not split into components. Before you run it, check the frame with figma-audit (free): it scores layer naming, auto layout, variables and components, and tells you what to fix first.

    What it does

    • Detects your project type (Astro, React, or plain HTML/TypeScript) and picks the matching prompts and number of phases
    • Phase 1, Implementation: reads the design context, tokens and annotations through the Figma MCP server, reuses your existing components and @theme tokens, and builds the page or component following your project's agent guidelines (CLAUDE.md or AGENTS.md)
    • Phase 2, Review: compares the implementation with the Figma screenshot of the same node, fixes layout, style and responsive differences, resolves type errors, and runs code-style and accessibility checks
    • Phase 3, Optimization (Astro and React): organizes components and design tokens
    • Phase 4, Tailwind Review: cleans up Tailwind classes with the free tailwind-review skill when it is installed; skipped, and reported as skipped, when it is not
    • Carries Figma's data-node-id attribute onto the matching elements, so a later design change can be traced to the exact element that implements it
    • Ends with one combined report covering every phase

    How it works

    1. You give it a Figma frame or section URL
    2. It detects the project type and confirms the target file if you did not name one
    3. It runs the phases in order, one sub-agent at a time
    4. It summarizes what each phase did and changed

    What it is not

    It does not set up a project or install dependencies: it works inside a project that already exists and already has a guidelines file. The review phase compares your code with the Figma screenshot and does not require a browser; if your agent can start the dev server, it may also measure the rendered page. For very tall pages, split the design into section frames (Hero, Features, CTA) and run it once per section, otherwise the context gets too large.

    Requirements

    Runs inside an agent connected to the official Figma MCP server, in a project with a CLAUDE.md (or AGENTS.md) that describes your conventions: the implementation follows it strictly, so it sets the quality of the result. The review and optimization phases run scripts from your package.json, by project type: Astro uses astro check plus your lint/format script, React uses build plus your lint/format script, and plain HTML uses build. The lint/format script can be Biome, ESLint, Prettier or whatever you use (check, lint, format); without one, that step is skipped and the report says so. Node.js is used for project detection. Optional: the free tailwind-review skill for Phase 4.

    Other agents

    Written for and tested on Claude Code. It is plain Markdown, so you can ask your own agent to adapt it: swap the guidelines file name, the Agent tool used to launch sub-agents, and the skill lookup paths. Other agents have not been tested.

    Try it free first

    Try it Free on Agensi does not apply to this skill: the free trial runs on Agensi's own servers, which have neither your project files nor a Figma connection. Use the example session above to see what a real run looks like.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for Frontend & Web Apps.

    Works on one Figma frame or section per run; split very tall pages into section frames. Needs an existing project with a guidelines file (CLAUDE.md or AGENTS.md) and the type-check / build scripts for your project type; the lint/format step runs whatever linter your project uses and is skipped if there is none. The review phase compares code with the Figma screenshot and does not require a browser; measuring the rendered page depends on what your agent can do. Tested on Claude Code only. Agensi's "Try it Free" does not apply, since its sandbox has no project files or Figma connection.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Accounts
    official Figma MCP
    Software
    Node.js

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    Allowed Hosts

    api.figma.com

    File Scopes

    src/**
    public/images/**
    *.html
    package.json
    CLAUDE.md
    AGENTS.md

    This skill runs Terminal commands to detect the project type and to run the project's own astro check, build and lint scripts through its package manager, and may start the project's own dev server to measure the rendered page. It reads existing components, design tokens and the project's agent guidelines file, and writes the implemented page or component (plus review and optimization fixes) into the project. The skill's own code makes no network calls; the design is read through the official Figma MCP server the user's agent already has connected. How the Figma MCP server is connected differs by client; see the Figma MCP catalog for setup guides: https://www.figma.com/mcp-catalog/

    Listed1 month ago
    Updated1 month ago

    What's inside

    Frequently Asked Questions

    No. Agensi’s free trial runs on its own servers, which have neither your project files nor a Figma connection. Buy the skill and run it on your own project; the example session above shows what a real run produces.

    You need some guidelines file that describes your conventions, such as CLAUDE.md or AGENTS.md. The implementation phase follows it strictly, so the result reflects it. If you have no project or no guidelines file yet, this skill is not the right starting point.

    No. It is a free skill on Agensi and Phase 4 uses it when it is installed. Without it, Phase 4 is skipped and the final report says so.

    Astro, React and plain HTML/TypeScript. Astro and React get four phases; plain HTML gets three, without the optimization phase.

    It was written for and tested on Claude Code only. It is plain Markdown, so you can ask your own agent to adapt it: the guidelines file name, the Agent tool that launches sub-agents, and the skill lookup paths.

    No. The review phase compares your code with the Figma screenshot of the same node. If your agent can start the dev server, it may also measure the rendered page, as it did in the example session, but that is not required.

    The official Figma MCP server connected to your agent, and read access to the design.

    New in Frontend & Web Apps