Mapa de Habilidades de Engenharia de IA: Usando agentes de codificação

Uma habilidade fundamental em engenharia de IA é usar agentes de codificação. Sua capacidade de orientá-los tanto para escrever código quanto para realizar tarefas que não envolvem código, como analisar dados ou gerenciar operações de sistemas, permite que você seja muito mais produtivo.

O ritmo acelerado da evolução dos agentes de codificação significa que essa habilidade também está evoluindo rapidamente — mais rápido do que outras habilidades de ponta em engenharia de IA. Agentes proprietários (como Claude Code, Codex e Cursor) e agentes de código aberto (como OpenCode e Pi) avançam em saltos, tanto por melhorias na estrutura (harness) quanto nos modelos. Portanto, acompanhar como usar agentes de codificação exige um processo contínuo de experimentação, construção e aprendizado.

Ao entrevistar dezenas dos melhores engenheiros de IA e refletir sobre o uso de agentes de codificação em nossa própria equipe, encontramos um fluxo de trabalho consistente e de alto nível para construir software com eles. As etapas principais são:

• Planejamento. Isso inclui (i) brainstorming, que pode envolver pesquisa, experimentação e compreensão da base de código existente (se houver) e (ii) escrever uma especificação que capture requisitos, design técnico e arquitetura, seguido pela geração de um plano de execução. Você também pode revisar o plano para questionar premissas-chave e verificar segurança, excesso de engenharia e outras lacunas.
• Execução, onde você constrói, testa e verifica, com o equilíbrio certo entre autonomia do agente e supervisão humana. Isso envolve (i) fazer o agente construir o software, com um nível calibrado de autonomia do agente e (ii) verificar sua saída por meio de verificações automatizadas e/ou humanas.
• Implantação e monitoramento, no qual você (i) implanta, talvez com um pipeline de CI/CD ou portões humanos adicionais, e (ii) usa agentes para observar logs, identificar problemas e propor e executar melhorias.

Este fluxo de trabalho de alto nível é semelhante ao normalmente usado para construir software antes dos agentes de codificação. Agora, focamos muito menos no código e, em vez disso, nos concentramos em decidir o que construir, projetar a arquitetura, escrever a especificação e verificar os resultados.

A duração de cada etapa pode variar significativamente entre projetos, e algumas etapas podem ser omitidas. Por exemplo, a especificação para um protótipo greenfield (construído do zero) pode ser descrita de forma vaga em um prompt escrito rapidamente, enquanto a especificação para um projeto brownfield (pré-existente) com muitos usuários pode exigir muito mais esforço para escrever e verificar. Além disso, o fluxo de trabalho é altamente iterativo, e desenvolvedores habilidosos sabem quando o feedback de uma etapa posterior deve levá-los de volta a uma etapa anterior. Por exemplo, se a verificação falhar, eles sabem como orientar o agente a reconstruir e corrigir erros; ou, se o monitoramento identificar problemas, eles sabem como fazer com que os agentes atualizem o sistema e o reimplantem.

Para usar agentes de codificação de forma eficaz neste fluxo de trabalho, as habilidades-chave são:

• Direcionar o fluxo de trabalho
• Permitir a autonomia do agente
• Revisar o trabalho
• Personalizar o agente e seu ambiente
• Fundamentos de agentes de codificação

Direcionar o fluxo de trabalho. Você sabe como navegar em cada etapa do fluxo de trabalho acima. Isso envolve decidir quanto esforço humano e quanto esforço do agente gastar em cada uma e quando voltar a uma etapa anterior para iterar. Requer uma compreensão profunda das compensações de velocidade, custo, risco técnico e esforço humano, para que você possa decidir quanto pesquisar e planejar antecipadamente, quando manter a propriedade humana sobre o trabalho crítico, como escolher a arquitetura, quanto detalhe escrever em um conjunto de artefatos de planejamento (como uma especificação) e como decompor o trabalho em etapas verificáveis.

Permitir a autonomia do agente. Ao aplicar um agente de codificação às etapas do fluxo de trabalho, você escolhe o nível de autonomia: você o observa e interage de forma interativa ou delega uma parte maior do trabalho a ele? E quando você define um objetivo claro e o faz repetir até ter sucesso? Além disso, você precisa gerenciar o contexto com cuidado para o agente. À medida que a construção avança por diferentes fases, você calibrará quando garantir que os principais aprendizados, feedback do usuário e premissas — incluindo premissas que mudaram durante a construção — sejam capturados para o agente usar posteriormente. Além disso, você decidirá quando configurar vários agentes para serem executados em paralelo em uma decomposição da tarefa — seja por um humano ou um agente de nível superior orquestrando esses outros agentes — e como gerenciar a atenção humana em sessões de agentes concorrentes. Você também sabe como executar agentes com segurança, definindo permissões e bloqueando ações adequadamente para permitir que o desenvolvimento prossiga rapidamente, limitando o risco de vazamentos, perda de dados ou outros danos.

