# Exemples de tâches multi-étapes (/fr/docs/verdent-for-vscode/common-workflows/multi-step-tasks)

> Gérer des tâches complexes en plusieurs étapes avec Verdent



Verdent for VS Code excelle à décomposer de manière autonome des tâches complexes en plusieurs étapes. Ce guide présente des flux de travail détaillés pour des scénarios multi-étapes courants, montrant précisément comment Verdent gère la décomposition des tâches, la gestion des dépendances et l'exécution progressive.

***

## Utiliser Plan Mode pour des implémentations complexes [#utiliser-plan-mode-pour-des-implémentations-complexes]

Supposons que vous souhaitiez examiner un plan détaillé avant que Verdent n'apporte des modifications à votre base de code.

<Steps>
  <Step title="Passer en Plan Mode">
    Sélectionnez le bouton « Switch Mode » dans l'interface, puis choisissez « Plan Mode ».

    Plan Mode est en lecture seule : Verdent peut analyser le code, effectuer des recherches et créer des plans sans modifier de fichiers ni exécuter de commandes.
  </Step>

  <Step title="Envoyer votre demande complexe">
    ```
    Refactor this codebase to replace our custom authentication with OAuth 2.0
    ```

    Verdent analyse minutieusement votre implémentation actuelle.
  </Step>

  <Step title="Répondre aux questions de clarification">
    Verdent peut poser des questions pour lever les incertitudes :

    * Quel fournisseur OAuth devons-nous utiliser ?
    * Les jetons doivent-ils être stockés dans localStorage ou dans des cookies ?
    * Devons-nous prendre en charge plusieurs fournisseurs OAuth ?

    Répondez à ces questions pour affiner le plan.
  </Step>

  <Step title="Examiner le plan détaillé">
    Verdent présente un plan complet indiquant :

    * Les fichiers à créer
    * Les fichiers existants à modifier
    * Les étapes d'implémentation dans un ordre logique
    * Les dépendances entre les étapes

    Examinez ce plan attentivement avant de poursuivre.
  </Step>

  <Step title="Choisir votre prochaine action">
    Après avoir examiné le plan, Verdent propose deux options :

    * Choisissez **Edit** pour demander des modifications ou poser des questions de clarification
    * Choisissez **Start Building** pour passer en Agent Mode et commencer l'exécution

    Vous pouvez itérer sur le plan autant de fois que nécessaire avant de lancer la construction.
  </Step>
</Steps>

<Tip>
  **Conseils :**

  * Utilisez Plan Mode pour les fonctionnalités affectant plusieurs fichiers
  * Effectuez plusieurs cycles d'examen du plan pour affiner l'approche
  * Enregistrez le plan dans un fichier pour une discussion d'équipe avant l'exécution
  * Plan Mode aide à garantir l'alignement entre vos attentes et la solution proposée par Verdent
  * **Personnaliser le format du plan :** accédez à **Settings → Rules → Plan Rules** pour contrôler la structure du plan, le niveau de détail et les préférences de formatage
</Tip>

***

## Décomposer les demandes de fonctionnalités volumineuses [#décomposer-les-demandes-de-fonctionnalités-volumineuses]

Supposons que vous construisiez un système de commande e-commerce complexe comportant plusieurs composants intégrés.

<Steps>
  <Step title="Fournir l'objectif de haut niveau">
    ```
    Build a complete checkout system with cart management, payment processing, order confirmation, and inventory updates
    ```

    Verdent analyse ce qui doit être fait.
  </Step>

  <Step title="Verdent crée des sous-tâches logiques">
    Le système décompose cela de manière autonome en :

    1. Créer le modèle de données du panier et API
    2. Construire l'interface du panier avec ajout/suppression/mise à jour des articles
    3. Implémenter la page de commande avec le formulaire d'adresse de livraison
    4. Intégrer la passerelle de paiement (Stripe ou fournisseur configuré)
    5. Créer la page de confirmation de commande
    6. Ajouter la logique de mise à jour des stocks
    7. Implémenter le système de confirmation par e-mail
    8. Écrire les tests d'intégration

    Chaque sous-tâche est affichée dans la liste des tâches avec des descriptions claires.
  </Step>

  <Step title="Verdent gère automatiquement les dépendances">
    Verdent exécute les sous-tâches dans le bon ordre :

    * Crée les modèles de données avant les points d'entrée API qui les utilisent
    * Construit les points d'entrée backend avant les composants frontend qui les appellent
    * Implémente les fonctionnalités principales avant d'ajouter les tests

    Les dépendances sont gérées automatiquement sans intervention manuelle.
  </Step>

  <Step title="Suivre la progression en temps réel">
    Observez la liste des tâches se mettre à jour en temps réel pendant que Verdent traite chaque sous-tâche. Les éléments passent de en attente → en cours → terminé.
  </Step>
