Módulo 6 da Jornada | MBA Engenharia de Software com IA

Desenvolvimento em Modo Agente: como trabalhar com IA de forma autônoma e controlada

O desenvolvimento em modo agente amplia o uso da inteligência artificial na programação: em vez de receber apenas uma sugestão por vez, o agente pode receber um objetivo, planejar etapas, executar tarefas, verificar resultados e ajustar sua execução com menor intervenção humana.

Resposta rápida: o que é desenvolvimento em modo agente?

Desenvolvimento em modo agente é uma abordagem na qual a IA recebe um objetivo de desenvolvimento e conduz uma sequência de ações para alcançá-lo, incluindo planejamento, execução, verificação e possíveis ajustes. A principal diferença para o modo assistido é o nível de autonomia concedido ao sistema.

Essa autonomia aumenta a produtividade potencial, mas também aumenta o risco de erros se a execução ocorrer sem plano, contexto, regras, checkpoints e testes.

TL;DR

O modo assistido trabalha com ações pontuais iniciadas pelo desenvolvedor.
O modo agente permite que a IA encadeie múltiplas ações para atingir um objetivo.
Quanto maior a autonomia, maior a necessidade de estrutura e supervisão.
Planos de ação transformam objetivos amplos em etapas verificáveis.
O gerenciamento de estado ajuda a preservar decisões e progresso em execuções longas.
Checkpoints e testes fornecem critérios objetivos para verificar o trabalho.
Exceções explícitas permitem autonomia sem transformar a execução em uma sequência sem controle.

Objetivos de Aprendizagem

Explicar a diferença entre desenvolvimento assistido e desenvolvimento em modo agente.
Compreender os riscos e limites do vibe coding.
Estruturar planos de ação antes de delegar tarefas a agentes.
Dividir objetivos grandes em tarefas pequenas e verificáveis.
Gerenciar estado e contexto durante execuções agênticas longas.
Definir regras e exceções para execução autônoma.
Utilizar testes como mecanismo de verificação e controle da autonomia.

Conceitos-Chave do Módulo

Modo agente: execução de múltiplas ações orientadas por um objetivo.
Autonomia: nível de liberdade concedido à IA para decidir a sequência de ações.
Vibe coding: desenvolvimento intuitivo baseado em pedir, aceitar e revisar pouco, sem estrutura sistemática.
Plano de ação: sequência ordenada de passos verificáveis antes da execução.
Task breakdown: divisão de uma tarefa ampla em unidades menores e verificáveis.
Checkpoint: ponto de controle usado para verificar o progresso.
Gerenciamento de estado: preservação do que foi feito, do que falta e das decisões tomadas.
Tool calling: capacidade necessária para que o agente execute ações por meio de ferramentas.
Verificação: comparação do resultado obtido com o objetivo e o plano original.
Testes automatizados: critérios objetivos que ajudam o agente a determinar se uma etapa foi concluída corretamente.

1. Fundamentos do desenvolvimento agêntico

No desenvolvimento assistido, a IA normalmente gera uma sugestão ou trecho de código a partir de uma solicitação pontual. O desenvolvedor avalia a resposta e decide o próximo passo. No modo agente, a unidade de trabalho muda: o sistema recebe um objetivo mais amplo e pode encadear várias ações sem devolver o controle ao usuário a cada etapa.

Aspecto	Modo assistido	Modo agente
Início da ação	O desenvolvedor inicia cada ação.	A IA pode decidir a sequência necessária.
Execução	Uma sugestão por vez.	Múltiplos passos encadeados.
Supervisão	Revisão frequente de cada trecho.	Revisão final ou em checkpoints definidos.
Propagação de erros	Normalmente limitada ao trecho atual.	Um erro pode afetar etapas posteriores.

O ganho de autonomia também cria um novo problema: uma decisão incorreta tomada no início pode influenciar várias etapas posteriores. Por isso, o desenvolvimento agêntico precisa substituir a supervisão linha a linha por mecanismos estruturados de controle.

