Agent skill

figma-to-code

Génère du code à partir d'une sélection Figma en utilisant les composants existants et Code Connect. Utiliser quand l'utilisateur fournit une URL Figma, dit "convertir ce design", "figma to code", "générer depuis figma", ou veut transformer un design en code.

Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/data/figma-to-code

SKILL.md

Figma to Code

📥 Contexte à charger

Au démarrage, vérifier l'environnement Figma et les composants existants.

Contexte Pattern/Action Priorité
Code Connect Read: figma.config.json Recommandé
Composants existants Glob: src/components/ui/*.{tsx,jsx,vue} Requis
Mappings Figma Glob: src/components/**/*.figma.tsx Optionnel
Framework Grep: package.json pour react/vue/angular/next Requis
Design tokens Read: src/styles/tokens.css ou docs/planning/ui/tokens.css Optionnel

Instructions de chargement

  1. Vérifier si Code Connect est configuré (figma.config.json)
  2. Scanner les composants UI existants pour réutilisation
  3. Identifier les mappings .figma.tsx existants
  4. Détecter le framework pour générer le bon code

Activation

Au démarrage :

  1. Parser l'URL Figma fournie
  2. Vérifier si Code Connect est configuré
  3. Détecter le framework du projet
  4. Identifier les composants mappés disponibles

Rôle & Principes

Rôle : Transformer un design Figma en code fonctionnel en utilisant les composants existants du projet. Privilégier la réutilisation plutôt que la création de nouveaux composants.

Principes :

  • Réutilisation first - Utiliser les composants mappés existants
  • Tokens first - Utiliser les design tokens du projet
  • Clean code - Générer du code lisible et maintenable
  • Framework-aware - Respecter les conventions du framework détecté

Règles :

  • ⛔ Ne JAMAIS créer de nouveaux composants de base (Button, Input, etc.)
  • ⛔ Ne JAMAIS hardcoder des valeurs de style (utiliser les tokens)
  • ⛔ Ne JAMAIS ignorer les composants mappés existants
  • ✅ Toujours vérifier les mappings avant de générer
  • ✅ Toujours utiliser les tokens CSS existants
  • ✅ Toujours proposer de créer les mappings manquants

Process

1. Parsing de l'URL Figma

markdown
🔗 **Analyse URL Figma**

**URL** : [URL fournie]

**Extraction** :
| Élément | Valeur |
|---------|--------|
| File Key | [file_key] |
| Node ID | [node_id ou "page entière"] |
| File Name | [nom si disponible] |

**Type de sélection** :
- [ ] Composant unique
- [ ] Frame / Screen
- [ ] Page complète

Je récupère les informations du design ?

⏸️ STOP - Validation avant appel API


2. Vérification des mappings existants

markdown
🔍 **Mappings Code Connect**

**Composants mappés disponibles** :
| Composant Figma | Composant Code | Mapping |
|-----------------|----------------|---------|
| Button | `<Button>` | ✅ |
| Input | `<Input>` | ✅ |
| Card | `<Card>` | ✅ |
| [Autre] | - | ❌ |

**Composants dans le design** :
[Liste des composants détectés dans la sélection Figma]

**Match** : [X/Y] composants ont un mapping existant

[Si mappings manquants]
⚠️ [N] composants sans mapping. Options :
- [C] Continuer avec composants génériques
- [M] Créer les mappings d'abord (`/figma-setup`)

⏸️ STOP - Décision sur les mappings manquants


3. Extraction du design

Utiliser les outils MCP Figma :

markdown
📐 **Design extrait**

**Structure** :

[Frame Name] ├── Header │ ├── Logo (Image) │ └── Navigation (→ mapped: NavBar) ├── Hero Section │ ├── Title (Text) │ ├── Description (Text) │ └── CTA (→ mapped: Button) └── Content └── Cards Grid ├── Card 1 (→ mapped: Card) ├── Card 2 (→ mapped: Card) └── Card 3 (→ mapped: Card)


**Tokens utilisés** :
| Token Figma | Token CSS local |
|-------------|-----------------|
| Primary/500 | --color-primary-500 |
| Spacing/lg | --space-lg |
| Radius/md | --radius-md |

**Dimensions** : [W] × [H]

Je génère le code ?

⏸️ STOP - Validation structure avant génération


4. Génération du code

markdown
💻 **Code généré**

**Fichier** : `src/components/[name].tsx`

```tsx
import { Button } from "@/components/ui/button";
import { Card } from "@/components/ui/card";
import { Input } from "@/components/ui/input";

interface [ComponentName]Props {
  // Props extraites du design
}

export function [ComponentName]({ ...props }: [ComponentName]Props) {
  return (
    <div className="[styles utilisant tokens]">
      {/* Structure générée depuis Figma */}
    </div>
  );
}

Composants utilisés :

  • Button (mapped) ✅
  • Card (mapped) ✅
  • Input (mapped) ✅

Tokens utilisés :

  • --color-primary-500
  • --space-lg
  • --radius-md

Ce code te convient ?


**⏸️ STOP** - Validation code généré

---

### 5. Proposition de mappings manquants

Si des composants Figma n'ont pas de mapping :

```markdown
🔗 **Mappings manquants**

Ces composants Figma n'ont pas de mapping Code Connect :

| Composant Figma | Composant code suggéré | Action |
|-----------------|------------------------|--------|
| [FigmaComponent] | `src/components/ui/[name].tsx` | Créer mapping |
| [Autre] | `src/components/ui/[name].tsx` | Créer mapping |

**Créer les mappings maintenant ?**
- [Y] Oui, créer les fichiers .figma.tsx
- [N] Non, utiliser les composants génériques
- [S] Setup complet (`/figma-setup`)

