# Exemplos de tarefas em várias etapas (/pt/docs/verdent-for-vscode/common-workflows/multi-step-tasks)

> Lidando com tarefas complexas em várias etapas usando Verdent



Verdent for VS Code se destaca em decompor tarefas complexas em várias etapas de forma autônoma. Este guia oferece fluxos de trabalho passo a passo para cenários comuns de várias etapas, mostrando exatamente como Verdent lida com a decomposição de tarefas, o gerenciamento de dependências e a execução progressiva.

***

## Usando Plan Mode para implementações complexas [#usando-plan-mode-para-implementações-complexas]

Suponha que você queira revisar um plano detalhado antes que Verdent faça qualquer alteração na sua base de código.

<Steps>
  <Step title="Mude para Plan Mode">
    Clique no botão "Switch Mode" na interface e selecione "Plan Mode".

    Plan Mode é somente leitura: Verdent pode analisar código, conduzir pesquisas e criar planos sem modificar arquivos ou executar comandos.
  </Step>

  <Step title="Envie sua solicitação complexa">
    ```
    Refactor this codebase to replace our custom authentication with OAuth 2.0
    ```

    Verdent analisa minuciosamente sua implementação atual.
  </Step>

  <Step title="Responda às perguntas esclarecedoras">
    Verdent pode fazer perguntas para eliminar incertezas:

    * Qual provedor OAuth devemos usar?
    * Os tokens devem ser armazenados em localStorage ou cookies?
    * Precisamos oferecer suporte a vários provedores OAuth?

    Responda a essas perguntas para refinar o plano.
  </Step>

  <Step title="Revise o plano detalhado">
    Verdent apresenta um plano abrangente mostrando:

    * Arquivos a serem criados
    * Arquivos existentes a modificar
    * Etapas de implementação em ordem lógica
    * Dependências entre as etapas

    Revise esse plano com atenção antes de prosseguir.
  </Step>

  <Step title="Escolha sua próxima ação">
    Após revisar o plano, Verdent apresenta duas opções:

    * Escolha **Edit** para solicitar modificações ou fazer perguntas esclarecedoras
    * Escolha **Start Building** para mudar para Agent Mode e iniciar a execução

    Você pode iterar sobre o plano quantas vezes precisar antes de construir.
  </Step>
</Steps>

<Tip>
  **Dicas:**

  * Use Plan Mode para recursos que afetam vários arquivos
  * Faça várias rodadas de revisão do plano para refinar a abordagem
  * Salve o plano em um arquivo para discussão em equipe antes da execução
  * Plan Mode ajuda a garantir o alinhamento entre suas expectativas e a solução proposta por Verdent
  * **Personalize o formato do plano:** Acesse **Settings → Rules → Plan Rules** para controlar a estrutura do plano, o nível de detalhe e as preferências de formatação
</Tip>

***

## Decompondo grandes solicitações de recursos [#decompondo-grandes-solicitações-de-recursos]

Suponha que você esteja construindo um sistema complexo de checkout de e-commerce com vários componentes integrados.

<Steps>
  <Step title="Forneça o objetivo de alto nível">
    ```
    Build a complete checkout system with cart management, payment processing, order confirmation, and inventory updates
    ```

    Verdent analisa o que precisa ser feito.
  </Step>

  <Step title="Verdent cria subtarefas lógicas">
    O sistema decompõe isso de forma autônoma em:

    1. Criar o modelo de dados do carrinho de compras e API
    2. Construir a UI do carrinho com adicionar/remover/atualizar itens
    3. Implementar a página de checkout com formulário de endereço de entrega
    4. Integrar o gateway de pagamento (Stripe ou provedor configurado)
    5. Criar a página de confirmação do pedido
    6. Adicionar a lógica de atualização de estoque
    7. Implementar o sistema de confirmação por e-mail
    8. Escrever testes de integração

    Cada subtarefa é exibida na lista de tarefas com descrições claras.
  </Step>

  <Step title="Verdent lida com as dependências automaticamente">
    Verdent executa as subtarefas na ordem correta:

    * Cria os modelos de dados antes dos endpoints API que os utilizam
    * Constrói os endpoints de backend antes dos componentes de frontend que os chamam
    * Implementa os recursos principais antes de adicionar testes

    As dependências são gerenciadas automaticamente, sem intervenção manual.
  </Step>

  <Step title="Acompanhe o progresso em tempo real">
    Observe a lista de tarefas se atualizar em tempo real enquanto Verdent trabalha em cada subtarefa. Os itens passam de pendente → em andamento → concluído.
  </Step>
