# Esempi di attività multi-step (/it/docs/verdent-for-vscode/common-workflows/multi-step-tasks)

> Gestire attività complesse multi-step con Verdent



Verdent for VS Code eccelle nello scomporre autonomamente attività complesse multi-step. Questa guida offre flussi di lavoro passo passo per scenari multi-step comuni, mostrando esattamente come Verdent gestisce la decomposizione delle attività, la gestione delle dipendenze e l'esecuzione progressiva.

***

## Usare Plan Mode per implementazioni complesse [#usare-plan-mode-per-implementazioni-complesse]

Supponiamo che tu voglia rivedere un piano dettagliato prima che Verdent apporti modifiche al tuo codebase.

<Steps>
  <Step title="Passa a Plan Mode">
    Seleziona il pulsante "Switch Mode" nell'interfaccia e scegli "Plan Mode".

    Plan Mode è in sola lettura: Verdent può analizzare il codice, condurre ricerche e creare piani senza modificare file o eseguire comandi.
  </Step>

  <Step title="Invia la tua richiesta complessa">
    ```
    Refactor this codebase to replace our custom authentication with OAuth 2.0
    ```

    Verdent analizza a fondo la tua implementazione attuale.
  </Step>

  <Step title="Rispondi alle domande di chiarimento">
    Verdent potrebbe porre domande per eliminare le incertezze:

    * Quale provider OAuth dovremmo usare?
    * I token vanno memorizzati in localStorage o nei cookie?
    * Dobbiamo supportare più provider OAuth?

    Rispondi a queste domande per affinare il piano.
  </Step>

  <Step title="Rivedi il piano dettagliato">
    Verdent presenta un piano completo che mostra:

    * I file da creare
    * I file esistenti da modificare
    * I passaggi di implementazione in ordine logico
    * Le dipendenze tra i passaggi

    Rivedi con attenzione questo piano prima di procedere.
  </Step>

  <Step title="Scegli l'azione successiva">
    Dopo aver rivisto il piano, Verdent presenta due opzioni:

    * Scegli **Edit** per richiedere modifiche o porre domande di chiarimento
    * Scegli **Start Building** per passare a Agent Mode e avviare l'esecuzione

    Puoi iterare sul piano tutte le volte necessarie prima di costruire.
  </Step>
</Steps>

<Tip>
  **Suggerimenti:**

  * Usa Plan Mode per funzionalità che coinvolgono più file
  * Esegui più cicli di revisione del piano per affinare l'approccio
  * Salva il piano in un file per discuterlo con il team prima dell'esecuzione
  * Plan Mode aiuta a garantire l'allineamento tra le tue aspettative e la soluzione proposta da Verdent
  * **Personalizza il formato del piano:** vai su **Settings → Rules → Plan Rules** per controllare la struttura del piano, il livello di dettaglio e le preferenze di formattazione
</Tip>

***

## Scomporre grandi richieste di funzionalità [#scomporre-grandi-richieste-di-funzionalità]

Supponiamo che tu stia costruendo un sistema complesso di checkout e-commerce con più componenti integrati.

<Steps>
  <Step title="Fornisci l'obiettivo di alto livello">
    ```
    Build a complete checkout system with cart management, payment processing, order confirmation, and inventory updates
    ```

    Verdent analizza ciò che deve essere fatto.
  </Step>

  <Step title="Verdent crea sottoattività logiche">
    Il sistema lo scompone autonomamente in:

    1. Creare il modello dati del carrello e API
    2. Costruire l'interfaccia del carrello con aggiunta/rimozione/aggiornamento degli articoli
    3. Implementare la pagina di checkout con il modulo per l'indirizzo di spedizione
    4. Integrare il gateway di pagamento (Stripe o il provider configurato)
    5. Creare la pagina di conferma dell'ordine
    6. Aggiungere la logica di aggiornamento dell'inventario
    7. Implementare il sistema di conferma via email
    8. Scrivere test di integrazione

    Ogni sottoattività viene mostrata nella lista delle cose da fare con descrizioni chiare.
  </Step>

  <Step title="Verdent gestisce automaticamente le dipendenze">
    Verdent esegue le sottoattività nell'ordine corretto:

    * Crea i modelli dati prima degli endpoint API che li usano
    * Costruisce gli endpoint backend prima dei componenti frontend che li richiamano
    * Implementa le funzionalità principali prima di aggiungere i test

    Le dipendenze vengono gestite automaticamente senza intervento manuale.
  </Step>

  <Step title="Monitora i progressi in tempo reale">
    Osserva la lista delle cose da fare aggiornarsi in tempo reale mentre Verdent lavora su ogni sottoattività. Gli elementi passano da in attesa → in corso → completato.
  </Step>
