Desenvolvendo funcionalidades

Agora que você entende a base de código, é hora de criar algo novo.

A chave para lançar funcionalidades com agentes é dividir o trabalho em etapas que o agente possa verificar por conta própria. Comece cada funcionalidade importante com um plano e estabeleça as proteções necessárias para que o agente possa detectar e corrigir os próprios erros.

Comece com um plano

Os agentes podem ajudar você a pensar no que criar antes de começar a escrever código.

Há muitas decisões a tomar antes de escrever código. Se você tem uma ideia para uma funcionalidade, talvez queira criar primeiro uma versão simples e iterar nela depois. Ou talvez haja decisões específicas de design a considerar.

Você pode usar agentes de programação para ajudar a pensar nessas decisões antes de escrever código. Com o modo Plan do Cursor, o agente pesquisará sua base de código, fará perguntas para esclarecer dúvidas e produzirá um plano passo a passo que você poderá editar e ajustar.

Ao enviar um prompt ao modo Plan, o agente faz perguntas para primeiro ajudar a definir os requisitos:

Depois que você responde, o agente gera um plano estruturado com marcos que pode revisar e verificar enquanto desenvolve a funcionalidade. Esse plano é editável, então você pode fazer alterações se algo não parecer certo:

O Cursor torna os planos úteis ao dividir solicitações maiores em etapas menores que podem ser verificadas de forma independente. Em cada etapa, o agente pode medir seu progresso, confirmar que ela foi concluída com sucesso e seguir adiante.

Quando recomeçar

Às vezes, o agente cria algo que não atende ao objetivo. Em vez de tentar corrigir isso com mensagens de acompanhamento, volte ao plano. Reverta as alterações e refine o plano, tornando-o mais específico antes de executá-lo novamente.

Por exemplo, se você deixou passar um ponto importante sobre a arquitetura ou o design do sistema, o plano pode levar à implementação errada. Recomeçar a partir do plano parece contraintuitivo, mas muitas vezes é mais rápido do que remendar uma abordagem que começou na direção errada.

Desenvolvimento orientado por testes com agentes

Os agentes trabalham melhor quando conseguem saber se o código está correto. Quando um teste falha, o agente consegue identificar o que deu errado e tentar novamente.

Engenheiros usam desenvolvimento orientado por testes há muito tempo, mas essa nem sempre foi a forma mais popular de escrever código. Com agentes, é muito mais fácil escrever os testes primeiro, e eles compensam à medida que sua base de código cresce.

1. Escreva os testes primeiro. Peça ao agente para escrever testes com base nas entradas e saídas esperadas. Deixe claro que você está fazendo TDD, para que ele não crie funções mock para código que ainda não existe.
2. Confirme que os testes falham. Diga ao agente para executar os testes e verificar se eles falham. Neste ponto, você não está tentando escrever o código da funcionalidade.
3. Faça commit dos testes. Quando estiver satisfeito com a cobertura e a qualidade dos testes, faça commit deles. Isso fixa os requisitos que o agente deverá implementar.
4. Peça ao agente para escrever o código. Diga a ele para fazer todos os testes passarem sem modificá-los. Continue iterando até que tudo passe.
5. Faça commit do código. Revise a saída, confirme que ela se comporta como esperado e faça commit.

Depois que os testes forem commitados, diga ao agente para escrever o código. Deixe claro que ele deve fazer todos os testes passarem sem modificá-los.

Por que isso funciona tão bem? Porque o agente pode executar testes, ver falhas, ajustar o código e tentar novamente. Cada execução de teste fornece feedback concreto ao agente. Sem testes, ele não tem como saber se as alterações de código que fez funcionam.

Essa abordagem é especialmente valiosa para código de backend, em que não é possível verificar se está correto olhando para uma tela. Você descreve o comportamento esperado nos testes, e o agente escreve o código para corresponder a ele.

Do design ao código

Os agentes podem processar e entender imagens. Você pode colar uma captura de tela ou mockup diretamente no campo de prompt, e o agente pode reproduzir o design com base na imagem.

Isso funciona para:

• Mockups: Cole um wireframe ou uma exportação do Figma e peça ao agente para criar o componente
• Depuração visual: Faça uma captura de tela de um estado inesperado da UI e peça ao agente para investigar
• Iteração: Faça uma captura de tela do resultado atual e descreva o que precisa mudar

Você também pode conectar o servidor MCP do Figma para que o agente extraia tokens de design, variáveis e especificações de componentes diretamente dos seus arquivos do Figma.

O navegador integrado permite visualizar as alterações conforme o agente as realiza. Com esse navegador, o agente pode navegar por páginas, fazer capturas de tela e verificar sua própria saída visual. Assim, você não precisa enviar manualmente capturas de tela de volta ao agente.

Padrão comum de falha: desenvolver sem verificar

O maior risco de desenvolver funcionalidades rapidamente é deixar de verificar se tudo está correto. Os agentes podem gerar muito código rapidamente, mas velocidade sem correção pode gerar mais trabalho no futuro.

Veja formas concretas de ajudar o agente a verificar o próprio trabalho:

• Testes de lógica e comportamento
• Verificação de tipos para garantir a correção estrutural
• Linters para impor padrões e estilo de código
• Ferramentas de navegador ou servidores MCP para obter feedback sobre alterações na UI

Se o agente não puder verificar sua saída, você acabará gastando mais tempo fazendo correções.

O que vem a seguir

Você lançou uma funcionalidade. Mas todo software tem bugs, e alguns são difíceis de encontrar e corrigir. No próximo capítulo, você aprenderá abordagens sistemáticas para encontrar e corrigir bugs com agentes.