Passer au contenu principal
Afficher en Markdown

Flux de travail axé sur la conception

Le flux de travail axé sur la conception commence par une conception technique ou une architecture système et en dérive des exigences réalisables.

Quand l'utiliser

Ce flux de travail est idéal lorsque :

  • Prototypage rapide - Vous connaissez la pile technologique et voulez explorer ce qui est possible
  • Contraintes techniques - Le système doit respecter des exigences non fonctionnelles strictes (latence, débit, disponibilité, conformité)
  • Conceptions existantes - Vous avez des diagrammes d'architecture ou des documents de conception à transposer dans Kiro
  • Exploration de la faisabilité - Vous voulez comprendre quelles exigences sont réalisables selon une conception donnée
  • Préférences marquées - Vous avez des préférences ou contraintes architecturales précises

Étapes du flux de travail

1. Créer un Spec de fonctionnalité

À partir du panneau Kiro ou de la palette de commandes, créez un nouveau Spec de fonctionnalité. Lorsque vous y êtes invité, sélectionnez le flux de travail Design-First.

2. Choisir le niveau de détail

Sélectionnez le niveau de détail architectural que vous voulez fournir :

Conception de haut niveau

Architecture complète comprenant :

  • Diagramme d'architecture système
  • Descriptions des composants et de leurs interactions
  • Approche technique et modèles utilisés
  • Propriétés non fonctionnelles (performance, scalabilité, sécurité)

Idéal pour : systèmes complexes, collaboration en équipe, documentation exhaustive

Conception de bas niveau

Axée sur les détails d'implémentation :

  • Pseudocode algorithmique
  • Définitions et contrats d'interface
  • Structures de données clés
  • Propriétés non fonctionnelles

Idéal pour : prototypage rapide, vérifications rapides de faisabilité, développement en solo

3. Phase de conception

Kiro génère un document design.md en fonction de votre requête et du niveau de détail choisi.

Ce qui est inclus :

  • Composants du système et leurs responsabilités
  • Flux de données et interactions
  • Pile technologique et cadres d'application (frameworks)
  • Contrats et interfaces d'API
  • Considérations non fonctionnelles

Votre rôle :

  • Vérifier l'exactitude de l'architecture
  • Faire évoluer la conception en fournissant des commentaires
  • Explorer des approches alternatives si nécessaire
  • Confirmer lorsque l'architecture répond à vos besoins

Astuce : Le document de conception s'ouvre par défaut en mode aperçu pour une meilleure lisibilité. Cliquez sur « Modifier » pour apporter des changements.

4. Phase des exigences

Une fois l'architecture confirmée, Kiro dérive des exigences réalisables selon la conception technique.

Ce qui est généré :

  • Récits utilisateur alignés sur les capacités architecturales
  • Comportements système au format EARS
  • Exigences fonctionnelles délimitées par la conception
  • Cas limites et gestion des erreurs

Avantage clé : Les exigences sont garanties d'être techniquement réalisables puisqu'elles sont dérivées d'une architecture validée.

Votre rôle :

  • Vérifier l'exhaustivité des exigences
  • Ajouter tout comportement orienté utilisateur manquant
  • Confirmer que les exigences correspondent à vos attentes

5. Phase des tâches

Identique au flux de travail axé sur les exigences - Kiro génère des tâches d'implémentation exécutables.

6. Implémentation

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

Bonnes pratiques

Commencer avec des contraintes techniques claires

Soyez explicite au sujet :

  • Des technologies ou services requis
  • Des exigences de performance (latence, débit)
  • Des besoins de scalabilité
  • Des exigences de conformité ou de sécurité
  • Des points d'intégration avec les systèmes existants

Exemple de requête :

Create an MCP server for querying our Redshift data lake. Must use FastAPI and mcp-python. Target: <100ms query latency for 95th percentile. No UI components needed - pure API server.

Faire évoluer l'architecture avant les exigences

La force du flux de travail axé sur la conception réside dans l'exploration des conceptions techniques. Prenez le temps de :

  • Essayer différentes approches architecturales
  • Évaluer les compromis (latence contre coût, complexité contre maintenabilité)
  • Valider que les exigences non fonctionnelles sont réalisables
  • Bien établir la conception avant de figer les exigences

Utiliser la conception de haut niveau pour les projets d'équipe

Si plusieurs personnes vont travailler sur l'implémentation, choisissez la conception de haut niveau pour une meilleure documentation et une compréhension partagée.

Utiliser la conception de bas niveau pour une validation rapide

