test-driven-development

Présentation du skill test-driven-development

Le skill test-driven-development vous aide à modifier du code en prouvant d’abord le comportement, puis en implémentant le correctif le plus minimal qui fait passer le test. Il convient particulièrement aux développeurs et aux agents qui travaillent sur des changements de logique, des corrections de bugs, des cas limites et des régressions, là où un résultat qui “semble correct” ne suffit pas. Si vous avez besoin du test-driven-development skill pour réduire la part d’approximation, ce guide vous explique quand il est pertinent et ce qu’il améliore réellement : des modifications plus sûres, des exigences plus claires et moins d’allers-retours après un premier correctif.

À quoi sert ce skill

Utilisez test-driven-development quand la tâche modifie le comportement : nouvelles fonctions, conditions ajustées, reproduction d’un bug, ou tout ce qui peut casser silencieusement du code existant. Il est particulièrement utile lorsque le dépôt contient déjà des tests et que vous voulez faire travailler l’agent à l’intérieur du système de preuve du projet, plutôt que de laisser l’agent inventer le comportement à partir de zéro.

Ce qui le rend différent

La valeur centrale, c’est la discipline : écrire d’abord un test qui échoue, puis n’implémenter que ce que le test démontre. Cela donne à l’agent une cible concrète, met au jour plus tôt les hypothèses manquantes et aide à garder les correctifs ciblés. Pour test-driven-development for Skill Testing, c’est souvent la différence entre un patch plausible et un patch vérifié.

Quand ce n’est pas adapté

N’utilisez pas ce skill pour des changements qui n’ont aucun comportement à l’exécution : corrections de texte, mises à jour de contenu statique ou simples ajustements de configuration. Si le projet a peu ou pas de couverture de tests, le skill peut quand même aider, mais l’adoption sera plus lente, car il faudra peut-être d’abord préparer l’infrastructure de test avant que le workflow ne porte ses fruits.

Comment utiliser le skill test-driven-development

Installer et examiner le skill

Utilisez le flux d’installation du dépôt pour test-driven-development install :

npx skills add addyosmani/agent-skills --skill test-driven-development

Après l’installation, commencez par SKILL.md. Dans ce dépôt, il n’y a pas de dossiers supplémentaires rules/, resources/ ou scripts/ sur lesquels s’appuyer ; l’essentiel consiste donc à lire attentivement le fichier du skill et à relier ses recommandations à votre base de code.

Transformer une tâche floue en demande testable

Le meilleur test-driven-development usage commence par une description de comportement, pas par une demande de solution. Un bon brief ressemble à : “Ajoute d’abord un test qui échoue pour la validation d’un e-mail vide, puis implémente le correctif minimal dans src/auth.ts.” Un brief faible ressemble à : “Améliore la connexion.” Incluez le résultat observable, le fichier ou le module si vous le connaissez, et le risque de régression qui vous préoccupe.

Suivre la boucle RED-GREEN-REFACTOR

Servez-vous du skill comme d’un workflow : d’abord écrire un test qui échoue avec le code actuel, puis faire le plus petit changement de code qui le fait passer, puis refactoriser seulement si le test passe toujours. Si l’échec est difficile à reproduire, arrêtez-vous et précisez le cas de test avant de toucher à l’implémentation. Le skill fonctionne au mieux quand le cas d’échec est assez précis pour prouver le bug.

Lire d’abord les bons fichiers

Pour ce dépôt, la première lecture la plus importante est SKILL.md. Inspectez ensuite la configuration de test locale dans votre projet cible : configuration du test runner, conventions de tests existantes, et tests les plus proches du code que vous allez modifier. Si le projet suit déjà des patterns solides, respectez-les à la lettre ; sinon, gardez le test minimal et explicite.

FAQ du skill test-driven-development

Est-ce réservé aux ingénieurs expérimentés ?

Non. Les débutants peuvent utiliser test-driven-development, mais ils ont besoin d’un point de départ clair : un comportement, un test qui échoue, un correctif minimal. Le skill est plus simple à apprendre sur de petites corrections de bugs que sur des fonctionnalités larges.

En quoi cela diffère-t-il d’un prompt normal ?

Un prompt normal peut demander du code qui “fonctionne”. Ce skill demande une preuve. Le test-driven-development guide pousse l’agent à définir le succès comme un test qui passe, ce qui réduit l’ambiguïté et facilite la revue.

Quand ne faut-il pas le choisir ?

Évitez-le pour la documentation, le formatage ou les changements qui ne peuvent pas être exprimés comme un comportement à l’exécution. Évitez-le aussi si le projet n’a pas de test harness exploitable et que vous avez seulement besoin d’une modification rapide sans impact comportemental.

Convient-il à tous les écosystèmes ?

Oui en principe, mais les commandes de test, les assertions et la structure des fichiers dépendent de la stack. Le skill est indépendant du framework ; ce sont les conventions locales du dépôt qui déterminent si vous utilisez Jest, Vitest, pytest, JUnit ou un autre runner.

Comment améliorer le skill test-driven-development

Donner à l’agent un cas d’échec plus précis

L’entrée la plus solide nomme le comportement en échec, le résultat attendu et la condition limite. Exemple : “Quand parseDate("") s’exécute, il doit lever InvalidDateError ; ajoute d’abord le test, puis corrige le parser.” Cela aide le test-driven-development skill à éviter les suppositions d’implémentation trop vagues.

Partager le style de tests existant

Mentionnez les fichiers de tests voisins, les conventions de nommage et les helpers ou fixtures déjà utilisés dans le projet. Si le dépôt utilise des tests table-driven, des mocks ou des tests d’intégration pour un comportement similaire, dites-le. S’aligner sur la convention locale renforce la confiance et facilite l’intégration du résultat.

Surveiller les échecs les plus fréquents

Les erreurs les plus courantes sont d’écrire l’implémentation avant le test, d’utiliser un test qui passe déjà et d’élargir le correctif au-delà du cas en échec. Si la première réponse est trop large, demandez le plus petit test en échec possible et un seul patch minimal. C’est généralement le chemin le plus rapide vers un test-driven-development usage fiable.

Itérer avec des preuves, pas avec des suppositions

Après le premier passage, demandez le point de preuve suivant : un autre cas limite, un test de régression ou un refactor qui conserve des tests verts. Si le bug est subtil, demandez un résumé du comportement avant/après ainsi que le nom exact du test à ajouter. Cela garde le workflow ancré dans un comportement observable plutôt que dans des hypothèses.