</Steps>

<Tip>
  **Suggerimenti:**

  * Per la maggior parte delle attività lascia che Verdent gestisca la scomposizione in autonomia
  * Usa Plan Mode se vuoi rivedere la scomposizione prima dell'esecuzione
  * Verdent adatta il proprio approccio quando incontra casi limite o nuovi requisiti
  * La lista delle cose da fare visibile offre trasparenza sull'esecuzione multi-step
</Tip>

***

## Progetti di refactoring multi-fase [#progetti-di-refactoring-multi-fase]

Supponiamo che tu stia effettuando il refactoring di un grande codebase e voglia affrontarlo in fasi gestibili.

<Steps>
  <Step title="Definisci l'approccio multi-fase">
    ```
    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 propone la suddivisione in fasi">
    Verdent suggerisce un piano multi-fase:

    * **Fase 1**: aggiungere la libreria OAuth e configurare gli endpoint
    * **Fase 2**: aggiornare il modello utente e lo schema del database
    * **Fase 3**: migrare la logica di autenticazione esistente
    * **Fase 4**: rimuovere il codice di autenticazione deprecato
    * **Fase 5**: aggiornare test e documentazione

    Ogni fase è testabile in modo indipendente.
  </Step>

  <Step title="Esegui fase per fase">
    Approva la Fase 1, lascia che Verdent la esegua, poi testa:

    ```
    npm test
    ```

    Una volta verificato che la Fase 1 funziona, passa alla Fase 2.
  </Step>

  <Step title="Adatta le fasi successive se necessario">
    In base a ciò che apprendi nella Fase 1, puoi adattare l'approccio per le fasi rimanenti:

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

  <Step title="Completa tutte le fasi in modo incrementale">
    Procedi attraverso tutte le fasi con test e verifica tra una e l'altra, garantendo sicurezza e permettendo correzioni di rotta.
  </Step>
</Steps>

<Tip>
  **Suggerimenti:**

  * Il refactoring multi-fase riduce il rischio consentendo test incrementali
  * Ogni fase dovrebbe lasciare il codebase in uno stato funzionante
  * Fai un commit dopo ogni fase per un rollback facile se necessario
  * Adatta le fasi successive in base a ciò che apprendi nelle precedenti
</Tip>

***

## Coordinare modifiche backend e frontend [#coordinare-modifiche-backend-e-frontend]

Supponiamo che tu stia aggiungendo una funzionalità che richiede aggiornamenti sincronizzati sia agli endpoint backend API sia ai componenti frontend.

<Steps>
  <Step title="Descrivi la funzionalità 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 coordina con un approccio backend-first">
    Verdent lavora tipicamente backend-first per le funzionalità full-stack:

    1. Creare la migrazione del database per la tabella dei commenti
    2. Aggiungere l'endpoint API per creare i commenti
    3. Aggiungere l'endpoint API per recuperare i commenti
    4. Definire le interfacce TypeScript per i dati dei commenti
    5. Costruire il componente frontend del modulo dei commenti
    6. Creare il componente di visualizzazione dei commenti
    7. Collegare il frontend agli endpoint API
  </Step>

  <Step title="Verdent garantisce la coerenza">
    Verdent garantisce che:

    * Le interfacce TypeScript del frontend corrispondano alle strutture dati del backend
    * Gli URL degli endpoint API siano referenziati correttamente nel codice frontend
    * I formati di richiesta/risposta siano allineati tra backend e frontend
    * La gestione degli errori sia coerente in tutto lo stack
  </Step>

  <Step title="Test di integrazione">
    ```
    Write integration tests for the commenting system covering the full stack
    ```

    Verdent crea test che verificano che backend e frontend funzionino correttamente insieme.
  </Step>
</Steps>

<Tip>
  **Suggerimenti:**

  * L'approccio backend-first garantisce che il frontend abbia API funzionanti con cui integrarsi
  * Verdent mantiene automaticamente la coerenza tra codice backend e frontend
  * Le interfacce TypeScript aiutano a individuare i problemi di integrazione in fase di compilazione
  * I test di integrazione verificano che la funzionalità completa funzioni end-to-end
</Tip>

***

## Usare i sottoagenti per l'esecuzione parallela [#usare-i-sottoagenti-per-lesecuzione-parallela]

Supponiamo che tu abbia più attività indipendenti che potrebbero essere svolte simultaneamente.

<Steps>
  <Step title="Individua le attività parallelizzabili">
    ```
    Generate unit tests for all service classes in the src/services directory
    ```

    Questi file di test sono indipendenti e possono essere creati in parallelo.
  </Step>

  <Step title="Verdent delega a più sottoagenti">
    Verdent usa automaticamente più sottoagenti per lavorare su attività indipendenti in modo concorrente:

    * Sottoagente 1: crea i test per UserService
    * Sottoagente 2: crea i test per PaymentService
    * Sottoagente 3: crea i test per NotificationService
    * Sottoagente 4: crea i test per AuthService

    Tutto il lavoro avviene in parallelo, risparmiando tempo.
  </Step>

  <Step title="I risultati vengono integrati">
    Ogni sottoagente restituisce i propri risultati. Verdent integra tutti i file di test nel progetto con nomi e struttura appropriati.
  </Step>

  <Step title="Verifica sequenziale">
    Dopo la creazione parallela, esegui i test in sequenza per verificare che funzionino tutti:

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

<Tip>
  **Suggerimenti:**

  * Verdent parallelizza automaticamente le attività indipendenti usando i sottoagenti
  * Il lavoro debolmente accoppiato (file di test separati, componenti indipendenti) trae vantaggio dalla parallelizzazione
  * Il lavoro strettamente accoppiato (file con dipendenze) viene svolto in sequenza per garantire la correttezza
  * L'esecuzione parallela accelera notevolmente le modifiche su larga scala
</Tip>

***

## Domande frequenti [#domande-frequenti]

<Accordion title="Posso fermare Verdent a metà di un'attività multi-step?">
  Sì. Puoi interrompere l'esecuzione in qualsiasi momento. Verdent completerà il passaggio corrente su cui sta lavorando, poi si fermerà. I progressi fino a quel punto vengono conservati. Puoi rivedere ciò che è stato fatto, apportare modifiche e decidere se continuare o adottare un approccio diverso.
</Accordion>

<Accordion title="Come faccio a sapere cosa sta facendo Verdent in questo momento durante un'attività lunga?">
  Osserva la lista delle cose da fare. Mostra lo stato in tempo reale con un elemento contrassegnato come "in corso" in ogni momento. L'elemento attivo mostra esattamente su cosa sta lavorando Verdent. Gli elementi completati sono contrassegnati come fatti e quelli in attesa mostrano cosa resta da fare.
</Accordion>

<Accordion title="Cosa succede se non sono d'accordo su come Verdent ha scomposto la mia attività?">
  Usa Plan Mode per rivedere e adattare la scomposizione prima dell'esecuzione. In Plan Mode puoi fornire feedback come "Suddividi il lavoro frontend in componenti separati" o "Unisci quei due passaggi". Verdent rivedrà il piano in base al tuo input prima che venga scritto qualsiasi codice.
</Accordion>

<Accordion title="Dovrei usare Plan Mode per ogni attività multi-step?">
  Non necessariamente. Usa Plan Mode per funzionalità complesse che coinvolgono molti file, per grandi refactoring o quando vuoi rivedere prima l'approccio. Per attività familiari e semplici, Verdent può eseguire direttamente con la visibilità della lista delle cose da fare in tempo reale. Plan Mode aggiunge un passaggio di revisione per le modifiche a rischio più elevato.
</Accordion>

<Accordion title="Posso modificare il piano di Verdent dopo l'avvio dell'esecuzione?">
  Puoi fornire indicazioni correttive mentre Verdent lavora. Di' "In realtà, usa un approccio diverso per l'integrazione con API" e Verdent adatterà i passaggi rimanenti. Per modifiche importanti al piano, è meglio fermarsi, fare il commit di ciò che è stato fatto e avviare una nuova sessione con l'approccio rivisto.
</Accordion>

***

## Vedi anche [#vedi-anche]

<CardGroup cols="2">
  <Card title="Scrivere nuovo codice" icon="code" href="/docs/verdent-for-vscode/task-based-guides/writing-code">
    Creare nuove funzionalità e componenti con Verdent
  </Card>

  <Card title="Best practice" icon="star" href="/docs/verdent-for-vscode/best-practices/prompts">
    Strategie efficaci di prompt e flusso di lavoro
  </Card>
</CardGroup>