Princípio central: autonomia sem estrutura aumenta o risco; autonomia acompanhada de planos, regras, checkpoints e testes pode ser utilizada de maneira muito mais controlada.

2. Vibe coding e desenvolvimento agêntico com método

O material diferencia o desenvolvimento agêntico estruturado do chamado vibe coding. Neste último, a pessoa utiliza a IA de maneira intuitiva, solicitando mudanças e aceitando resultados sem uma revisão ou planejamento sistemático.

Vibe coding	Desenvolvimento agêntico com método
Sem plano explícito.	Plano de ação definido antes da execução.
Aceitação da primeira saída.	Ciclo de verificação.
Contexto pode se perder.	Estado e contexto são gerenciados.
Mais adequado a protótipos descartáveis.	Pode ser estruturado para tarefas que chegam à produção.

O ponto não é eliminar o uso intuitivo da IA, mas reconhecer que projetos duradouros exigem método. Quanto maior o impacto das decisões automatizadas, mais importante se torna estabelecer limites antes da execução.

3. Ferramentas, IDEs e agentes de codificação

O módulo apresenta o Codex e o Claude Code como exemplos de ferramentas voltadas ao desenvolvimento agêntico. O foco deixa de ser apenas sugerir um trecho de código e passa a permitir a delegação de tarefas maiores sobre uma base de código.

O Claude Code é apresentado como uma ferramenta agêntica de linha de comando ou IDE, capaz de acessar arquivos, terminal e, por meio de MCP, outras ferramentas do ambiente de desenvolvimento. O Codex é apresentado como um agente de codificação capaz de trabalhar de maneira mais autônoma sobre uma base de código.

Nesse modelo, a ferramenta é apenas parte da solução. O método de execução, as regras, o contexto disponível e os mecanismos de verificação continuam sendo componentes fundamentais.

4. Modelos e casos de uso

A escolha de um modelo para desenvolvimento agêntico não deve considerar somente sua qualidade geral. O módulo destaca características especialmente relevantes para tarefas longas.

Seguimento de instruções: capacidade de manter coerência diante de instruções longas e complexas.
Tool calling ou function calling: suporte para executar ações por meio de ferramentas.
Janela de contexto: capacidade de manter informações relevantes durante a exploração de bases de código maiores.
Consistência: em tarefas longas, consistência de execução é especialmente importante.

A escolha do modelo, portanto, deve considerar a natureza da tarefa e o nível de autonomia necessário, e não apenas uma avaliação genérica de qualidade.

5. Workflow para aplicações novas e existentes

5.1 Novas aplicações

Em uma aplicação nova, o agente pode receber previamente um design doc ou plano estrutural. Isso reduz a possibilidade de decisões arquiteturais importantes serem tomadas implicitamente durante a geração.

5.2 Aplicações existentes

Em uma base já existente, a exploração do código relacionado deve preceder a implementação. O agente precisa entender a organização dos arquivos, padrões utilizados e testes existentes. Ignorar esse levantamento aumenta o risco de criar código que funciona isoladamente, mas viola convenções ou duplica lógica.

flowchart TD
A[Objetivo da tarefa] --> B[Explorar o projeto]
B --> C[Identificar arquivos e padrões]
C --> D[Definir plano]
D --> E[Dividir em tasks]
E --> F[Executar]
F --> G[Rodar testes]
G --> H{Resultado correto?}
H -->|Sim| I[Próximo checkpoint]
H -->|Não| J[Diagnosticar discrepância]
J --> D
I --> K[Conclusão]

6. Rules para desenvolvimento agêntico

As regras utilizadas no desenvolvimento assistido continuam importantes, mas o modo agente exige regras adicionais sobre o comportamento da IA durante execuções longas.

Antes de modificar um arquivo, leia-o integralmente e examine os arquivos que o utilizam.
Nunca delete testes existentes apenas para fazer uma suíte passar.
Estabeleça checkpoints durante execuções longas.
Se uma instrução do plano não fizer sentido diante do código real, interrompa e reporte.
Não improvise silenciosamente uma solução que altere o plano original.

