Flux axé sur les exigences

Le flux axé sur les exigences (Requirements-First) est l'approche traditionnelle des Feature Specs, qui commence par ce que le système doit faire avant de déterminer comment le construire.

Ce flux est idéal lorsque :

• Récits utilisateur clairs - Vous avez un comportement bien défini que Kiro peut utiliser pour créer des récits utilisateur
• Architecture flexible - La conception technique peut être adaptée pour répondre aux exigences
• Projets greenfield - Démarrage à neuf sans contraintes techniques existantes

Depuis le panneau Kiro ou la palette de commandes, créez un nouveau Feature Spec. Lorsque vous y êtes invité, sélectionnez le flux Requirements-First.

Kiro génère un document requirements.md basé sur votre requête.

Ce qui est inclus :

• Des récits utilisateur avec des critères d'acceptation clairs
• Des comportements du système au format EARS (WHEN...THE SYSTEM SHALL...)
• Des exigences fonctionnelles
• Des cas limites et la gestion des erreurs

Votre rôle :

• Examiner les exigences pour vérifier leur exhaustivité
• Itérer sur les récits utilisateur et les critères d'acceptation
• Ajouter tout scénario ou cas limite manquant
• Confirmer lorsque les exigences répondent à vos besoins

Exemple d'exigences :

## User Authentication

### User Registration

WHEN a user submits valid registration data
THE SYSTEM SHALL create a new user account

WHEN a user submits an email that already exists
THE SYSTEM SHALL display "Email already registered" error

WHEN a user submits invalid email format
THE SYSTEM SHALL display email validation error

Une fois les exigences confirmées, Kiro génère un document design.md qui décrit comment les mettre en œuvre.

Ce qui est généré :

• L'architecture du système et ses composants
• Des diagrammes de séquence montrant les interactions
• Des modèles de données et des interfaces
• Des recommandations de pile technologique
• Une approche de gestion des erreurs
• Une stratégie de tests

Votre rôle :

• Examiner l'approche technique
• Itérer sur les décisions architecturales
• Valider les choix technologiques
• Confirmer que la conception est réalisable

Kiro génère un fichier tasks.md avec des tâches d'implémentation exécutables.

Ce qui est généré :

• Des tâches distinctes et traçables
• Des descriptions claires et les résultats attendus
• Les dépendances entre les tâches
• Des tâches facultatives ou obligatoires

Votre rôle :

• Examiner la répartition des tâches
• Ajuster les priorités des tâches si nécessaire
• Marquer les tâches facultatives
• Commencer l'implémentation

Exécutez les tâches individuellement ou lancez toutes les tâches pour implémenter la fonctionnalité.

Soyez explicite sur :

• Qui est l'utilisateur
• Ce qu'il souhaite accomplir
• Pourquoi il a besoin de cette fonctionnalité
• Les critères de réussite

Exemple de requête :

Build a user authentication system. Users should be able to register with 
email/password, login securely, reset forgotten passwords, and logout. 
The system must prevent brute force attacks and validate email formats.

La force du Requirements-First est de bien cerner le « quoi » avant de s'engager dans le « comment ». Prenez le temps de :

• Valider que tous les scénarios utilisateur sont couverts
• S'assurer que les critères d'acceptation sont testables
• Obtenir l'adhésion des parties prenantes aux exigences
• Confirmer que les cas limites sont pris en compte

Les exigences au format EARS (WHEN...THE SYSTEM SHALL...) sont :

• Sans ambiguïté et testables
• Faciles à traduire en cas de test
• Traçables tout au long de l'implémentation
• Claires pour les parties prenantes techniques comme non techniques

Avant de passer aux tâches, validez que :

• La conception répond à toutes les exigences
• Les choix technologiques sont appropriés
• Les exigences non fonctionnelles sont prises en compte
• L'approche est maintenable

Scénario : Le gestionnaire de produit fournit des récits utilisateur pour une nouvelle fonctionnalité.

Approche :

1. Copier les récits utilisateur dans la requête initiale
2. Sélectionner le flux Requirements-First
3. Laisser Kiro formaliser les exigences au format EARS
4. Examiner et itérer sur les exigences avec le gestionnaire de produit
5. Générer la conception et la valider avec l'équipe d'ingénierie
6. Exécuter les tâches pour implémenter

Scénario : Un client demande une fonctionnalité spécifique.

Approche :

1. Décrire les besoins du client dans la requête initiale
2. Sélectionner le flux Requirements-First
3. Générer des exigences qui capturent l'intention du client
4. Valider les exigences avec le client
5. Générer une conception optimisée pour les exigences
6. Implémenter et livrer

Scénario : Démarrer une nouvelle application à partir de zéro.

Approche :

1. Définir les parcours utilisateur et les fonctionnalités essentiels
2. Sélectionner le flux Requirements-First
3. Générer des exigences complètes
4. Examiner la conception pour l'évolutivité et la maintenabilité
5. Exécuter les tâches pour construire le produit minimum viable

Si la conception générée ne répond pas entièrement aux exigences :

1. Examiner les exigences pour en vérifier la clarté et l'exhaustivité
2. Ajouter des critères d'acceptation plus précis
3. Régénérer la conception à partir des exigences mises à jour
4. Itérer jusqu'à ce que la conception s'harmonise avec les exigences

Si les exigences manquent de précision :

1. Ajouter plus de détails à votre requête initiale
2. Inclure des scénarios utilisateur et des cas limites précis
3. Définir des critères de réussite clairs
4. Utiliser le format EARS pour plus de précision

Si vous devez modifier les exigences après la génération de la conception :

1. Modifier le document requirements.md
2. Cliquer sur Refine dans le fichier design.md
3. Kiro mettra à jour la conception et les tâches pour correspondre aux nouvelles exigences
4. Ceci est normal - l'itération fait partie du processus

• Flux axé sur la conception technique →
• Bonnes pratiques →