Lorsque vous voulez vérifier rapidement si une idée est réalisable, la conception de bas niveau vous amène plus rapidement à la validation grâce aux détails d'implémentation.

Téléverser des conceptions existantes

Si vous avez des diagrammes d'architecture provenant de draw.io, Lucidchart, ou des croquis à la main :

  1. Exportez-les en PNG ou téléversez des photos
  2. Incluez-les dans votre requête initiale
  3. Kiro intégrera la conception visuelle dans le document d'architecture

Modèles courants

Modèle 1 : Transposer des conceptions externes

Scénario : Vous avez un document de conception provenant d'un autre outil ou de notes de réunion.

Approche :

  1. Copiez le contenu de la conception ou téléversez des diagrammes
  2. Sélectionnez le flux de travail Design-First
  3. Choisissez la conception de haut niveau
  4. Laissez Kiro formaliser la conception dans design.md
  5. Dérivez les exigences à partir de la conception formalisée

Modèle 2 : Explorer la faisabilité technique

Scénario : Vous voulez savoir si une fonctionnalité est possible avec des contraintes précises.

Approche :

  1. Décrivez les contraintes techniques et l'architecture approximative
  2. Sélectionnez le flux de travail Design-First
  3. Choisissez la conception de bas niveau pour une itération plus rapide
  4. Vérifiez les exigences générées pour voir ce qui est réalisable
  5. Faites évoluer l'architecture si les exigences ne correspondent pas aux attentes

Modèle 3 : Prototypage avec une pile connue

Scénario : Le client spécifie des services précis (Lambda, S3, DynamoDB) et vous devez prototyper rapidement.

Approche :

  1. Décrivez la pile technologique et le flux de haut niveau
  2. Sélectionnez le flux de travail Design-First
  3. Générez l'architecture avec les services spécifiés
  4. Dérivez les exigences montrant ce que le système peut faire
  5. Exécutez les tâches pour construire le prototype

Modèle 4 : Répondre à des exigences non fonctionnelles strictes

Scénario : Le système doit répondre à des exigences précises de latence, de débit ou de conformité.

Approche :

  1. Définissez les exigences non fonctionnelles dans la requête initiale
  2. Sélectionnez le flux de travail Design-First
  3. Choisissez la conception de haut niveau pour documenter l'approche de conformité
  4. Validez que l'architecture respecte toutes les contraintes
  5. Dérivez des exigences réalisables dans les limites des contraintes

Dépannage

Les exigences ne correspondent pas aux attentes

Si les exigences générées ne s'alignent pas avec ce que vous voulez :

  1. Revenez en arrière et faites évoluer l'architecture
  2. Ajoutez plus de détails sur les capacités visées
  3. Clarifiez les exigences non fonctionnelles
  4. Régénérez les exigences à partir de l'architecture mise à jour

Architecture trop générique

Si l'architecture manque de précision :

  1. Fournissez plus de détails techniques dans votre requête
  2. Précisez les cadres d'application, bibliothèques ou services exacts
  3. Incluez les chiffres de performance et les contraintes
  4. Choisissez la conception de haut niveau pour plus de profondeur

Besoin de modifier la conception après les exigences

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

  1. Modifiez le document design.md
  2. Demandez à Kiro de valider les exigences par rapport à l'architecture mise à jour
  3. Régénérez les exigences si nécessaire
  4. Ceci est normal - l'itération fait partie du processus

Exemples de requêtes

Conception de haut niveau

Design a real-time notification system using AWS services. Must support: - 100k concurrent WebSocket connections - <50ms message delivery latency - Message persistence for offline users - Integration with existing user authentication service Use API Gateway WebSocket, Lambda, DynamoDB, and SQS. Include architecture diagram showing component interactions and data flow.

Conception de bas niveau

Build a rate limiter middleware for our Express API. Requirements: - Token bucket algorithm - Per-user and per-IP limits - Redis for distributed state - Configurable limits per endpoint Show pseudocode for the core algorithm and interface definitions.

Avantages du flux axé sur la conception

  1. Produit des exigences réalisables - Les exigences sont dérivées d'une conception technique validée
  2. Évite la frustration de la réconciliation - Pas besoin de mettre à jour les exigences en explorant des conceptions
  3. Économise du temps et des crédits - Moins d'itérations entre les exigences et la conception
  4. Explore les options techniques - Essayez différentes approches techniques avant de vous engager
  5. Valide les contraintes tôt - Assurez-vous que les exigences non fonctionnelles sont réalisables
Page mise à jour : 11 août 2026