Essas regras transformam preferências de desenvolvimento em restrições operacionais que ajudam a limitar decisões inesperadas.

7. Exploração e contextualização

Antes de modificar um projeto, o agente precisa investigar o terreno. Isso inclui descobrir quais arquivos são relevantes, como o código está organizado, quais padrões já existem e onde estão os testes relacionados.

Essa etapa é comparável ao início do ciclo ReAct estudado anteriormente, mas aplicada a uma tarefa de maior escala. O objetivo é evitar que o agente comece a implementar com contexto insuficiente.

Regra prática: antes de implementar, descubra quais arquivos são relevantes, qual padrão já é utilizado em funcionalidades semelhantes e onde estão os testes correspondentes.

8. Planos de ação

Um plano de ação transforma um objetivo amplo em uma sequência ordenada de passos verificáveis. Ele funciona como uma ponte entre a intenção humana e a execução autônoma.

O módulo apresenta como exemplo a implementação de autenticação por token JWT em uma API existente. O plano pode envolver adicionar a dependência, criar o middleware de validação, proteger rotas, criar testes para diferentes situações de token e atualizar a documentação da API.

A vantagem de registrar o plano antes da execução é permitir sua revisão antes que decisões equivocadas sejam transformadas em código.

9. Task breakdown

Cada item do plano deve ser pequeno o suficiente para ser verificado isoladamente. Uma tarefa genérica como "implementar autenticação" é ampla demais para servir como um bom checkpoint.

Ao dividir o trabalho em unidades menores, cada etapa pode possuir um critério objetivo de conclusão. O agente consegue então executar uma tarefa, verificar seu resultado e somente depois avançar.

Nível	Exemplo	Critério de verificação
Objetivo	Adicionar autenticação	Objetivo geral definido.
Task	Criar middleware de validação	Middleware implementado e executável.
Validação	Testar token válido e inválido	Testes relacionados passam.

10. Gerenciamento de estado

Uma execução agêntica longa precisa manter informações sobre o que já foi feito, o que ainda falta e quais decisões foram tomadas. Sem isso, a continuidade da execução pode perder contexto.

10.1 Arquivo de progresso

Uma estratégia apresentada no módulo é manter um arquivo temporário de progresso, como PROGRESS.md, atualizado pelo próprio agente a cada etapa concluída. Esse arquivo também pode funcionar como registro auditável da execução.

10.2 Resumo do histórico

Quando uma execução fica longa, o histórico pode ser resumido sem simplesmente descartar as decisões anteriores. Dessa maneira, informações relevantes permanecem disponíveis sem consumir desnecessariamente a janela de contexto.

11. Prompts para execução autônoma

Para delegar uma tarefa inteira sem exigir confirmação a cada passo, o prompt precisa antecipar situações que normalmente exigiriam intervenção humana.

Um padrão apresentado no módulo é permitir a execução do plano do início ao fim, exceto quando a tarefa exigir a exclusão de arquivos existentes, a alteração de uma migração de banco já aplicada ou quando surgir uma ambiguidade que o plano não cobre. Nessas situações, o agente deve parar e solicitar orientação.

Execute o plano de ação do início ao fim.

Não interrompa para confirmação a cada etapa, exceto se:
1. Precisar deletar arquivos existentes.
2. Precisar alterar uma migração de banco já aplicada.
3. Encontrar uma ambiguidade que o plano não cobre.

Nessas situações, pare e solicite orientação.

Fora dessas exceções, prossiga autonomamente e entregue um resumo final.

A ideia é combinar autonomia ampla com exceções explícitas. A autonomia não precisa significar ausência de limites.

12. Verificação e correção de discrepâncias

Terminar uma execução sem erro técnico não significa necessariamente que o objetivo foi alcançado. O resultado precisa ser comparado com o plano original.

O código compila ou executa sem erros?
Os testes antigos e novos passam?
O comportamento observado corresponde ao objetivo?
Foram introduzidas alterações fora do escopo?

