---
title: "Spec-driven development : l'étape d'après le vibe coding"
description: "Le spec-driven development fait écrire une spécification avant le code. Méthode en 4 phases, outils (Spec Kit, Kiro), limites et modèle prêt à copier."
url: "https://vibe-code.blog/blog/spec-driven-development-2"
lang: "fr"
author: "Thierry Gustin"
published: "2026-08-30"
updated: "2026-11-21"
---

# Spec-driven development : l'étape d'après le vibe coding

> **L’essentiel** — Le spec-driven development (SDD) consiste à faire écrire et valider une spécification avant de laisser un agent d'IA coder : exigences, plan technique, liste de tâches, puis implémentation. C'est la réponse aux projets vibe codés qui deviennent ingérables. Des outils comme Spec Kit de GitHub ou l'IDE Kiro l'outillent, mais la méthode s'applique avec n'importe quel agent, à condition de la réserver aux fonctionnalités qui le méritent.

Le spec-driven development, c'est écrire ce que tu veux avant de demander le code, puis faire travailler l'agent d'IA à partir de ce texte plutôt qu'à partir d'une suite de prompts improvisés. Quatre phases : spécifier, planifier, découper en tâches, implémenter. C'est l'étape naturelle quand un projet vibe codé dépasse le prototype et que l'IA commence à casser ce qui marchait.

## Qu'est-ce que le spec-driven development, exactement ?

Le spec-driven development (SDD) est une méthode où la spécification devient le document de référence que l'agent d'IA suit pour écrire le code. Tu ne dis plus « ajoute un système de réservation », tu fais d'abord rédiger, relire et corriger un document qui décrit qui réserve quoi, quand, avec quelles règles et quels cas limites.

GitHub, qui a publié l'outil open source Spec Kit en septembre 2025, résume l'idée en une phrase : « les specs deviennent la source de vérité partagée ».

La différence avec le vibe coding tient en un tableau :

|  | Vibe coding | Spec-driven development |
| --- | --- | --- |
| Point de départ | Un prompt | Une spécification écrite et validée |
| Ce que tu relis | Le résultat à l'écran | La spec, le plan, puis des changements ciblés |
| Mémoire du projet | L'historique de la conversation | Des fichiers dans le projet |
| Taille des changements | Souvent énorme et diffuse | Une tâche à la fois |
| Idéal pour | Prototype, test d'idée, projet du week-end | Fonctionnalité durable, projet qui grossit |

