La plupart des développeurs, des tech leads et des ingénieurs DevOps débutent leur carrière en tant que bâtisseurs.

Ils construisent des systèmes, des applications, des composants, des thèmes, des patterns, des modules et des pipelines. Ils optimisent les mises en page, corrigent les cas limites, maintiennent la compatibilité et font avancer les systèmes un commit après l'autre. Le travail est précis, concret et profondément technique.

Mais à un moment donné, quelque chose bascule.

Les meilleurs praticiens ne cessent pas de construire, mais ils se mettent à penser en systèmes.

De bâtisseur à penseur de systèmes

Le basculement : du résultat aux règles

Quand on est bâtisseur, on se concentre sur le résultat : composants, templates, pages, fonctionnalités, bibliothèques, applications.

Quand on pense en systèmes, l'attention se déplace vers les règles : contraintes, interactions, boucles de rétroaction.

Au lieu de se demander « À quoi ressemble ce composant ? », les penseurs de systèmes posent d'autres questions : quelles règles gouvernent ce composant ? Qu'est-ce qui a le droit d'interagir avec lui ? Comment se comporte-t-il face au changement ? Comment l'intention survit-elle au temps ?

Ce basculement mène naturellement vers les systèmes agentiques.

Quand le design cesse d'être statique

Les design systems modernes encodent déjà de la logique : les tokens définissent les contraintes, les composants définissent la structure, les patterns définissent le comportement.

Pourtant, la plupart des systèmes dépendent encore d'une lourde orchestration humaine.

Les agents IA introduisent un autre modèle, où les systèmes peuvent faire respecter leurs propres règles, valider les décisions en continu, réagir au contexte et se coordonner en interne.

C'est là que le design passe de la documentation à une logique exécutable.

Vers où nous allons

L'enjeu est désormais de mettre ces idées en œuvre dans des systèmes réels et fonctionnels, non pas comme des expériences, mais comme des fondations.

1. Une intégration plus poussée des agents IA aux outils de design (Figma)

Vers des design systems agentiques

Les outils de design ne devraient pas être de simples toiles passives.

L'objectif est d'intégrer à Figma des agents IA qui comprennent les design tokens et les contraintes des composants, valident les décisions en temps réel, traduisent l'intention de design en règles au niveau du système, et agissent comme des collaborateurs, pas comme de simples outils d'export.

Cela fait remonter le design en amont, là où l'intention est préservée plutôt que déduite après coup.

2. Une gestion des agents IA à grande échelle

Objectif : 150 agents, un par composant

Plutôt qu'une seule IA généraliste, les équipes évoluent vers de nombreux agents spécialisés.

Chaque composant a son propre agent, avec des responsabilités définies, des limites claires et une connaissance des composants voisins.

C'est le reflet de la façon dont les systèmes sains passent à l'échelle : par la spécialisation, la coordination et des contrats clairs.

3. Des agents dotés de vraies compétences, d'outils et de plugins

Les agents doivent être capables d'agir.

Cela passe par des compétences (raisonnement sur l'accessibilité, validation du design, sensibilité à la performance), des outils (linters, exécuteurs de tests, API de design) et des plugins (Storybook, Drupal, pipelines CI, intégrations Figma).

Un agent sans outils reste théorique. Un agent avec des outils devient une partie du système lui-même.

4. Des tests fonctionnels d'acceptation automatisés plus intelligents

Pilotés par l'IA et attentifs à l'intention

Le test traditionnel vérifie le résultat. Le test piloté par des agents comprend le comportement.

On mise sur des agents IA qui raisonnent sur les parcours utilisateurs, des tests fonctionnels qui comprennent l'intention plutôt que de simples sélecteurs, des systèmes qui font évoluer les tests en même temps que les composants, et sur la réduction des tests fragiles tout en renforçant la confiance sémantique.

Le test devient une couche supplémentaire de l'intelligence du système.

TDD & BDD à l'ère de l'IA : pourquoi les agents IA exigent 100 % de développement piloté par les tests en plus

Pourquoi c'est important

Les équipes construisent des systèmes qui survivent à leurs créateurs, s'adaptent en continu et portent dans la durée des décisions de design.

Dans ce monde, le contrôle manuel ne passe pas à l'échelle. Mais des règles bien définies, si.

Designers, développeurs et agents IA doivent évoluer dans le même cadre logique : un système partagé de contraintes et d'intention.

Passer de bâtisseur à penseur de systèmes ne signifie pas renoncer à l'implémentation. Il s'agit de voir les systèmes comme autre chose qu'une collection de pièces.

L'étape suivante consiste à concevoir les règles qui permettent aux systèmes de raisonner, de s'adapter et d'évoluer.

Les développeurs, tech leads et ingénieurs DevOps qui franchissent ce pas ne se contentent plus de construire : ils bâtissent les conditions pour que les systèmes se construisent eux-mêmes.