Resumo Técnico: A Influência dos Grandes Modelos de Linguagem no Código

Declaração do Problema

A rápida integração de Grandes Modelos de Linguagem (LLMs) e ferramentas impulsionadas por LLMs (ex: Copilot, Cursor) no desenvolvimento de software levantou questões sobre seu impacto tangível nas práticas reais de programação. Enquanto pesquisas anteriores focaram em distinguir código gerado por LLM de código escrito por humanos ou em avaliar a correção funcional, há uma falta de evidência empírica sobre se os LLMs transformaram fundamentalmente o estilo de código no mundo real. Este artigo investiga a questão central: Os LLMs transformaram o estilo de código e como tal transformação pode ser caracterizada? Especificamente, os autores examinam se as preferências estilísticas dos LLMs (ex: convenções de nomenclatura, métricas de complexidade) estão permeando bases de código escritas por humanos ao longo do tempo.

Metodologia

O estudo emprega uma abordagem de duas frentes, combinando análise empírica em larga escala de repositórios reais com simulações controladas.

1. Coleta de Dados

• Repositórios do GitHub: Os autores coletaram 22.074 repositórios e mais de 1 milhão de arquivos de código fonte vinculados a artigos do arXiv publicados entre o primeiro trimestre de 2020 e o terceiro trimestre de 2025. Os repositórios foram categorizados por linguagem de programação (Python, C/C++) e domínio científico (Ciência da Computação vs. Não-CC).
• Linha de Base Escrita por Humanos: Para estabelecer uma linha de base pré-LLM, os autores utilizaram o Code4Bench, um conjunto de dados de submissões de usuários aceitas no Codeforces antes de 2020.
• Subconjunto de Problemas: Um subconjunto de 200 problemas algorítmicos foi selecionado do Code4Bench, estratificado por dificuldade (rating 800–2000+) e tipo de algoritmo (ex: DP, Greedy, Math).

2. Simulação e Geração

Os autores simularam a codificação assistida por LLM usando 12 LLMs diversos (incluindo séries Qwen3, DeepSeek-R1, GPT-4.1, Llama-4 e Gemini-2.0). Duas estratégias de geração foram testadas:

• Geração Direta (ANS): Os modelos resolvem problemas do zero baseando-se apenas nas descrições dos problemas.
• Geração Guiada por Referência (REF): Os modelos recebem uma solução humana correta (código AC) e são instruídos a revisar ou reescrever o código.

3. Métricas de Avaliação

O estudo analisou o código através de quatro dimensões:

• Padrões de Nomenclatura: Categorizados em formatos (snake_case, camelCase, PascalCase, etc.) e medidos pelo comprimento dos nomes.
• Complexidade e Manutenibilidade: Medidos usando Complexidade Ciclomática, métricas de Halstead (Volume, Dificuldade, Esforço, Bugs) e Índice de Manutenibilidade (Padrão e Customizado).
• Similaridade de Código: Quantificada usando Similaridade de Cosseno e Similaridade de Jaccard entre o código humano, a geração direta e a geração guiada por referência.
• Alinhamento de Raciocínio: Analisou a correspondência entre os rótulos algorítmicos na cadeia de raciocínio do modelo e as tags do problema de verdade fundamental (ground-truth).

Principais Contribuições e Resultados

1. Evidência de Transformação de Estilo (Padrões de Nomenclatura)

O estudo fornece a primeira evidência empírica em larga escala de que os LLMs estão influenciando os estilos de codificação humana.

• Adoção de Preferências de LLM: Em Python, a proporção de nomes de funções em snake_case em repositórios do GitHub aumentou de 40,7% no Q1 2023 para 49,8% no Q3 2025. Essa tendência alinha-se com a preferência observada no código gerado por LLM.
• Nomenclatura de Variáveis: Os LLMs preferem consistentemente nomes de variáveis mais longos e descritivos (ex: max_length em vez de ml) e evitam nomes de letra única ou com sufixos numéricos. Repositórios do GitHub mostram um declínio paralelo em nomes curtos/com sufixos numéricos e um aumento no comprimento médio dos nomes, particularmente em domínios de CC.
• Diferenças de Linguagem: Embora o Python mostre tendências temporais claras na nomenclatura, as tendências em C/C++ são menos pronunciadas, embora o uso de snake_case em variáveis e funções em C/C++ ainda mostre uma trajetória ascendente.

