Examinar o código gerado por IA

Aprenda técnicas para verificar e validar o código gerado por IA e como Bate-papo do Copiloto pode ajudar.

Neste artigo

A revisão do código gerado por ferramentas de IA como GitHub Copilot, ChatGPT ou outros agentes de codificação está se tornando uma parte essencial do fluxo de trabalho do desenvolvedor moderno. Este guia fornece técnicas práticas, enfatiza a importância da supervisão e do teste humano e inclui prompts de exemplo para mostrar como a IA pode ajudar no processo de revisão.

Para as bases de código herdadas e as solicitações de pull maiores, em particular, um processo de revisão completa é fundamental. Combinar a experiência humana com ferramentas automatizadas pode garantir que o código gerado por IA atenda aos padrões de qualidade, se alinhe às metas do projeto e adere às práticas recomendadas.

Com Copilot, você pode simplificar seu processo de revisão e aprimorar sua capacidade de identificar possíveis problemas no código gerado por IA.

1. Comece com verificações funcionais

Sempre execute testes automatizados e ferramentas de análise estática primeiro.

Prompts de exemplo

  • What functional tests to validate this code change do not exist or are missing?
  • What possible vulnerabilities or security issues could this code introduce?

2. Verificar o contexto e a intenção

Verifique se o código gerado por IA se encaixa na finalidade e na arquitetura do seu projeto.

  • Examine a saída de IA para alinhamento com seus requisitos e padrões de design.
  • Pergunte a si mesmo: "Esse código resolve o problema certo? Ele segue nossas convenções?
  • Use o README, os documentos e as solicitações de pull recentes como ponto de partida para o contexto para IA. Informe à IA quais fontes confiar, o que não usar e dê a ela bons exemplos para trabalhar.
  • Experimente Como sintetizar pesquisa para ver como Copilot usa documentação e pesquisa para auxiliar na geração de código.
  • Ao solicitar que a IA execute tarefas de pesquisa e planejamento, considere a destilação da saída de IA em artefatos estruturados para, em seguida, tornar-se contexto para tarefas futuras de IA, como a geração de código.

Prompts de exemplo

  • How does this refactored code section align with our project architecture?
  • What similar features or established design patterns did you identify and model your code after?
  • When examining this code, what assumptions about business logic, design preferences, or user behaviors have been made?
  • What are the potential issues or limitations with this approach?

3. Avaliar a qualidade do código

Os padrões humanos ainda importam.

  • Procure legibilidade, manutenção e nomenclatura clara.
  • Evite aceitar código difícil de seguir ou levaria mais tempo para refatorar do que reescrever.
  • Prefira o código bem documentado e inclua comentários claros.
  • Verifique Melhorar a legibilidade e a facilidade de manutenção para obter prompts e dicas sobre revisão e refatoração do código gerado.

Prompts de exemplo

  • What are some readability and maintainability issues in this code?
  • How can this code be improved for clarity and simplicity? Suggest an alternative structure or variable names to enhance clarity.
  • How could this code be broken down into smaller, testable units?

4. Examinar dependências

Fique atento com novos pacotes e bibliotecas.

  • Verifique se as dependências sugeridas existem e são mantidas ativamente. Considere as origens e os colaboradores de novas dependências para garantir que elas venham de fontes respeitáveis e não concorrentes.
  • Revise o licenciamento. Evite introduzir código ou dependências incompatíveis com a licença do projeto (por exemplo, AGPL-3.0 em um projeto licenciado do MIT ou dependências sem licença declarada).
  • Cuidado com pacotes alucinados ou suspeitos (como pacotes que na verdade não existem) ou a ataques de slopsquatting (um ataque teórico a LLMs usando pacotes falsos ou mal-intencionados).
  •           [AUTOTITLE](/copilot/tutorials/copilot-chat-cookbook/communicate-effectively/creating-templates) demonstra como Copilot pode auxiliar na configuração das dependências, porém é uma boa prática sempre verificar os pacotes sugeridos por conta própria.
  • Use Referência a código do GitHub Copilot para examinar correspondências com código disponível publicamente.

Prompts de exemplo

  • Analyze the attached package.json file and list all dependencies with their respective licenses.
  • Are each of the dependencies listed in this package.json file actively maintained (that is, not archived and have recent maintainer activity)?

5. Detectar armadilhas específicas de IA

As ferramentas de IA podem cometer erros exclusivos.

  • Procure por APIs alucinadas, restrições ignoradas ou lógica incorreta.
  • Fique atento a testes que são excluídos ou ignorados, em vez de corrigidos.
  • Seja cético quanto ao código que "parece certo", mas não corresponde à sua intenção.
  • Veja Depurando JSON inválido como exemplo de detecção de erros sutis e depuração com Copilot.

Prompts de exemplo

  • What was the reasoning behind the code change to delete the failing test? Suggest some alternatives that would fix the test instead of deleting it.
  • What potential complexities, edge cases, or scenarios are there that this code might not handle correctly?
  • What specific technical questions does this code raise that require human judgment or domain expertise to evaluate properly?

6. Usar revisões colaborativas

O emparelhamento e a colaboração da equipe ajudam a capturar problemas sutis.

  • Peça aos colegas de equipe que revisem alterações complexas ou confidenciais.
  • Use listas de verificação para garantir que todos os principais pontos de revisão (funcionalidade, segurança, manutenção) sejam cobertos.
  • Compartilhe prompts e padrões bem-sucedidos para uso de IA em sua equipe.
  • Consulte Comunicar-se com eficiência para obter exemplos de como trabalhar com Copilot de forma colaborativa e documentar os resultados.

Automatize o que você puder

Permitir que as ferramentas lidem com o trabalho repetitivo.

  • Configure verificações de CI para estilo, linting e segurança.
  • Utilize Dependabot para atualização e alertas de dependências.
  • Aplique CodeQL ou ferramentas semelhantes para análise estática.
  •         [AUTOTITLE](/copilot/how-tos/get-code-suggestions/find-matching-code) mostra como Copilot pode ajudar a identificar padrões de código e automatizar tarefas de pesquisa.
  • Considere se agentes de IA com recursos de raciocínio podem ajudar na automatização de partes do processo de revisão. Por exemplo, crie um agente de autoavaliação que avalie rascunhos de solicitações pull de acordo com seus padrões, verificando precisão, tom apropriado e lógica de negócios antes de solicitar a revisão humana.

8. Continue melhorando seu fluxo de trabalho

Adotar novas ferramentas e técnicas de IA pode tornar seu fluxo de trabalho ainda mais eficaz.

  • Documente suas práticas recomendadas para revisar o código gerado por IA.
  • Incentive os "campeões de IA" em sua equipe a compartilhar dicas e fluxos de trabalho.
  • Atualize seus guias de integração e contribuição para incluir suas técnicas e recursos de revisão de IA. Use um CONTRIBUTING.md arquivo em seu repositório para documentar suas expectativas de código-fonte e conteúdo gerados por IA, consulte Configurar diretrizes para os contribuidores do repositório.
  •         [Referencie AUTOTITLE](/copilot/tutorials/copilot-chat-cookbook) para obter inspiração e compartilhar receitas úteis em seus documentos de equipe.

Leitura adicional

  •           [Supervisão humana na revisão de código moderno](https://resources.github.com/enterprise/human-oversight-modern-code-review/) em recursos GitHub