⏸️ STOP - Décision mappings

Si oui, créer les fichiers .figma.tsx :

tsx
// src/components/ui/[name].figma.tsx
import figma from "@figma/code-connect";
import { ComponentName } from "./[name]";

figma.connect(ComponentName, "[FIGMA_URL_NODE]", {
  props: {
    // Props détectées
  },
  example: (props) => <ComponentName {...props} />,
});

6. Écriture du fichier

markdown
📝 **Fichier créé**

**Path** : `src/components/[path]/[name].tsx`

**Contenu** : [résumé du composant]

**Imports** :
- [X] composants UI mappés
- [Y] tokens CSS
- [Z] types

Le fichier a été créé. Vérifications :
- [ ] Pas d'erreurs TypeScript
- [ ] Imports corrects
- [ ] Tokens utilisés (pas de hardcode)

Écrire le fichier avec Write.


7. Validation & Résumé

markdown
## ✅ Code généré depuis Figma

**Source** : [URL Figma]
**Fichier créé** : `src/components/[name].tsx`

**Résumé** :
| Métrique | Valeur |
|----------|--------|
| Composants mappés utilisés | [N] |
| Tokens CSS utilisés | [N] |
| Lignes de code | [N] |
| Props typées | [N] |

**Composants réutilisés** :
- `Button` ✅
- `Card` ✅
- `Input` ✅

**Nouveaux mappings créés** : [N] (si applicable)

---

**Prochaine étape ?**
- [A] Générer un autre composant (`/figma-to-code [url]`)
- [T] Écrire les tests (`/test-runner`)
- [R] Review le code (`/code-reviewer`)

⏸️ STOP - Fin de génération


Détection du framework

React / Next.js

tsx
// Imports
import { ComponentName } from "@/components/ui/component";

// Styles
className="flex gap-4 p-6"  // Tailwind si détecté
className={styles.container} // CSS Modules si détecté

// Props
interface Props {
  title: string;
  onClick?: () => void;
}

Vue

vue
<template>
  <div class="container">
    <ComponentName :prop="value" />
  </div>
</template>

<script setup lang="ts">
import ComponentName from '@/components/ui/ComponentName.vue';

defineProps<{
  title: string;
}>();
</script>

HTML / Web Components

html
<div class="container">
  <custom-button variant="primary">Click me</custom-button>
</div>

<style>
.container {
  display: flex;
  gap: var(--space-md);
}
</style>

Mapping des styles Figma → Code

Couleurs

Figma Tailwind CSS Variable
Primary/500 bg-primary-500 var(--color-primary-500)
Neutral/100 bg-gray-100 var(--color-neutral-100)

Spacing

Figma Tailwind CSS Variable
8 p-2 var(--space-sm)
16 p-4 var(--space-md)
24 p-6 var(--space-lg)

Typography

Figma Tailwind CSS Variable
Heading/H1 text-3xl font-bold var(--font-heading-1)
Body/Regular text-base var(--font-body)

Output Validation

Avant de terminer, valider :

markdown
### ✅ Checklist Output Figma to Code

| Critère | Status |
|---------|--------|
| URL Figma parsée correctement | ✅/❌ |
| Design extrait | ✅/❌ |
| Composants mappés utilisés | ✅/❌ |
| Tokens CSS utilisés (pas hardcode) | ✅/❌ |
| Code TypeScript valide | ✅/❌ |
| Fichier créé | ✅/❌ |

**Score : X/6** → Si < 5, corriger avant de terminer

Auto-Chain

Après la génération, proposer :

markdown
## 🔗 Prochaine étape

✅ Code généré depuis Figma.

**Suggestions :**

→ 🧪 **`/test-runner`** - Écrire des tests pour le composant
→ 🔄 **`/code-reviewer`** - Review du code généré
→ 🖼️ **`/figma-to-code [autre-url]`** - Générer un autre composant

---

**[T] Tests** | **[R] Review** | **[F] Autre Figma** | **[X] Terminé**

⏸️ STOP - Attendre choix


Gestion des erreurs

URL invalide

markdown
❌ **URL Figma invalide**

L'URL fournie ne semble pas être une URL Figma valide.

**Format attendu** :

https://figma.com/design/FILE_KEY/FILE_NAME?node-id=NODE_ID https://figma.com/file/FILE_KEY/FILE_NAME?node-id=NODE_ID


**Exemples valides** :
- `https://figma.com/design/ABC123/MyDesign?node-id=1:234`
- `https://figma.com/file/XYZ789/Components`

Fournis une URL Figma valide.

Pas de Code Connect

markdown
⚠️ **Code Connect non configuré**

Pour une meilleure génération, configure d'abord Code Connect :

```bash
/figma-setup

Options :

  • [S] Setup Code Connect d'abord (recommandé)
  • [C] Continuer sans mappings (génération basique)

### Accès refusé

```markdown
❌ **Accès au fichier Figma refusé**

Tu n'as pas accès à ce fichier Figma.

**Solutions** :
1. Vérifie que tu es connecté au bon compte Figma
2. Demande l'accès au propriétaire du fichier
3. Vérifie que le lien de partage est activé

Re-authentification :
```bash
npx figma connect

---

## Transitions

- **Vers test-runner** : "On écrit les tests pour ce composant ?"
- **Vers code-reviewer** : "On review le code généré ?"
- **Vers figma-setup** : "On configure Code Connect d'abord ?"

Expand your agent's capabilities with these related and highly-rated skills.

Didn't find tool you were looking for?

Be as detailed as possible for better results