2. Complexidade e Manutenibilidade

• LLM vs. Humano: Em Python, o código gerado por LLM exibiu maior complexidade ciclomática do que o código escrito por humanos. Por outro lado, em C/C++, os LLMs produziram código com menor complexidade ciclomática.
• Manutenibilidade: O código gerado por LLM geralmente demonstrou índices de manutenibilidade mais altos e contagens estimadas de bugs menores em comparação com as soluções escritas por humanos na simulação.
• Guiado por Referência vs. Direto: Em Python, a geração guiada por referência (reescrita de código existente) resultou em código mais conciso (menor volume/esforço de Halstead) do que a geração direta. Em C/C++, o oposto foi observado.

3. Similaridade de Código

• Capacidade de Imitação: Quando fornecidos com código de referência, os LLMs produziram soluções com maior similaridade (tanto de Cosseno quanto de Jaccard) ao código humano original em comparação com a geração direta.
• Divergência: Sem orientação de referência, o código gerado por LLM em tarefas de algoritmos de IO divergiu significamente em estilo do código escrito por humanos, sugerindo que os LLMs possuem estilos "nativos" distintos que diferem das normas humanas, a menos que sejam explicitamente condicionados.

4. Raciocínio e Compreensão Algorítmica

• Correspondência de Rótulos: A análise das cadeias de raciocínio revelou que os LLMs frequentemente falham em mencionar explicitamente os rótulos algorítmicos corretos (ex: "DP", "Greedy") associados ao problema.
• Taxas de Erro: A taxa de erro (identificar algoritmos incorretos) geralmente excedeu a taxa de correspondência (identificar algoritmos corretos).
• Viés de Linguagem: Os modelos tenderam a depender mais do raciocínio algorítmico para tarefas de C/C++ comparado ao Python, onde se inclinaram para detalhes de implementação prática.
• Correlação de Dificuldade: Tanto as taxas de correspondência quanto as de erro aumentaram com a dificuldade do problema, sugerindo que problemas mais difíceis ativam melhor as capacidades de raciocínio algorítmico dos modelos, embora com maior ruído.

Significância e Alegações

O artigo afirma fornecer a primeira evidência empírica em larga escala de que os LLMs não são apenas ferramentas para gerar código, mas estão moldando ativamente o cenário estilístico da programação no mundo real.

• Mudança de Normas: Os autores argumentam que os estilos de codificação humana estão mudando em direção às convenções preferidas pelos LLMs (ex: snake_case, nomes mais longos), criando um ciclo de feedback onde desenvolvedores humanos podem estar se alinhando sutilmente com as normas geradas por máquinas.
• Além da Detecção: Diferente de trabalhos anteriores focados em detectar código gerado por IA, este estudo foca na influência dos LLMs na evolução do estilo de código, destacando que o impacto dos LLMs vai além da correção funcional para as normas estéticas e estruturais.
• Implicações: As descobertas sugerem que, conforme a adoção de LLMs cresce, a distinção entre o estilo "humano" e o "de máquina" pode se tornar tênue, necessitando de uma reavaliação de como a qualidade e o estilo do código serão avaliados no futuro.

Os autores mantêm-se modestos em relação às suas alegações, reconhecendo limitações como a incapacidade de quantificar a porcentagem exata de código gerado por LLMs no mundo real e o potencial de incompletude da linha de base pré-LLM (Code4Bench) em representar todo o espectro de estilos de codificação humana. Eles enfatizam que seu trabalho identifica traços de influência, em vez de uma causalidade definitiva para todas as mudanças observadas.