Revisar o trabalho. A saída de um agente de codificação é incerta. Não sabemos de antemão que boas ideias ele pode ter e quais bugs irá implementar. Revisar e verificar a saída é uma etapa fundamental para garantir que você está obtendo o resultado desejado e redirecionar o agente se não estiver. Você projetará testes e validações que sejam adequados à tarefa, aplicando verificação comportamental e funcional conforme necessário. Você também pode testar fluxos de usuário, talvez fazendo com que um agente forneça capturas de tela como evidência de sucesso ou falha. Para avaliação qualitativa/comportamental, conjuntos de avaliação, talvez com um LLM como juiz, podem ser usados.

Você também precisa decidir quanto desses testes devem ser automatizados. Alguns fluxos de trabalho terão todos os testes e validações totalmente automatizados para que o agente possa verificar seu trabalho e saber quando concluiu uma tarefa com sucesso. Você precisa avaliar os testes para garantir que eles correspondam aos seus objetivos e os evoluirá se não corresponderem. Além disso, você usa revisão de código agentiva e executa auditorias de segurança e arquitetura habilitadas por IA. Quando a revisão de IA não é suficiente, você insere criteriosamente revisões humanas do comportamento do código (e, raramente, do código em si) enquanto explora como automatizar ainda mais essa revisão. Finalmente, você verifica a implantação e pode operacionalizar o monitoramento e o gerenciamento de incidentes com agentes.

Personalizar o agente e seu ambiente. Sua capacidade de atualizar tanto o agente quanto o ambiente em que ele trabalha permite que seus agentes obtenham eficientemente o contexto de que precisam, acessem ferramentas e construam de forma correta e eficiente. Você sabe como integrar habilidades de agente, plugins e servidores MCP. Ocasionalmente, você os podará quando não forem mais necessários (como quando um novo modelo torna uma habilidade antiga obsoleta). Você pode usar hooks para automatizar partes repetíveis do processo de desenvolvimento, como acionar revisões de código automatizadas ou pipelines de CI/CD. Você também pode manter o ambiente em que o agente trabalha: atualizando o contexto permanente (como AGENTS.md ou CLAUDE.md) com informações sobre a base de código, premissas arquitetônicas principais, estilo de código e padrões de acesso a dados. Você sabe como preservar o estado em várias sessões e entre agentes paralelos, e acumular aprendizados do agente ao longo do tempo, talvez realizando retrospectivas pós-execução para capturar o que funcionou e o que não funcionou. Você também sabe como configurar convenções e estrutura consistentes para tornar sua base de código navegável para o agente e como limpar ocasionalmente a dívida gerada pelo agente. Quando você trabalha em equipe, considera como coordenar o contexto entre os agentes de diferentes desenvolvedores.

Fundamentos de agentes de codificação. Finalmente, para tomar boas decisões ao longo do processo, você tem uma boa compreensão de como os agentes de codificação funcionam: como eles realizam busca/recuperação na base de código, como gerenciam suas janelas de contexto, como diferentes operações (como adicionar chamadas de ferramentas, servidores MCP, etc.) afetam o contexto, como agentes e subagentes interagem e como o agente é construído envolvendo uma estrutura (harness) em torno de um LLM. Isso torna o agente menos uma caixa preta e ajuda você a reconhecer modos de falha, como excesso de engenharia em uma solução simples, perda de rigor porque o agente carece de um processo de verificação explícito, parar antes de atingir o objetivo ou ações do agente que arriscam a destruição de arquivos ou dados de produção. Também ajuda você a raciocinar sobre o estado do agente e orientá-lo, dando a ele a prescrição ou o contexto certo. E ao monitorar uma execução, esse entendimento permite que você identifique melhor quando o agente sai do caminho e requer sua intervenção.

Acho que as mídias sociais frequentemente fornecem descrições simplificadas demais de como usar agentes de codificação. Por exemplo, às vezes é útil fazer com que os agentes sejam executados de forma autônoma por horas e queimem milhões ou dezenas de milhões de tokens. Mas, atualmente, a utilidade prática de tarefas de horizonte muito longo — especialmente em relação ao seu custo — foi amplificada além da realidade. Em vez disso, o uso mais eficaz de agentes de codificação é um processo complexo e altamente iterativo, e ser capaz de intervir com julgamento de alto nível produz resultados muito melhores.

Sua habilidade em usar agentes de codificação fará de você um construtor eficaz. Isso o posiciona para também direcionar a construção como um todo. Direi mais sobre isso em um artigo futuro.