GitHub Copilot and Developer Productivity: An Observational Dose-Response Analysis
Utilizando 16.223 engenheiros da Microsoft ao longo de 43 semanas e um design de efeitos fixos por engenheiro para controlar habilidade e esforço individuais, este estudo descobre que o uso do GitHub Copilot está associado a um aumento monotônico de 40,5% nas taxas de conclusão de pull requests em tempos de codificação equivalentes, indicando um ganho genuíno de eficiência em vez de uma correlação com períodos de trabalho inerentemente mais intensos.
Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo
Imagine que você está tentando descobrir se um novo par de tênis de corrida de alta tecnologia realmente faz as pessoas correrem mais rápido.
A maneira óbvia de testar isso é comparar dois grupos: pessoas usando os tênis e pessoas usando tênis comuns. Mas aqui está o problema: talvez as pessoas que escolhem usar os tênis de alta tecnologia sejam já atletas profissionais, enquanto os usuários de tênis comuns sejam corredores casuais. Se os usuários dos tênis correrem mais rápido, são os tênis ou apenas o fato de que eles já são corredores melhores?
Este é o exato enigma que pesquisadores da Microsoft enfrentaram com o GitHub Copilot, uma ferramenta de IA que ajuda engenheiros de software a escrever código. Eles queriam saber: O uso da IA realmente torna os engenheiros mais produtivos, ou os engenheiros que a utilizam mais são apenas pessoas naturalmente mais produtivas?
Pior ainda, há uma segunda camada de confusão. Talvez um engenheiro use a IA muito durante uma semana específica não porque a IA seja mágica, mas porque aquela semana foi um período de "correria" onde eles estavam trabalhando 80 horas por dia em um projeto enorme. Nesse caso, eles terminariam mais trabalho (Pull Requests) simplesmente porque trabalharam mais horas, não porque a IA os ajudou a trabalhar mais rápido.
A Solução: O Experimento de "Autocomparação"
Como os pesquisadores não podiam forçar aleatoriamente alguns engenheiros a parar de usar a ferramenta (isso seria antiético e interromperia o trabalho deles), eles usaram um truque inteligente chamado análise "Within-Engineer" (dentro do mesmo engenheiro).
Pense nisso desta forma: Em vez de comparar o Engenheiro A (que usa IA) com o Engenheiro B (que não usa), eles compararam o Engenheiro A consigo mesmo.
Eles observaram o mesmo engenheiro ao longo de 43 semanas.
- Semana 1: O engenheiro mal usou a IA.
- Semana 2: O engenheiro usou a IA intensamente.
Ao comparar o engenheiro consigo mesmo, eles automaticamente cancelaram todas as coisas que tornam o Engenheiro A diferente do Engenheiro B (como talento natural, função de trabalho ou cultura da equipe). Eles estavam perguntando: "Quando esta pessoa específica usa a IA mais, ela consegue realizar mais trabalho em comparação a quando a usa menos?"
O Teste de "Eficiência": Eles trabalharam mais duro ou de forma mais inteligente?
Ainda havia uma variável complicada: o Esforço.
Se um engenheiro usa a IA muito, ele também pode estar apenas sentado em frente ao computador programando por 10 horas em vez de 5. Se ele termina mais trabalho, pode ser apenas porque passou mais tempo na mesa.
Para corrigir isso, os pesquisadores usaram um "filtro" estatístico (um modelo chamado PPML) que manteve o tempo gasto programando constante.
- A Pergunta: "Se o Engenheiro A passar exatamente 8 horas programando, ele termina mais código quando usa a IA intensamente em comparação a quando não a usa?"
O Resultado: Sim. Mesmo quando o tempo gasto programando era exatamente o mesmo, os engenheiros que usavam a IA intensamente completavam cerca de 40% mais projetos de código (Pull Requests) do que nas semanas em que não a utilizavam de forma alguma.
A Bateria de "Falsificação": Eliminando Desculpas
Os pesquisadores sabiam que céticos levantariam outros motivos para esse resultado. Por isso, realizaram sete diferentes testes de "detector de mentiras" para ver se os resultados eram apenas um acaso.
O Teste da "IA Genérica": Talvez os engenheiros que usam muita IA sejam apenas "tecnologicamente avançados" e usem outras ferramentas de IA (como no Word ou Excel), o que os faz se sentir produtivos?
- Teste: Eles verificaram se o uso de IA em aplicativos não relacionados à programação (como o PowerPoint) previa mais código.
- Resultado: Não. Usar IA no Word não ajudou a escrever código. Foi especificamente a IA de programação que importou.
O Teste do "Hype da Equipe": Talvez toda a equipe estivesse em uma semana de "entusiasmo", então todos usaram a IA e todos escreveram mais código?
- Teste: Eles verificaram se o uso de IA de um engenheiro previa o output de código de seus colegas de equipe.
- Resultado: Não. Se fosse apenas o entusiasmo da equipe, o seu uso de IA deveria prever o desempenho do seu vizinho. Não previu.
O Teste de "Troca de Tarefas": Talvez em semanas com muito uso de IA, os engenheiros simplesmente pararam de revisar o código de outras pessoas e focaram inteiramente em escrever seu próprio código?
- Teste: Eles verificaram se escrever mais código significava revisar menos código.
- Resultado: Não. Os engenheiros escreveram mais código E revisaram mais código quando usaram a IA. Eles não apenas trocaram de tarefas; eles fizeram mais de tudo.
O Teste de "Fatiamento": Talvez os engenheiros estivessem apenas fatiando grandes projetos em pedaços minúsculos e fáceis para fazer os números parecerem bons?
- Teste: Eles observaram o tamanho dos projetos de código.
- Resultado: Não. O maior aumento ocorreu, na verdade, nos projetos maiores e mais complexos (7 ou mais arquivos), não nos minúsculos.
O Teste do "Trabalho Fácil": Talvez eles estivessem apenas fazendo tarefas simples (como atualizar arquivos de texto) em vez de programação difícil?
- Teste: Eles separaram arquivos de configuração "fáceis" de arquivos de código "difíceis".
- Resultado: Não. O aumento de produtividade foi, na verdade, mais forte para os arquivos de código difíceis.
O Teste de "Tempo": Talvez o uso de IA na Semana 1 fosse apenas um sinal de que o engenheiro estava em um "humor produtivo" que durou até a Semana 2?
- Teste: Eles verificaram se o uso de IA da semana anterior previa o output desta semana.
- Resultado: Não. O aumento só aconteceu na exata mesma semana em que a IA foi usada.
A Conclusão Final
O estudo conclui que o GitHub Copilot genuinamente torna os engenheiros mais eficientes.
Quando um engenheiro utiliza a ferramenta de forma mais intensa, ele realiza cerca de 40% mais trabalho no mesmo período de tempo. Não é apenas que pessoas produtivas usam a ferramenta; a ferramenta em si parece agir como um multiplicador de força, ajudando os engenheiros a realizarem mais sem precisar trabalhar mais horas.
No entanto, os pesquisadores são cuidadosos ao notar: este estudo mede a eficiência (fazer mais coisas por hora). Ele não mede o tempo total economizado. Se a IA te ajuda a terminar uma tarefa em 30 minutos em vez de uma hora, sua "eficiência" aumenta, mas você também pode simplesmente parar de trabalhar mais cedo. O estudo prova que a velocidade aumenta, mas não nos diz exatamente como os engenheiros gastam esse tempo extra.
Afogado em artigos na sua área?
Receba digests diários dos artigos mais recentes que correspondam às suas palavras-chave de pesquisa — com resumos técnicos, no seu idioma.