Les tokens avant les pixels
Pourquoi chaque projet commence désormais par un système de couleurs, de typo et de mouvement, même les petits.
Pendant longtemps, j'ai démarré mes projets de la même façon : j'ouvrais Figma ou l'éditeur, et je posais des pixels. Un vert qui me plaisait, un titre en 28 px « parce que ça rend bien », une transition en 0.3s ease copiée d'un autre fichier.
Trois semaines plus tard, le projet contenait onze nuances de gris, quatre verts « de marque » presque identiques, des titres en 26, 28 et 30 px, et des animations qui n'avaient rien en commun. Puis quelqu'un demandait un mode sombre.
Aujourd'hui, l'ordre est inversé. Avant le premier écran, avant même le premier composant, je pose un petit système de tokens : couleurs, typographie, mouvement. Même pour une landing page. Même pour un side project du week-end.
Voici pourquoi, et comment le faire en une demi-heure.
Un token, c'est une décision qui porte un nom
Un design token est une valeur de design (une couleur, une taille, une durée, une courbe d'animation) stockée sous un nom, et utilisée partout à la place de la valeur brute.
/* Sans token */
.button { background: #10b981; transition: background 150ms cubic-bezier(0.2, 0, 0, 1); }
/* Avec tokens */
.button { background: var(--color-action); transition: background var(--duration-fast) var(--ease-out); }La différence semble cosmétique. Elle ne l'est pas : #10b981 est une valeur, --color-action est une décision. Le jour où la couleur d'action change, on change une ligne, pas quarante.
Le concept vient de l'équipe du design system Salesforce Lightning, où Jina Anne et Jon Levine ont donné ce nom aux « tokens » au milieu des années 2010. Depuis, l'idée a fait du chemin : en octobre 2025, le W3C Design Tokens Community Group a publié la première version stable de sa spécification (2025.10), un format JSON commun pour échanger des tokens entre outils de design et de code. Ce n'est pas un standard W3C officiel, mais c'est un signal clair : les tokens ne sont plus un luxe de grande entreprise, c'est une infrastructure de base.
Pourquoi même les petits projets
L'argument classique, c'est « les tokens, c'est pour les design systems à 200 composants ». Je pense l'inverse : c'est sur les petits projets qu'ils rapportent le plus vite, parce qu'ils coûtent presque rien à poser au début et beaucoup à rattraper après.
1. Le mode sombre (et les thèmes) deviennent gratuits
Si vos composants utilisent --color-surface et --color-text au lieu de #fff et #0f172a, le mode sombre consiste à redéfinir une dizaine de variables. Rien d'autre.
Exemple concret : sur PolicyCraft, j'ai fait passer tout le thème sombre vers un bleu nuit en modifiant la teinte de quelques variables. Aucun composant n'a été touché.
2. L'accessibilité se vérifie une fois, à la source
Le contraste se valide au niveau des paires de tokens (color.text sur color.surface, color.on-action sur color.action), pas écran par écran. Si la paire respecte le ratio de 4,5:1 exigé par le critère WCAG 1.4.3, tous les écrans qui l'utilisent le respectent aussi.
3. Le design et le code parlent la même langue
Les variables Figma et les variables CSS portent les mêmes noms. Le handoff ne consiste plus à mesurer des hex à la pipette, mais à dire « c'est color.action.hover ».
4. Plusieurs plateformes, une seule source
Sur un projet comme COLIS'A, la même marque doit vivre dans une console web en React et dans deux applis mobiles en Flutter. Sans tokens, chaque codebase finit par avoir « son » vert. Avec une source unique, des outils comme Style Dictionary génèrent les variables CSS, les constantes Dart et le reste à partir du même fichier.
5. Les assistants de code arrêtent d'inventer des valeurs
C'est l'argument le plus récent, et pour moi le plus fort en 2026. Quand on code avec un assistant IA, il génère volontiers bg-[#10b981] ou duration-300 au hasard. Si le projet expose un jeu de tokens clair, l'assistant les réutilise. Les tokens deviennent un garde-fou pour la cohérence, que le code soit écrit par vous, un collègue ou un modèle.
Les trois systèmes à poser dès le départ
Couleur : trois couches, pas une palette
L'erreur classique est de s'arrêter à la palette (green-500, slate-900…). Une palette, c'est une boîte de peinture ; ce n'est pas encore un système. Le modèle qui fonctionne, popularisé notamment par Nathan Curtis (EightShapes) et utilisé par Material Design 3, sépare trois couches :
- Primitifs : les valeurs brutes.
green.500,slate.50. Ils disent ce que c'est. - Sémantiques : l'intention.
color.action,color.surface,color.danger. Ils disent à quoi ça sert. C'est la couche que les composants consomment, et celle qu'on redéfinit pour le mode sombre. - Composants (optionnel sur un petit projet) :
button.bg,card.title. Utile quand un composant doit pouvoir dévier sans casser le reste.
Sur un petit projet, les couches 1 et 2 suffisent largement.
Un conseil de plus : définissez vos primitifs en OKLCH plutôt qu'en hex ou HSL. L'espace OKLCH est perceptuellement uniforme : deux couleurs avec la même luminosité L paraissent aussi claires l'une que l'autre, ce qui rend les échelles et les contrastes beaucoup plus prévisibles. L'article d'Evil Martians l'explique très bien.
Typographie : une échelle, pas des tailles
Au lieu de choisir des tailles une par une, on choisit une base et un ratio. Avec une base de 16 px et un ratio de 1,25 (la « tierce majeure »), on obtient 12,8 · 16 · 20 · 25 · 31,25 · 39 px. Six tailles, pas une de plus.
Ce qui change tout : quand un écran « manque de hiérarchie », on ne bricole plus un 27 px. On monte d'un cran dans l'échelle. Pour aller plus loin, Utopia génère des échelles fluides qui s'adaptent à la largeur de l'écran via clamp().
Les tokens typo ne s'arrêtent pas à la taille : famille, graisses, interlignage (line-height) et espacement des lettres méritent aussi leur nom.
Mouvement : le système qu'on oublie toujours
C'est la couche la plus souvent absente, et celle qui trahit le plus vite un projet bricolé. Des modales qui s'ouvrent en 500 ms, des menus en 200 ms, des boutons en ease-in-out, un toast en linear… Chaque animation est correcte isolément, l'ensemble paraît désordonné.
En travaillant sur Splash, ma plateforme de modèles d'animation, la leçon a été nette : la cohérence du mouvement compte plus que sa sophistication. Deux familles de tokens suffisent :
- Les durées, proportionnelles à la distance et à la taille de ce qui bouge : rapide pour un survol ou un appui, plus lent pour une modale ou un changement de page.
- Les courbes (easing) :
ease.out(décélération) pour ce qui entre à l'écran,ease.in(accélération) pour ce qui sort, et presque jamaislinearpour une interface. Material Design 3 documente un jeu complet de durées et de courbes, une bonne base pour s'inspirer.
Et un token de mouvement a un super-pouvoir : on peut le neutraliser globalement pour les personnes qui ont activé prefers-reduced-motion. Une seule règle, et tout le projet respecte ce réglage.
Le kit minimal : 30 minutes, un fichier
Voici à quoi ressemble mon point de départ aujourd'hui, avec Tailwind CSS v4, dont la directive @theme transforme directement des variables CSS en utilitaires (bg-action, text-surface, text-lg, ease-out…) :
@import "tailwindcss";
@theme {
/* ── Couleur : primitifs ── */
--color-green-500: oklch(0.70 0.15 163);
--color-green-700: oklch(0.51 0.11 166);
--color-slate-50: oklch(0.98 0.003 248);
--color-slate-900: oklch(0.21 0.04 266);
--color-red-500: oklch(0.64 0.21 25);
/* ── Typographie : base 16px, ratio 1.25 ── */
--font-sans: "Inter", system-ui, sans-serif;
--text-sm: 0.8rem;
--text-md: 1rem;
--text-lg: 1.25rem;
--text-xl: 1.5625rem;
--text-2xl: 1.953rem;
--text-3xl: 2.441rem;
/* ── Couleur : sémantique (ce que consomment les composants) ── */
--color-action: var(--color-green-500);
--color-action-hover: var(--color-green-700);
--color-surface: var(--color-slate-50);
--color-text: var(--color-slate-900);
--color-danger: var(--color-red-500);
/* ── Mouvement : courbes ── */
--ease-out: cubic-bezier(0.2, 0, 0, 1);
--ease-in: cubic-bezier(0.3, 0, 1, 1);
}
/* ── Mouvement : durées (utilisées via var()) ── */
:root {
--duration-fast: 150ms;
--duration-base: 250ms;
--duration-slow: 400ms;
}
/* ── Mode sombre : on ne redéfinit QUE la couche sémantique ── */
@media (prefers-color-scheme: dark) {
:root {
--color-surface: var(--color-slate-900);
--color-text: var(--color-slate-50);
}
}
/* ── Accessibilité : un seul interrupteur pour tout le mouvement ── */
@media (prefers-reduced-motion: reduce) {
:root {
--duration-fast: 0ms;
--duration-base: 0ms;
--duration-slow: 0ms;
}
}Sans Tailwind, c'est exactement la même chose en CSS pur. Et si vous avez besoin de partager ces tokens entre plusieurs plateformes, le format de la spec DTCG ressemble à ceci :
{
"color": {
"green-500": {
"$type": "color",
"$value": { "colorSpace": "srgb", "components": [0.063, 0.725, 0.506], "hex": "#10b981" }
},
"action": { "$value": "{color.green-500}" }
},
"duration": {
"fast": { "$type": "duration", "$value": { "value": 150, "unit": "ms" } }
},
"ease": {
"out": { "$type": "cubicBezier", "$value": [0.2, 0, 0, 1] }
}
}Notez l'alias {color.green-500} : c'est la couche sémantique, exprimée dans le format standard. Côté Flutter, ces valeurs finissent dans un ThemeData et, pour ce qui n'y a pas sa place (durées, courbes), dans une ThemeExtension.
Les pièges que j'ai rencontrés
- Nommer par la valeur au lieu de l'intention.
--green-buttonest un mauvais token : le jour où le bouton devient bleu, le nom ment. Préférez--color-action. - Sauter la couche sémantique. Utiliser
green-500directement dans les composants, c'est garder tous les inconvénients des valeurs codées en dur, avec un nom en plus. - Créer trop de tokens trop tôt. Un token qui n'est utilisé qu'une fois n'est pas un token, c'est une valeur déguisée. Commencez petit : 5 à 8 couleurs sémantiques, 6 tailles de texte, 3 durées, 2 ou 3 courbes.
- Oublier le mouvement. Voir plus haut. C'est le système le plus rapide à poser et celui qui se voit le plus quand il manque.
- Construire un outillage avant d'en avoir besoin. Pour un seul projet web, un fichier CSS suffit. Style Dictionary et le format DTCG deviennent utiles quand il y a plusieurs plateformes ou plusieurs projets.
En résumé
Les tokens ne servent pas à faire « plus pro ». Ils servent à prendre les décisions de design une seule fois, au moment où c'est le moins cher, et à les rendre impossibles à contourner par accident, que ce soit par vous dans trois mois, par un collègue ou par un assistant IA.
Couleurs, typo, mouvement : trois petits systèmes, un fichier, trente minutes. Ensuite seulement, les pixels.
Sources et pour aller plus loin
- W3C Design Tokens Community Group : annonce de la spécification stable 2025.10 · spécification complète
- Salesforce Trailhead : l'histoire du Lightning Design System
- Smashing Podcast avec Jina Anne : What Are Design Tokens?
- Nathan Curtis : Naming Tokens in Design Systems
- Material Design 3 : Design tokens · Easing and duration
- Tailwind CSS : Theme variables (
@theme) - Figma : Guide des variables
- Style Dictionary, pour générer les tokens vers plusieurs plateformes
- Evil Martians : OKLCH in CSS: why we moved from RGB and HSL
- Utopia, pour des échelles typographiques et d'espacement fluides
- W3C : WCAG 2.2, critère 1.4.3 Contraste (minimum)
- MDN :
prefers-reduced-motion - Flutter :
ThemeExtension