</Steps>

<Tip>
  **Dicas:**

  * Deixe Verdent lidar com a decomposição de forma autônoma na maioria das tarefas
  * Use Plan Mode se você quiser revisar a decomposição antes da execução
  * Verdent ajusta sua abordagem quando encontra casos extremos ou novos requisitos
  * A lista de tarefas visível oferece transparência sobre a execução em várias etapas
</Tip>

***

## Projetos de refatoração em várias fases [#projetos-de-refatoração-em-várias-fases]

Suponha que você esteja refatorando uma grande base de código e queira abordá-la em fases gerenciáveis.

<Steps>
  <Step title="Defina a abordagem em várias fases">
    ```
    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 propõe a divisão em fases">
    Verdent sugere um plano em várias fases:

    * **Fase 1**: Adicionar a biblioteca OAuth e configurar os endpoints
    * **Fase 2**: Atualizar o modelo de usuário e o esquema do banco de dados
    * **Fase 3**: Migrar a lógica de autenticação existente
    * **Fase 4**: Remover o código de autenticação obsoleto
    * **Fase 5**: Atualizar os testes e a documentação

    Cada fase é testável de forma independente.
  </Step>

  <Step title="Execute fase por fase">
    Aprove a Fase 1, permita que Verdent a execute e, em seguida, teste:

    ```
    npm test
    ```

    Assim que a Fase 1 for verificada como funcional, avance para a Fase 2.
  </Step>

  <Step title="Ajuste as fases seguintes se necessário">
    Com base no que você aprende na Fase 1, é possível ajustar a abordagem das fases restantes:

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

  <Step title="Conclua todas as fases de forma incremental">
    Trabalhe em todas as fases com testes e verificação entre cada uma, garantindo segurança e permitindo correções de rumo.
  </Step>
</Steps>

<Tip>
  **Dicas:**

  * A refatoração em várias fases reduz o risco ao permitir testes incrementais
  * Cada fase deve deixar a base de código em estado funcional
  * Faça commit após cada fase para facilitar o rollback se necessário
  * Ajuste as fases posteriores com base nos aprendizados das fases anteriores
</Tip>

***

## Coordenando alterações de backend e frontend [#coordenando-alterações-de-backend-e-frontend]

Suponha que você esteja adicionando um recurso que exige atualizações sincronizadas tanto nos APIs do backend quanto nos componentes do frontend.

<Steps>
  <Step title="Descreva o recurso 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 coordena a abordagem backend-first">
    Verdent normalmente trabalha backend-first para recursos full-stack:

    1. Criar a migração de banco de dados para a tabela de comentários
    2. Adicionar o endpoint API para criar comentários
    3. Adicionar o endpoint API para recuperar comentários
    4. Definir as interfaces TypeScript para os dados de comentários
    5. Construir o componente de formulário de comentários do frontend
    6. Criar o componente de exibição de comentários
    7. Conectar o frontend aos endpoints API
  </Step>

  <Step title="Verdent garante a consistência">
    Verdent garante que:

    * As interfaces TypeScript do frontend correspondam às estruturas de dados do backend
    * As URLs dos endpoints API sejam referenciadas corretamente no código do frontend
    * Os formatos de requisição/resposta estejam alinhados entre backend e frontend
    * O tratamento de erros seja consistente em toda a stack
  </Step>

  <Step title="Teste de integração">
    ```
    Write integration tests for the commenting system covering the full stack
    ```

    Verdent cria testes que verificam se o backend e o frontend funcionam corretamente em conjunto.
  </Step>
</Steps>

<Tip>
  **Dicas:**

  * A abordagem backend-first garante que o frontend tenha APIs funcionais para integração
  * Verdent mantém a consistência entre o código de backend e frontend automaticamente
  * As interfaces TypeScript ajudam a detectar problemas de integração em tempo de compilação
  * Os testes de integração verificam se o recurso completo funciona de ponta a ponta
</Tip>

***

## Usando subagentes para execução paralela [#usando-subagentes-para-execução-paralela]

Suponha que você tenha várias tarefas independentes que poderiam ser feitas simultaneamente.

<Steps>
  <Step title="Identifique tarefas paralelizáveis">
    ```
    Generate unit tests for all service classes in the src/services directory
    ```

    Esses arquivos de teste são independentes e podem ser criados em paralelo.
  </Step>

  <Step title="Verdent delega para vários subagentes">
    Verdent usa automaticamente vários subagentes para trabalhar em tarefas independentes de forma concorrente:

    * Subagente 1: Cria testes para UserService
    * Subagente 2: Cria testes para PaymentService
    * Subagente 3: Cria testes para NotificationService
    * Subagente 4: Cria testes para AuthService

    Todo o trabalho acontece em paralelo, economizando tempo.
  </Step>

  <Step title="Os resultados são integrados">
    Cada subagente retorna seus resultados. Verdent integra todos os arquivos de teste ao projeto com a nomenclatura e a estrutura adequadas.
  </Step>

  <Step title="Verificação sequencial">
    Após a criação paralela, execute os testes sequencialmente para verificar se todos funcionam:

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

<Tip>
  **Dicas:**

  * Verdent paraleliza automaticamente tarefas independentes usando subagentes
  * Trabalhos fracamente acoplados (arquivos de teste separados, componentes independentes) se beneficiam da paralelização
  * Trabalhos fortemente acoplados (arquivos com dependências) são feitos sequencialmente para garantir a correção
  * A execução paralela acelera significativamente alterações em larga escala
</Tip>

***

## Perguntas frequentes [#perguntas-frequentes]

<Accordion title="Posso interromper Verdent no meio de uma tarefa em várias etapas?">
  Sim. Você pode interromper a execução a qualquer momento. Verdent concluirá a etapa atual em que está trabalhando e então parará. O progresso até esse ponto é preservado. Você pode revisar o que foi feito, fazer ajustes e continuar ou adotar uma abordagem diferente.
</Accordion>

<Accordion title="Como sei o que Verdent está fazendo agora em uma tarefa longa?">
  Observe a lista de tarefas. Ela mostra o status em tempo real, com um item marcado como "em andamento" a cada momento. O item ativo mostra exatamente em que Verdent está trabalhando no momento. Os itens concluídos são marcados como feitos, e os pendentes mostram o que falta.
</Accordion>

<Accordion title="E se eu discordar de como Verdent decompôs minha tarefa?">
  Use Plan Mode para revisar e ajustar a decomposição antes da execução. No Plan Mode, você pode dar feedback como "Divida o trabalho de frontend em componentes separados" ou "Combine essas duas etapas". Verdent revisará o plano com base na sua entrada antes que qualquer código seja escrito.
</Accordion>

<Accordion title="Devo usar Plan Mode para toda tarefa em várias etapas?">
  Não necessariamente. Use Plan Mode para recursos complexos que afetam muitos arquivos, grandes refatorações ou quando quiser revisar a abordagem primeiro. Para tarefas familiares e diretas, Verdent pode executar diretamente com a visibilidade da lista de tarefas em tempo real. Plan Mode adiciona uma etapa de revisão para alterações de maior risco.
</Accordion>

<Accordion title="Posso modificar o plano de Verdent depois que a execução começou?">
  Você pode fornecer orientações corretivas enquanto Verdent trabalha. Diga "Na verdade, use uma abordagem diferente para a integração API" e Verdent ajustará as etapas restantes. Para grandes mudanças de plano, é melhor parar, fazer commit do que foi feito e iniciar uma nova sessão com a abordagem revisada.
</Accordion>

***

## Veja também [#veja-também]

<CardGroup cols="2">
  <Card title="Escrevendo código novo" icon="code" href="/docs/verdent-for-vscode/task-based-guides/writing-code">
    Criando novos recursos e componentes com Verdent
  </Card>

  <Card title="Boas práticas" icon="star" href="/docs/verdent-for-vscode/best-practices/prompts">
    Estratégias eficazes de prompts e fluxo de trabalho
  </Card>
</CardGroup>