Si tu découvres le sujet, commence par notre [guide complet du vibe coding](https://vibe-code.blog/blog/vibe-coding-guide-complet) : le SDD n'a de sens que quand on a déjà senti les limites de l'approche « au feeling ».

## Pourquoi on en parle maintenant

Le vibe coding marche très bien pendant les premières heures. Ensuite, trois problèmes apparaissent, et ils sont bien documentés.

- **L'IA oublie.** Chaque session repart presque de zéro. Les décisions prises il y a trois jours (« les prix sont toujours en centimes ») ne sont écrites nulle part.
- **Les changements deviennent énormes.** Un prompt vague produit une modification sur quinze fichiers, impossible à relire.
- **Le code n'est pas vérifié.** Le rapport 2025 de Veracode a trouvé une faille de sécurité dans 45 % des tâches de code générées par plus de 100 modèles. Plus le changement est gros, moins tu as de chances de la voir.

Le SDD répond aux trois : la spec sert de mémoire, le découpage en tâches réduit la taille des changements, et chaque tâche se vérifie isolément.

## Les 4 phases du spec-driven development

Les outils diffèrent, mais le déroulé est le même partout. Voici celui décrit par GitHub pour Spec Kit.

1. **Spécifier.** Tu décris ce que tu construis et pourquoi : les utilisateurs, leurs problèmes, ce qui définit le succès. Pas de technique. L'agent rédige une spec détaillée que tu corriges.
2. **Planifier.** Tu donnes la direction technique : stack, architecture, contraintes. L'agent produit un plan technique. GitHub suggère même de demander plusieurs variantes pour comparer.
3. **Découper en tâches.** L'agent transforme spec et plan en petites tâches, chacune réalisable et testable seule.
4. **Implémenter.** L'agent traite les tâches une par une. Tu relis des changements ciblés, pas un bloc de code géant.

> **La règle qui change tout** — Ne passe jamais à la phase suivante sans avoir relu et corrigé la précédente. Une erreur dans la spec coûte une phrase à corriger ; la même erreur dans le code coûte une après-midi.

Pour la phase 1, tu as déjà la méthode : c'est exactement [le cahier des charges avant le prompt](https://vibe-code.blog/blog/cahier-des-charges-ia), en plus formalisé.

## Les outils du spec-driven development

Trois noms reviennent dans toutes les analyses sérieuses, notamment celle de Birgitta Böckeler (Thoughtworks) publiée sur le site de Martin Fowler en octobre 2025.

### Spec Kit (GitHub)

[Spec Kit](https://github.com/github/spec-kit) est une boîte à outils open source qui ajoute des commandes à ton agent de code existant. À son lancement, GitHub annonçait la compatibilité avec GitHub Copilot, Claude Code et Gemini CLI. Les commandes suivent les phases : une pour la spec, une pour le plan, une pour les tâches, une pour l'implémentation. Le dépôt ajoute aussi une « constitution » : les principes non négociables du projet (tests obligatoires, bibliothèques autorisées, etc.).

Les noms exacts des commandes ont évolué depuis l'annonce : réfère-toi au README du dépôt pour ta version.

### Kiro

[Kiro](https://kiro.dev/) est un IDE agentique présenté en juillet 2025, construit sur Code OSS (la base de VS Code) et adossé à AWS : sa FAQ indique une connexion possible par AWS Builder ID et une facturation des offres entreprise via AWS. Chaque spec y produit trois fichiers : `requirements.md` pour les exigences, `design.md` pour l'architecture, `tasks.md` pour les tâches. Les critères d'acceptation suivent la notation EARS (Easy Approach to Requirements Syntax), un format structuré du type « quand \[événement\], le système doit \[comportement\] ». Kiro ajoute des « hooks », des automatisations déclenchées quand tu enregistres ou crées un fichier.

### Tessl

Tessl, encore en bêta privée lors de l'analyse de Böckeler, est cité comme l'outil le plus ambitieux : il vise une spec maintenue dans la durée, et explore l'idée d'une spec qui serait le seul fichier que les humains modifient.

|  | Spec Kit | Kiro | Sans outil |
| --- | --- | --- | --- |
| Forme | Commandes ajoutées à ton agent | IDE complet | Fichiers Markdown et prompts |
| Agent | Le tien (Copilot, Claude Code…) | Celui de Kiro | N'importe lequel |
| Fichiers produits | Spec, plan, tâches, constitution | requirements.md, design.md, tasks.md | Ceux que tu définis |
| Pour qui | Tu as déjà un agent et tu veux un cadre | Tu veux tout dans un seul outil | Tu veux tester la méthode d'abord |

## Les trois niveaux de spec-driven development

Böckeler distingue trois niveaux, et la distinction évite beaucoup de confusion.

1. **Spec-first** : la spec est écrite avant de coder une tâche, puis éventuellement abandonnée. C'est ce que font la plupart des outils.
2. **Spec-anchored** : la spec est conservée et mise à jour quand la fonctionnalité évolue.
3. **Spec-as-source** : la spec est le seul fichier que les humains modifient ; le code en est généré.

Pour un vibe coder, le niveau 2 est le plus rentable : une spec vivante, rangée dans le projet, que l'agent relit à chaque session. C'est aussi là que les fichiers de contexte comme CLAUDE.md ou AGENTS.md prennent le relais.

## Les limites à connaître avant de t'y mettre

Le SDD n'est pas une solution miracle, et les critiques publiées sont précises.

- **Trop lourd pour les petites tâches.** Böckeler note que les workflows de Kiro et Spec Kit sont disproportionnés pour un petit bug ou une fonctionnalité moyenne.
- **Beaucoup de Markdown à relire.** Spec Kit a produit chez elle de nombreux fichiers répétitifs et verbeux, plus pénibles à relire que le code lui-même.
- **Un faux sentiment de contrôle.** Les agents ignorent parfois des instructions de la spec, ou les appliquent trop.
- **Un terme flou.** Certains appellent « spec » ce qui n'est qu'un prompt détaillé.

> **Le piège classique** — Une spec que personne ne relit est pire que pas de spec : l'agent la suit avec assurance, erreurs comprises.

## Quand passer au spec-driven development ?

Voici un arbre de décision simple.

- **Si** tu testes une idée et que tu jetteras peut-être le projet la semaine prochaine, **alors** reste en vibe coding pur.
- **Si** la fonctionnalité touche aux paiements, aux comptes ou aux données des utilisateurs, **alors** écris une spec, même courte.
- **Si** l'agent casse régulièrement ce qui marchait, **alors** le projet a besoin d'une mémoire écrite : spec et fichier de contexte.
- **Si** la tâche tient en une phrase (« change la couleur du bouton »), **alors** pas de spec, un prompt suffit.
- **Si** tu travailles à plusieurs, **alors** la spec devient le document qu'on discute avant de coder.

## Le modèle prêt à copier pour démarrer sans outil

Tu peux appliquer la méthode avec [Claude Code](https://www.anthropic.com/claude-code), [Cursor](https://cursor.com/) ou [Codex](https://openai.com/codex/) sans rien installer. Crée un dossier `specs/` et colle ce prompt :

```text
Nous allons travailler en spec-driven development. Ne code rien pour l'instant.

Étape 1 : rédige specs/reservation/spec.md avec :
- le problème et les utilisateurs concernés
- les parcours utilisateur, étape par étape
- les règles métier (ex. : pas de réservation dans le passé)
- les critères d'acceptation au format « Quand [événement], le système doit [comportement] »
- les cas limites et ce qui est hors périmètre
Pose-moi d'abord les questions dont tu as besoin, puis attends ma validation.

Après validation : rédige specs/reservation/plan.md (choix techniques, tables, fichiers touchés),
puis specs/reservation/tasks.md (tâches numérotées, chacune testable seule).
Ensuite seulement, implémente la tâche 1 et arrête-toi pour que je vérifie.
```

Garde ces fichiers dans le projet et dans Git : ce sont eux qui empêchent la prochaine session de tout réinventer. Pour choisir l'agent qui suivra le mieux ce genre de plan, compare [Cursor, Claude Code et Codex](https://vibe-code.blog/blog/cursor-vs-claude-code-vs-codex), et si tu démarres avec l'un d'eux, lis [le guide pour bien démarrer avec Claude Code](https://vibe-code.blog/blog/claude-code-guide).

## Questions fréquentes

## Questions fréquentes

### Quelle différence entre spec-driven development et vibe coding ?

Le vibe coding part d'un prompt et juge le résultat à l'écran, sans relire le code. Le spec-driven development part d'une spécification écrite et validée, que l'agent transforme en plan puis en petites tâches vérifiables. Le premier est idéal pour prototyper vite ; le second pour construire des fonctionnalités qui doivent durer et rester maintenables quand le projet grossit.

### Faut-il un outil spécial pour faire du spec-driven development ?

Non. Spec Kit et Kiro outillent la méthode, mais tu peux l'appliquer avec n'importe quel agent de code : un dossier de fichiers Markdown (spec, plan, tâches) et un prompt qui interdit de coder avant validation suffisent. Commence sans outil pour voir si la méthode te convient, puis adopte un outil si tu veux un cadre plus strict.

### Le spec-driven development convient-il aux débutants ?

Oui, et c'est même souvent plus facile qu'un vibe coding pur : relire une spec en français demande moins de compétences que relire du code. La spec oblige à décider des règles avant que l'IA ne les invente. La limite : il faut accepter de passer du temps à écrire et relire avant de voir le résultat.

### Qu'est-ce que la notation EARS ?

EARS (Easy Approach to Requirements Syntax) est une façon structurée d'écrire des exigences, utilisée notamment par Kiro pour les critères d'acceptation. Elle suit des gabarits du type « Quand \[événement\], le système doit \[comportement\] ». Ce format réduit les ambiguïtés et facilite la vérification, par toi comme par l'agent.

### Le spec-driven development remplace-t-il les tests ?

Non. La spec dit ce que le code doit faire ; les tests vérifient qu'il le fait vraiment. Les critères d'acceptation d'une bonne spec se transforment d'ailleurs facilement en tests. Demande à l'agent d'écrire un test par critère, et vérifie toujours à la main les parcours critiques.

## Sources

- [Spec-driven development with AI: Get started with a new open source toolkit — GitHub Blog](https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/)
- [github/spec-kit — GitHub](https://github.com/github/spec-kit)
- [Introducing Kiro — Kiro](https://kiro.dev/blog/introducing-kiro/)
- [Specs — Kiro Docs](https://kiro.dev/docs/specs/)
- [FAQ — Kiro](https://kiro.dev/faq/)
- [Understanding Spec-Driven-Development: Kiro, spec-kit, and Tessl — Birgitta Böckeler, martinfowler.com](https://martinfowler.com/articles/exploring-gen-ai/sdd-3-tools.html)
- [AI-Generated Code Poses Major Security Risks in Nearly Half of All Development Tasks — Veracode](https://www.veracode.com/press-release/ai-generated-code-poses-major-security-risks-in-nearly-half-of-all-development-tasks-veracode-research-reveals/)

— Thierry Gustin, Formateur en intelligence artificielle (GustinAI) · 21 novembre 2026
