Por que é difícil atribuir a origem dos bugs em código gerado pelo GitHub Copilot
O autocompletar inline tem um perfil de risco diferente do de um agente que reescreve arquivos. Cada sugestão é pequena o bastante para parecer revisável, então você revisa em um segundo e segue em frente. Esse segundo de atenção é honesto com a linha à sua frente e cego para o sistema ao redor dela.
A consequência é que, quando algo quebra, fazer bisect vira um sofrimento. Não existe um único commit suspeito, apenas uma longa cauda de sugestões aceitas que pareciam corretas na hora.
Os três desvios que merecem atenção
Desvio de convenção
As sugestões seguem padrões vindos do treinamento e do código ao redor, que nem sempre são a convenção real da sua base de código.
Tratamento de erros, verificações de nulo e logs vão divergindo aos poucos entre os módulos.
Lógica duplicada
É mais rápido aceitar um helper gerado do que encontrar o que já existe, então a mesma regra acaba implementada em três lugares.
Mais tarde, um deles é corrigido e os outros dois não.
Valores padrão plausíveis
Um valor padrão, timeout ou ordenação sugerido parece razoável e não corresponde à regra do seu produto.
Nada falha. O comportamento simplesmente não é o que alguém pretendia.
Os três são invisíveis na revisão e visíveis quando o produto roda, e é isso que define onde a verificação precisa acontecer.
Verifique o comportamento em uma cadência, não a cada sugestão
Verificar cada sugestão aceita não é possível nem útil. A unidade certa é o pull request: nesse ponto já existe um volume coerente de mudança, e ele ainda é pequeno o bastante para você raciocinar sobre ele se algo estiver errado.
O que você quer verificar não é o código novo, é o comportamento em que esse código está inserido. Um pull request que mexeu no módulo de faturamento deve exercitar o faturamento de ponta a ponta, incluindo os caminhos em que o autor não pensou, porque é exatamente ali que um valor padrão plausível se esconde.
Instalar a skill de verificação deixa o agente fazer isso sozinho, em vez de esperar que alguém se lembre.
Terminal
npm install -g @testsprite/testsprite-cli
testsprite setup
O dashboard cobre o mesmo terreno para quem não quer uma instalação local, e o conjunto completo de comandos está no repositório do CLI.
A pergunta sobre regressão que ninguém faz cedo o bastante
A pergunta útil sobre uma base de código construída em boa parte com autocompletar não é "esse código é bom". É "o produto ainda faz o que fazia no mês passado". São perguntas diferentes, e só a segunda pega o desvio.
Respondê-la exige um conjunto de verificações anteriores à mudança, e essa é justamente a parte que os times adiam. Dez fluxos escritos na primeira semana valem mais do que cem escritos depois do primeiro incidente, porque só os dez primeiros foram definidos antes de alguém saber quais iriam importar.
O hábito de revisão que escala
Revisar cada sugestão não é possível, e não revisar nenhuma é exatamente como o desvio se acumula. O hábito que funciona é revisar por categoria, e não por linha.
Quando uma sugestão introduz um caminho de erro, confira se ele combina com a forma como o resto do módulo trata erros, porque a divergência aqui é o desvio mais comum e o mais chato de desfazer depois. Quando ela introduz um valor padrão, pergunte de onde veio esse padrão, porque um valor padrão plausível é a maneira mais silenciosa de mudar o comportamento. Quando ela introduz um helper, gaste dez segundos procurando o que já existe, já que a lógica duplicada é o que faz uma correção futura ficar incompleta.
Essas três verificações levam poucos segundos cada e pegam a maior parte do que se acumula. Todo o resto é mais bem detectado exercitando o produto do que lendo o código.
Torne isso automático
O desvio é gradual, então a verificação precisa ser regular a ponto de ser monótona. Qualquer coisa que dependa de alguém se lembrar vai ser pulada exatamente na semana corrida em que mais sugestões são aceitas.
Se o pipeline pertence a outro time, o GitHub App é o caminho de menor resistência: é um webhook, não muda nada no seu repositório e dispara quando o seu build informa que a nova versão está no ar. Se você prefere a verificação visível dentro do repositório, um passo do GitHub Actions faz isso.
Como pegar o desvio sem ler cada sugestão
Revisar cada sugestão aceita não é possível, então o TestSprite verifica o comportamento em que esse código está inserido. A cobertura é gerada a partir do seu produto, roda em cada pull request e responde à pergunta que importa para uma base de código construída em boa parte com autocompletar: isso ainda faz o que fazia no mês passado.
Isso pega os três desvios diretamente. Um valor padrão plausível que mudou uma ordenação aparece como um fluxo se comportando de forma diferente. A lógica duplicada aparece quando uma cópia é corrigida e a outra não. O desvio de convenção no tratamento de erros aparece como um caminho que agora falha em silêncio.
A verificação roda onde a mudança está, como um comentário no pull request ou uma verificação de commit, de modo que uma regressão aponta para um lote de sugestões em vez de para um trimestre inteiro delas.
O código gerado pelo Copilot é pior do que o código escrito à mão?
Na maioria dos casos, não linha a linha. O risco é de volume: entra mais código no repositório por hora do que o processo de revisão foi desenhado para absorver, então a mesma taxa de defeitos deixa mais coisas passarem.
Uma revisão mais rigorosa resolveria isso?
Em parte, e ela briga com o motivo pelo qual as pessoas usam autocompletar. Deslocar a verificação da leitura para a verificação de comportamento mantém a velocidade e devolve a rede de proteção.
E os testes que o Copilot escreve?
Úteis para cobertura, fracos como verificação independente. Um teste gerado a partir das mesmas premissas do código concorda com o código por construção.
Quantos fluxos devemos cobrir primeiro?
Comece pelos poucos que você demonstraria para um cliente, mais qualquer caminho que envolva dinheiro ou permissões. Expanda a partir dos incidentes, e não de uma meta de cobertura.
Isso precisa de acesso ao repositório?
A verificação roda contra a aplicação já publicada, pela interface dela. O acesso ao repositório é usado apenas para publicar os resultados de volta em pull requests e commits.
O bug é o desvio, não a sugestão.
Bugs em código gerado pelo GitHub Copilot se acumulam ao longo de muitas pequenas sugestões aceitas. Verifique o comportamento por pull request, e não por sugestão, defina os fluxos antes de precisar deles e mantenha a verificação rodando automaticamente.