Quando existe uma discrepância, o diagnóstico deve procurar a causa antes de simplesmente pedir uma correção. O problema pode estar relacionado a contexto insuficiente, plano ambíguo ou limitação do modelo.

13. Testes automatizados como mecanismo de autonomia

Em modo agente, os testes assumem uma função adicional: eles fornecem critérios objetivos para que o próprio agente saiba se determinada etapa foi bem-sucedida.

O fluxo recomendado começa pela definição dos testes que representam o comportamento esperado. Depois, o agente executa a suíte após cada etapa relevante. Um passo somente é considerado concluído quando os testes relacionados passam.

flowchart LR
A[Definir comportamento esperado] --> B[Criar ou identificar testes]
B --> C[Executar uma task]
C --> D[Rodar testes]
D --> E{Testes passam?}
E -->|Sim| F[Checkpoint concluído]
E -->|Não| G[Diagnosticar e corrigir]
G --> D
F --> H[Próxima task]

Isso aproxima o desenvolvimento agêntico de um espírito de TDD adaptado ao contexto: o teste deixa de ser apenas uma etapa posterior e passa a funcionar como mecanismo de controle da execução.

14. Comparação: autonomia e controle

Elemento	Baixa autonomia	Alta autonomia com método
Planejamento	Decisões a cada interação.	Plano estruturado antes da execução.
Contexto	Fornecido pontualmente.	Gerenciado durante a execução.
Controle	Revisão frequente.	Checkpoints e exceções.
Qualidade	Revisão manual contínua.	Testes e verificação sistemática.

15. Checklist de Domínio

Sei explicar a diferença entre modo assistido e modo agente.
Sei explicar os riscos do vibe coding.
Sei escrever um plano de ação antes de delegar uma tarefa.
Sei quebrar um plano em tasks pequenas e verificáveis.
Sei criar um prompt de execução autônoma com exceções explícitas.
Sei descrever estratégias de gerenciamento de estado.
Sei explicar por que testes são importantes para autonomia segura.

16. Exercícios Práticos

Exercício 1 — Plano de ação

Escolha uma funcionalidade real ou hipotética e escreva um plano completo antes de iniciar a implementação.

Exercício 2 — Task breakdown

Divida o plano em tarefas pequenas e defina para cada uma um critério objetivo de conclusão.

Exercício 3 — Execução autônoma

Escreva um prompt para executar a tarefa de forma autônoma e defina pelo menos três situações que devem interromper a execução.

Exercício 4 — Verificação

Depois da execução, compare o resultado final com o plano original e registre as discrepâncias encontradas.

17. Resumo para Revisão

Em 10 pontos

Modo agente significa maior autonomia na execução.
O agente pode planejar, executar, verificar e ajustar etapas.
Mais autonomia também significa maior superfície de risco.
Vibe coding não substitui método em projetos que exigem continuidade.
Planos escritos permitem revisar decisões antes da execução.
Tasks pequenas tornam a execução verificável.
Estado preserva progresso e decisões.
Exceções explícitas funcionam como guardrails de autonomia.
Verificação compara o resultado com o plano.
Testes fornecem critérios objetivos para checkpoints.

Em uma frase

Desenvolvimento agêntico seguro combina autonomia da IA com planejamento, contexto, regras, checkpoints, verificação e testes.

18. Glossário Técnico

Agente: sistema de IA capaz de conduzir uma sequência de ações orientadas por um objetivo.
Autonomia: liberdade concedida ao agente para decidir ações.
Checkpoint: ponto definido para verificar o progresso.
Contexto: informações necessárias para orientar a execução.
Function calling: mecanismo que permite ao modelo acionar funções ou ferramentas.
Tool calling: uso de ferramentas externas pelo modelo durante a execução.
Task: unidade de trabalho que pode ser executada e verificada.
Task breakdown: decomposição de um objetivo em tarefas menores.
Vibe coding: abordagem intuitiva de programação assistida por IA sem estrutura sistemática.
Estado: registro do progresso, decisões e informações necessárias para continuar uma execução.

