figma-to-vanilla
Health Uyari
- License — License: MIT
- Description — Repository has a description
- Active repo — Last push 0 days ago
- Low visibility — Only 8 GitHub stars
Code Gecti
- Code scan — Scanned 3 files during light audit, no dangerous patterns found
Permissions Gecti
- Permissions — No dangerous permissions requested
Bu listing icin henuz AI raporu yok.
Figma to Vanilla is a collection of specialized AI Agent Skills for transforming Figma designs into accurate, responsive, and maintainable websites using native HTML, CSS, and JavaScript. Covers the complete Figma-to-Web workflow, including design analysis, MCP integration, layout implementation, visual verification, and production preparation.
Figma to Vanilla
From Figma designs to production-ready websites.
A modular AI Agent Skill for building responsive websites with HTML, CSS, and Vanilla JavaScript.
Overview · Who Is This Project For? · Features · Technology Stack · Architecture · Supported AI Agents · Installation · Workflow · Limitations · Requirements
Overview
Figma to Vanilla is a modular AI Agent Skill designed to turn Figma designs into accurate, responsive, and maintainable websites using native web technologies.
It provides AI coding agents with a structured development methodology covering the entire Figma-to-Web workflow — from design analysis and layout implementation to responsive behavior, animations, visual verification, and production preparation.
Instead of relying on a single large prompt, the project uses a modular architecture with a main skill and dedicated technical references.
One design. One structured workflow. Clean, framework-free code.
Who Is This Project For?
figma-to-vanilla is designed for developers, web studios, and designers who need to turn Figma designs into high-quality, responsive, and functional web interfaces using native HTML, CSS, and JavaScript.
The project is intended for several audiences:
- HTML/CSS developers and frontend engineers. To quickly generate ready-to-use HTML/CSS/JS markup from Figma without being tied to React, Vue, or other frameworks.
- Web studios and freelancers. To speed up the development of landing pages, corporate websites, promotional pages, and other web projects.
- CMS developers. To prepare HTML/CSS/JS markup that can be integrated into WordPress, Laravel, PHP projects, and other CMS or backend systems.
- Designers and product teams. To quickly generate a responsive web version of a design that can be presented to clients and team members, used to discuss its structure and visual implementation, and serve as a starting point for further development.
The main goal of the project is to shorten the path from a Figma design to finished web markup while keeping the output technology-independent, easy to customize, and ready for integration into existing projects.
Features
|
🎨 Figma Integration Retrieve and analyze design information directly through Figma MCP. |
📐 Layout Analysis Understand Auto Layout, Layout Grid, spacing, dimensions, and positioning. |
🧩 Component Implementation Translate Figma Components, Component Sets, and Variants into reusable structures. |
|
📱 Responsive Development Build fluid layouts, responsive containers, and breakpoint-specific adjustments. |
🎯 CSS Architecture Apply CSS variables, BEM methodology, and consistent styling conventions. |
🔤 Typography & Assets Implement fonts, typography, images, SVG files, and favicons. |
|
✨ Animations Implement animations, transitions, and interactive states. |
🔍 Visual Verification Compare the implementation with the original Figma design and refine visual discrepancies. |
🚀 Production Preparation Prepare production files, minify CSS and JavaScript, convert raster images to WebP, and organize the website for deployment. |
Figma Design Support
The skill supports the analysis and implementation of the following Figma design features:
| Figma Feature | Implementation |
|---|---|
| Auto Layout | CSS Flexbox layouts |
| Layout Grid | CSS Grid and responsive containers |
| Components | Reusable HTML structures |
| Component Sets & Variants | Component states and variations |
| Styles | Typography, colors, and effects (shadows, blurs, etc.) |
| Variables | Reusable design tokens for colors, spacing, dimensions, and other design properties |
| Assets | Images, SVG files, and fonts |
| Interactive States | CSS transitions, animations, and JavaScript interactions |
The implementation approach is selected according to the structure and properties of the original Figma design.
Technology Stack
The project focuses on native web technologies without frontend frameworks or component libraries.
| Technology | Application |
|---|---|
| HTML5 | Semantic markup and website structure |
| CSS3 | Layout, styling, and responsive behavior |
| Vanilla JavaScript | Interactions and dynamic functionality |
| Figma MCP | Design data retrieval and analysis |
| BEM | CSS naming methodology |
No framework dependencies.
Just native web technologies.
Architecture
Figma to Vanilla follows a modular skill architecture.
The main SKILL.md defines the overall workflow and determines which technical references are relevant to the current task. Each reference focuses on a specific area of implementation.
Repository Structure
figma-to-vanilla/
├── .agents/
│ └── skills/
│ └── figma-to-vanilla/
│ ├── SKILL.md
│ └── references/
│ ├── animations.md
│ ├── assets.md
│ ├── css-conventions.md
│ ├── design-system.md
│ ├── figma-components.md
│ ├── figma-layout.md
│ ├── fluid-responsive.md
│ ├── mcp-rules.md
│ ├── production-git.md
│ ├── structure.md
│ └── verification.md
│
├── .claude/
│ └── skills/
│ └── figma-to-vanilla # Same skill, provided separately for Claude Code
│
├── .github/
│ └── workflows/
│ └── release.yml
│
├── .vscode/
│ └── settings.json
│
├── .mcp.json
├── .gitignore
├── AGENTS.md
├── CLAUDE.md
├── LICENSE
└── README.md
Generated Website Structure
The skill supports two website architectures. The following examples illustrate the typical source and production structures.
Single-page
project/
├── build/
│ ├── index.html
│ ├── styles/
│ │ └── styles.min.css
│ ├── scripts/
│ │ └── scripts.min.js
│ ├── fonts/
│ └── images/
│ └── favicons/
│
└── src/
├── index.html
├── styles/
│ └── styles.css
├── scripts/
│ └── scripts.js
├── fonts/
└── images/
└── favicons/
Multi-page
project/
├── build/
│ ├── index.html
│ ├── about.html
│ ├── contacts.html
│ ├── styles/
│ │ └── styles.min.css
│ ├── scripts/
│ │ └── scripts.min.js
│ ├── fonts/
│ └── images/
│ └── favicons/
│
└── src/
├── index.html
├── pages/
│ ├── about.html
│ └── contacts.html
├── styles/
│ └── styles.css
├── scripts/
│ └── scripts.js
├── fonts/
└── images/
└── favicons/
The source structure keeps individual pages organized, while the production build places all HTML documents directly in the build/ directory.
src/contains the original source files used during development.build/contains optimized files prepared for production.- CSS and JavaScript files are minified during production preparation.
- Original source files are preserved in
src/.
This separation keeps development files organized and prevents production output from interfering with the source code.
Development Configuration
| File | Purpose |
|---|---|
.mcp.json |
Figma MCP server configuration for VS Code AI extensions that support this file. |
.vscode/settings.json |
Live Server configuration for local website preview. |
The MCP configuration uses figma-console-mcp and can serve as a reference when setting up the server in other AI coding agents.
Skill References
| Reference | Responsibility |
|---|---|
mcp-rules.md |
Figma MCP integration and usage rules |
structure.md |
Project structure, HTML, JavaScript, and favicons |
fluid-responsive.md |
Responsive layouts and fluid containers |
css-conventions.md |
CSS variables, BEM, and typography |
design-system.md |
Design tokens and reusable design system rules |
figma-components.md |
Figma Components, Component Sets, and Variants |
figma-layout.md |
Figma layout analysis and implementation |
assets.md |
Fonts, images, and SVG assets |
animations.md |
Animations and interactive states |
verification.md |
Visual verification and Live Server |
production-git.md |
Minification, WebP, production, Git, and GitHub |
This separation keeps the main skill concise while allowing detailed technical instructions to be loaded when needed.
Supported AI Agents
The skill uses the Agent Skills format and is intended for AI coding agents that support this format.
| AI Agent | Skill Directory |
|---|---|
| OpenCode, Codex, Cline, and other compatible AI agents | .agents/skills/ |
| Claude Code | .claude/skills/ |
Installation
1. Clone the Repository
git clone https://github.com/andrewalexeich/figma-to-vanilla.git
Open the cloned repository directly in your AI coding agent. The skill is already included in the repository, so no additional copying or installation is required.
2. Prepare Figma MCP
Figma to Vanilla uses figma-console-mcp as its preferred MCP server for interacting with Figma.
Before using the skill for tasks involving Figma designs, make sure you have:
- Node.js 18 or later installed.
- Figma Desktop installed.
- A personal Figma access token.
No manual download of the package archive or global installation of figma-console-mcp is required. The package is downloaded automatically through npx.
To download the MCP package, open a terminal and run:
npx -y figma-console-mcp@latest --print-path
This command automatically downloads the package from npm if it is not already cached, prepares the Figma Desktop Bridge plugin files, and prints the plugin directory path. It exits without starting the MCP server.
The MCP server can then be launched automatically by your AI coding agent using the same command specified in its MCP configuration.
3. Import and Run Figma Desktop Bridge
The MCP server requires the Figma Desktop Bridge plugin to communicate with Figma Desktop.
You only need to import the plugin once initially. Re-importing may be required after certain server updates, as indicated in the release notes.
- Open Figma Desktop.
- Go to Plugins → Development → Import plugin from manifest....
- Navigate to the plugin directory printed by the
--print-pathcommand and selectmanifest.json.
Default plugin locations:
- macOS:
~/.figma-console-mcp/plugin/manifest.json - Windows:
%USERPROFILE%\.figma-console-mcp\plugin\manifest.json
Use the path printed by --print-path if the plugin is installed in a different location.
- After importing, open a Figma file and run Plugins → Development → Figma Desktop Bridge.
- Wait until the plugin displays the
Local · readystatus.
The imported plugin remains available in Figma's Development plugins. You only need to run it when you want to use Figma MCP.
4. Configure Figma MCP
The MCP configuration depends on the AI coding agent you use.
For VS Code
The repository includes a preconfigured .mcp.json file in the project root containing the MCP server configuration for figma-console-mcp.
Set the FIGMA_ACCESS_TOKEN environment variable to your personal Figma access token in the environment where VS Code runs.
Open the project in VS Code and make sure GitHub Copilot uses the workspace MCP configuration. The figma-console-mcp server will be started by the Copilot agent when needed.
For OpenCode, Claude Code, Codex, and other AI Agents
You can ask your AI agent to read the preconfigured .mcp.json file, which contains the Figma MCP server command and required environment variables, and configure the figma-console-mcp server using the same settings in its own MCP configuration format.
Make sure to provide your personal Figma access token through the environment variables required by your AI agent.
After configuring the server, restart your AI agent if necessary and verify that the Figma MCP tools are available.
5. Start Building
Open your project in the AI coding agent and provide a task involving a Figma design.
The agent will first determine whether the project should be implemented as a single-page or multi-page website. It will then use the main skill to analyze the provided Figma design through Figma MCP and load the relevant technical references.
Workflow
The development process follows a structured sequence:
flowchart TD
A["Figma Design"] --> B["Figma MCP"]
B --> C["Design Analysis"]
C --> D["Design System Analysis"]
D --> E["Layout & Component Analysis"]
E --> F["HTML Structure"]
F --> G["CSS Implementation"]
G --> H["JavaScript & Animations"]
H --> I["Responsive Development"]
I --> J["Visual Verification"]
J --> K{"Matches Figma?"}
K -->|No| C
K -->|Yes| L["Production Preparation"]
L --> M["Finished Website"]
Visual verification is an iterative part of the process. If discrepancies are found, the relevant implementation is reviewed and corrected before proceeding.
Development Principles
The project is built around the following principles:
| Principle | Description |
|---|---|
| Figma as the Source of Truth | Use the original design as the primary source of layout and visual information. |
| Native Web Technologies | Implement websites with HTML, CSS, and Vanilla JavaScript. |
| Design Accuracy | Preserve the original layout, proportions, typography, colors, and spacing. |
| Responsive by Design | Maintain the design intent across different screen sizes. |
| Modular Instructions | Keep technical rules organized in specialized reference files. |
| Maintainable Code | Use consistent naming conventions and avoid unnecessary complexity. |
Limitations
The accuracy and completeness of the generated website depend on several factors:
- Figma Design Quality: Missing, inconsistent, or incomplete design information may require additional interpretation.
- MCP Capabilities: Available design data and operations depend on the installed Figma MCP server and its supported functionality.
- Visual Verification: Some visual discrepancies may require manual inspection and adjustment.
- Responsive Behavior: Responsive layouts may require additional decisions when the original Figma file does not include designs for all screen sizes.
Requirements
- An AI coding agent that supports the Agent Skills format.
figma-console-mcpconfigured for tasks involving Figma designs.- Access to the relevant Figma files and design information.
- A local development environment for running and previewing static websites.
Figma Design Preparation
For accurate and reliable implementation, the Figma design should be properly structured before development begins.
- Use Auto Layout for frames and components wherever applicable.
- Use Layout Grids to define consistent alignment, columns, and page structure.
- Ensure that spacing, dimensions, alignment, and constraints are properly configured.
- Avoid relying on manually positioned elements when a layout-based structure is more appropriate.
Poorly structured designs or missing layout properties may require additional interpretation and can reduce implementation accuracy, responsiveness, and maintainability.
Related Projects
figma-console-mcp — the Figma MCP server used by this skill.
License
Distributed under the MIT License.
Yorumlar (0)
Yorum birakmak icin giris yap.
Yorum birakSonuc bulunamadi