Développement piloté par les spécifications
Transformez les besoins en spécifications, plans, code et registres de changements traçables.
Donnez aux personnes et aux Coding Agents un contrat commun avant l’implémentation. FiboCode et Fibo Skills transforment une demande initiale en critères d’acceptation explicites, conception reliée, plan ordonné, code révisé et registre de changements conservé dans le dépôt.
Coder vite ne signifie pas coder de façon alignée.
Un Coding Agent peut passer rapidement d’une demande courte à l’implémentation, mais les hypothèses manquantes apparaissent souvent après la modification des fichiers. Si le besoin, les limites et la preuve d’achèvement restent implicites, les personnes chargées de la révision doivent reconstruire le comportement attendu tout en évaluant le code.
Le développement piloté par les spécifications crée un parcours explicite avant l’exécution. Le besoin devient des critères d’acceptation testables ; les décisions de conception expliquent comment les satisfaire ; le plan nomme dans l’ordre tâches, fichiers et vérifications. L’implémentation dispose alors d’un contrat visible et le registre final du diff explique les changements réels.
Voyez le flux rester relié au travail réel.
Ces démonstrations montrent des documents traçables qui grandissent avec le code, tandis que l’Agent CLI reste dans le flux de terminal existant.
Voyez la chaîne documentaire qui relie un besoin initial aux décisions, tâches, preuves d’implémentation et connaissances futures.
Gardez l’Agent CLI dans le terminal tout en lui fournissant fichiers, symboles, captures d’écran et chemins de sortie navigables.
Passez de l’intention aux preuves en quatre étapes.
Chaque étape a un but propre, afin de résoudre les questions avant qu’elles ne deviennent des choix d’implémentation cachés.
Clarifiez le besoin et les critères d’acceptation.
Transformez la demande initiale en résultats explicites et testables et définissez ce qui reste hors du changement. Le développeur valide le contrat avant le début du code de production.
Concevez l’approche à partir des critères.
Décrivez comment le système satisfera chaque critère, notamment les limites, interfaces et compromis importants. Les liens maintiennent chaque décision rattachée au comportement qu’elle sert.
Créez et exécutez un plan ordonné.
Découpez la conception en tâches délimitées avec fichiers concernés et méthodes d’acceptation. Le Coding Agent suit la séquence avec le contexte convenu.
Révisez le code et consignez le changement réel.
Inspectez le diff obtenu, vérifiez les critères d’acceptation et conservez une explication centrée sur les hunks de ce qui a changé et pourquoi.
Un contrat traçable autour de l’exécution par l’Agent.
Des critères d’acceptation avant l’implémentation.
Une spécification transforme une intention floue en résultats observables et donne au développeur et à l’Agent une définition commune de l’achèvement.
Des décisions de conception reliées au comportement.
La conception explique le fonctionnement attendu du changement et maintient chaque décision importante liée au critère qui l’exige.
Une exécution délimitée et ordonnée.
Les plans nomment les tâches, fichiers concernés et méthodes de vérification afin que l’implémentation avance en unités révisables plutôt qu’en un saut opaque.
Un historique des changements ancré dans le diff.
Après l’exécution, un registre fondé sur le diff réel explique les hunks d’implémentation et les relie à la logique environnante et à l’intention du projet.
Cas d’utilisation : modifier le comportement dans plusieurs modules.
Une demande paraît simple, mais touche au routage, à l’état, à la UI et à la validation. Le développeur convient d’abord des résultats observables et des exclusions. La conception associe ces résultats aux limites concernées et le plan sépare le travail en tâches par fichiers, chacune avec sa méthode de vérification.
L’Agent CLI exécute alors avec moins de décisions cachées. Les personnes chargées de la révision peuvent comparer le résultat aux critères validés, examiner les changements réels et conserver un registre du diff qui relie l’implémentation au besoin initial.
Une couche de flux, pas un remplacement de votre Agent ni de vos tests.
Fibo Skills guide les étapes de clarification, spécification, conception, planification, exécution et consignation des changements. L’Agent CLI choisi effectue toujours le travail de programmation, et les tests et méthodes d’acceptation réels du projet déterminent toujours si le résultat est correct.
La valeur réside dans l’alignement partagé et la traçabilité. Un flux centré sur le prompt peut commencer à coder alors que l’intention reste imprécise ; le parcours piloté par les spécifications rend cette intention révisable avant le changement et conserve ses preuves après.
FAQ sur le développement piloté par les spécifications
Ai-je besoin d’une spécification pour chaque petite modification ?
Utilisez ce flux lorsque le comportement, les limites ou l’acceptation nécessitent un alignement. Une petite modification mécanique peut demander moins de profondeur qu’une fonctionnalité couvrant plusieurs modules.
Que sont Fibo Skills ?
Fibo Skills désigne les instructions de flux utilisées avec les environnements Agent CLI compatibles pour guider clarification, spécification, conception, planification, exécution et consignation des changements.
L’Agent peut-il commencer à coder avant la validation ?
Le flux prévu demande au développeur d’approuver d’abord la spécification, afin que le code de production repose sur un contrat comportemental explicite plutôt que sur des hypothèses non résolues.
Comment la conception et le plan restent-ils traçables ?
Les décisions de conception renvoient aux critères d’acceptation, tandis que les tâches du plan nomment les critères, fichiers et méthodes d’acceptation concernés.
Que se passe-t-il après l’implémentation ?
Le résultat est révisé selon la spécification et le diff réel. Un registre de changements peut ensuite expliquer les hunks d’implémentation et conserver leur raison d’être.