19. Mapa Mental do Desenvolvimento em Modo Agente

mindmap
root((Desenvolvimento em Modo Agente))
  Autonomia
    Objetivo
    Planejamento
    Execução
    Verificação
  Método
    Plano de ação
    Task breakdown
    Rules
    Checkpoints
  Contexto
    Exploração
    Estado
    Progresso
    Histórico resumido
  Qualidade
    Testes
    Verificação
    Discrepâncias
  Segurança
    Exceções
    Supervisão
    Limites
  Ferramentas
    Codex
    Claude Code
    Tool calling
  Prática
    Aplicações novas
    Aplicações existentes
    Vibe coding

20. Sugestão de Imagem

Título: Desenvolvimento de software em modo agente

Objetivo: Representar visualmente o ciclo de planejamento, execução, verificação e correção realizado por um agente de IA.

Prompt: Ilustração editorial técnica mostrando um agente de IA trabalhando sobre uma base de código, conectado a planejamento, tarefas, ferramentas, testes, checkpoints e verificação humana. Interface de desenvolvimento moderna, arquitetura de software, terminal, arquivos de código e fluxo visual organizado, estética profissional, composição limpa e sem textos ilegíveis.

ALT: Agente de IA planejando, executando e verificando tarefas de desenvolvimento de software.

Legenda: O desenvolvimento agêntico combina execução autônoma com planejamento, checkpoints, testes e verificação.

21. Continue Aprendendo

O próximo documento da série é o Módulo 7 — Desenvolvimento de aplicações com IA, conforme indicado no material-base.

O conteúdo deste módulo também se conecta ao desenvolvimento assistido estudado anteriormente, especialmente pela evolução de uma interação pontual para uma execução com maior autonomia.

Revisar os fundamentos do modo agente
Voltar aos planos de ação
Revisar testes automatizados

22. Perguntas Frequentes

O que diferencia o modo agente do modo assistido?

No modo assistido, o desenvolvedor inicia cada ação e avalia as sugestões individualmente. No modo agente, a IA pode encadear múltiplas ações para alcançar um objetivo.

O desenvolvimento agêntico elimina a supervisão humana?

Não. O módulo apresenta autonomia acompanhada de checkpoints e exceções explícitas. A verificação do resultado continua sendo necessária.

O que é vibe coding?

É uma forma intuitiva de utilizar IA para programação, geralmente sem plano explícito ou revisão estruturada. O módulo destaca seus limites em projetos que precisam durar.

Por que criar um plano antes de usar um agente?

Porque o plano permite revisar a sequência de decisões antes que a execução transforme uma estratégia inadequada em várias alterações no código.

Por que dividir uma tarefa em pequenas tasks?

Porque tarefas menores podem ser verificadas isoladamente, reduzindo o impacto de um eventual erro e criando checkpoints objetivos.

Como o agente mantém o estado durante uma execução longa?

Entre as estratégias apresentadas estão um arquivo de progresso, como PROGRESS.md, e o resumo do histórico sem descartar decisões importantes.

Por que testes são importantes no modo agente?

Porque fornecem critérios objetivos para determinar se uma etapa foi concluída corretamente, reduzindo a dependência de revisão manual a cada trecho.

Quando o agente deve interromper a execução?

O exemplo apresentado define interrupção para situações como exclusão de arquivos existentes, alteração de migrações já aplicadas ou ambiguidades não previstas pelo plano.

23. Referências para Aprofundar

Documentação do Claude Code sobre fluxos agênticos e uso de ferramentas.
Documentação do Codex/OpenAI sobre agentes de codificação.
Materiais e discussões sobre vibe coding e seus limites em produção.
Revisão do padrão ReAct como base conceitual para ciclos de ação e observação.

Seriado Engenharia de Software com IA

Engenharia de Software com IA - Parte 6/10 - Desenvolvimento em Modo Agente: como trabalhar com IA de forma autônoma e controlada