</Steps>

<Tip>
  **Conseils :**

  * Laissez Verdent gérer la décomposition de manière autonome pour la plupart des tâches
  * Utilisez Plan Mode si vous souhaitez examiner la décomposition avant l'exécution
  * Verdent ajuste son approche lorsqu'il rencontre des cas particuliers ou de nouvelles exigences
  * La liste des tâches visible offre une transparence sur l'exécution multi-étapes
</Tip>

***

## Projets de refactorisation en plusieurs phases [#projets-de-refactorisation-en-plusieurs-phases]

Supposons que vous refactorisiez une base de code volumineuse et souhaitiez procéder par phases gérables.

<Steps>
  <Step title="Définir l'approche en plusieurs phases">
    ```
    In Plan Mode: Refactor this codebase to replace our custom authentication with OAuth 2.0. I want this done in phases so we can test incrementally.
    ```
  </Step>

  <Step title="Verdent propose une décomposition en phases">
    Verdent suggère un plan en plusieurs phases :

    * **Phase 1** : ajouter la bibliothèque OAuth et configurer les points d'entrée
    * **Phase 2** : mettre à jour le modèle utilisateur et le schéma de base de données
    * **Phase 3** : migrer la logique d'authentification existante
    * **Phase 4** : supprimer le code d'authentification obsolète
    * **Phase 5** : mettre à jour les tests et la documentation

    Chaque phase peut être testée indépendamment.
  </Step>

  <Step title="Exécuter phase par phase">
    Approuvez la Phase 1, laissez Verdent l'exécuter, puis testez :

    ```
    npm test
    ```

    Une fois la Phase 1 vérifiée et fonctionnelle, passez à la Phase 2.
  </Step>

  <Step title="Ajuster les phases suivantes si nécessaire">
    En fonction de ce que vous apprenez lors de la Phase 1, vous pouvez ajuster l'approche pour les phases restantes :

    ```
    For Phase 2, let's also add user role migration to the database schema changes
    ```
  </Step>

  <Step title="Terminer toutes les phases progressivement">
    Traitez toutes les phases avec des tests et une vérification entre chacune, afin de garantir la sécurité et de permettre une correction de trajectoire.
  </Step>
</Steps>

<Tip>
  **Conseils :**

  * La refactorisation en plusieurs phases réduit les risques en permettant des tests progressifs
  * Chaque phase doit laisser la base de code dans un état fonctionnel
  * Effectuez un commit après chaque phase pour faciliter un retour en arrière si nécessaire
  * Ajustez les phases suivantes en fonction des enseignements tirés des phases précédentes
</Tip>

***

## Coordonner les modifications backend et frontend [#coordonner-les-modifications-backend-et-frontend]

Supposons que vous ajoutiez une fonctionnalité nécessitant des mises à jour synchronisées des API backend et des composants frontend.

<Steps>
  <Step title="Décrire la fonctionnalité full-stack">
    ```
    Add a commenting system where users can add comments to blog posts. Include backend API, database schema, and frontend UI
    ```
  </Step>

  <Step title="Verdent coordonne une approche backend-first">
    Verdent adopte généralement une approche backend-first pour les fonctionnalités full-stack :

    1. Créer la migration de base de données pour la table des commentaires
    2. Ajouter le point d'entrée API pour créer des commentaires
    3. Ajouter le point d'entrée API pour récupérer les commentaires
    4. Définir les interfaces TypeScript pour les données de commentaire
    5. Construire le composant de formulaire de commentaire côté frontend
    6. Créer le composant d'affichage des commentaires
    7. Connecter le frontend aux points d'entrée API
  </Step>

  <Step title="Verdent garantit la cohérence">
    Verdent garantit que :

    * Les interfaces TypeScript du frontend correspondent aux structures de données du backend
    * Les URL des points d'entrée API sont correctement référencées dans le code frontend
    * Les formats de requête/réponse sont alignés entre le backend et le frontend
    * La gestion des erreurs est cohérente sur toute la pile
  </Step>

  <Step title="Tests d'intégration">
    ```
    Write integration tests for the commenting system covering the full stack
    ```

    Verdent crée des tests qui vérifient que le backend et le frontend fonctionnent correctement ensemble.
  </Step>
</Steps>

<Tip>
  **Conseils :**

  * L'approche backend-first garantit que le frontend dispose de API fonctionnels avec lesquels s'intégrer
  * Verdent maintient automatiquement la cohérence entre le code backend et frontend
  * Les interfaces TypeScript permettent de détecter les problèmes d'intégration à la compilation
  * Les tests d'intégration vérifient que la fonctionnalité complète fonctionne de bout en bout
</Tip>

***

## Utiliser des sous-agents pour l'exécution parallèle [#utiliser-des-sous-agents-pour-lexécution-parallèle]

Supposons que vous ayez plusieurs tâches indépendantes pouvant être réalisées simultanément.

<Steps>
  <Step title="Identifier les tâches parallélisables">
    ```
    Generate unit tests for all service classes in the src/services directory
    ```

    Ces fichiers de test sont indépendants et peuvent être créés en parallèle.
  </Step>

  <Step title="Verdent délègue à plusieurs sous-agents">
    Verdent utilise automatiquement plusieurs sous-agents pour traiter des tâches indépendantes en simultané :

    * Sous-agent 1 : crée les tests pour UserService
    * Sous-agent 2 : crée les tests pour PaymentService
    * Sous-agent 3 : crée les tests pour NotificationService
    * Sous-agent 4 : crée les tests pour AuthService

    Tout le travail s'effectue en parallèle, ce qui permet de gagner du temps.
  </Step>

  <Step title="Les résultats sont intégrés">
    Chaque sous-agent renvoie ses résultats. Verdent intègre tous les fichiers de test dans le projet avec une nomenclature et une structure adaptées.
  </Step>

  <Step title="Vérification séquentielle">
    Après la création en parallèle, exécutez les tests de manière séquentielle pour vérifier qu'ils fonctionnent tous :

    ```
    npm test
    ```
  </Step>
</Steps>

<Tip>
  **Conseils :**

  * Verdent parallélise automatiquement les tâches indépendantes à l'aide de sous-agents
  * Le travail faiblement couplé (fichiers de test séparés, composants indépendants) profite de la parallélisation
  * Le travail fortement couplé (fichiers avec des dépendances) est effectué de manière séquentielle par souci de correction
  * L'exécution parallèle accélère considérablement les modifications à grande échelle
</Tip>

***

## Questions fréquentes [#questions-fréquentes]

<Accordion title="Puis-je interrompre Verdent au milieu d'une tâche multi-étapes ?">
  Oui. Vous pouvez interrompre l'exécution à tout moment. Verdent terminera l'étape en cours sur laquelle il travaille, puis s'arrêtera. La progression réalisée jusqu'à ce moment est conservée. Vous pouvez examiner ce qui a été fait, apporter des ajustements, puis soit continuer, soit adopter une approche différente.
</Accordion>

<Accordion title="Comment savoir ce que fait Verdent en ce moment dans une tâche longue ?">
  Observez la liste des tâches. Elle affiche un statut en temps réel, avec un seul élément marqué « en cours » à tout instant. L'élément actif indique précisément ce sur quoi Verdent travaille actuellement. Les éléments terminés sont marqués comme tels, et les éléments en attente indiquent ce qui reste à faire.
</Accordion>

<Accordion title="Que faire si je ne suis pas d'accord avec la façon dont Verdent a décomposé ma tâche ?">
  Utilisez Plan Mode pour examiner et ajuster la décomposition avant l'exécution. En Plan Mode, vous pouvez donner un retour du type « Divisez le travail frontend en composants séparés » ou « Combinez ces deux étapes ». Verdent révisera le plan en fonction de vos indications avant que la moindre ligne de code ne soit écrite.
</Accordion>

<Accordion title="Dois-je utiliser Plan Mode pour chaque tâche multi-étapes ?">
  Pas nécessairement. Utilisez Plan Mode pour les fonctionnalités complexes affectant de nombreux fichiers, les refactorisations importantes, ou lorsque vous souhaitez d'abord examiner l'approche. Pour les tâches familières et simples, Verdent peut s'exécuter directement avec une visibilité en temps réel sur la liste des tâches. Plan Mode ajoute une étape de revue pour les modifications à risque plus élevé.
</Accordion>

<Accordion title="Puis-je modifier le plan de Verdent après le début de l'exécution ?">
  Vous pouvez fournir des indications correctives pendant que Verdent travaille. Dites « En fait, utilise une approche différente pour l'intégration API » et Verdent ajustera les étapes restantes. Pour des changements de plan majeurs, il est préférable d'arrêter, de valider ce qui a été fait, puis de démarrer une nouvelle session avec l'approche révisée.
</Accordion>

***

## Voir aussi [#voir-aussi]

<CardGroup cols="2">
  <Card title="Écrire du nouveau code" icon="code" href="/docs/verdent-for-vscode/task-based-guides/writing-code">
    Créer de nouvelles fonctionnalités et composants avec Verdent
  </Card>

  <Card title="Bonnes pratiques" icon="star" href="/docs/verdent-for-vscode/best-practices/prompts">
    Prompts efficaces et stratégies de flux de travail
  </Card>
</CardGroup>