Os AIs de Codificação Tendem a Sofrer do Efeito Dunning-Kruger

Pesquisas recentes mostram que os AIs de codificação, como o ChatGPT, sofrem do Efeito Dunning-Kruger, muitas vezes agindo com mais confiança quando são menos competentes. Ao lidar com linguagens de programação desconhecidas ou obscuros, eles afirmam alta certeza, mesmo quando suas respostas se desmoronam. O estudo relaciona a superconfiança do modelo com o desempenho ruim e a falta de dados de treinamento, levantando novas preocupações sobre o quanto esses sistemas realmente sabem sobre o que eles não sabem.

Qualquer pessoa que tenha passado um tempo moderado interagindo com Modelos de Linguagem Grande sobre questões factuais já sabe que os LLMs frequentemente tendem a dar respostas confiantes, mas erradas a uma consulta do usuário.

Além de formas mais óbvias de alucinação, a razão para essa bravata vazia não é 100% clara. Pesquisas publicadas durante o verão sugerem que os modelos dão respostas confiantes mesmo quando sabem que estão errados, por exemplo; embora outras teorias atribuam a superconfiança a escolhas arquitetônicas, entre outras possibilidades.

O que o usuário final pode ter certeza é que a experiência é incrivelmente frustrante, pois somos programados para confiar nas estimativas das pessoas sobre suas próprias habilidades (não menos porque, nesses casos, há consequências, legais e outras, para uma pessoa superprometer e subentregar); e uma espécie de transferência antropomórfica significa que tendemos a replicar esse comportamento com sistemas de IA conversacional.

Mas um LLM é uma entidade sem responsabilidade que pode e vai efetivamente retornar um ‘Quem diria! Erros…’ após ter ajudado o usuário a inadvertidamente destruir algo importante, ou pelo menos desperdiçar uma tarde do tempo deles; supondo que ele admita a responsabilidade.

Pior, essa falta de circunspeção prudente parece impossível de ser afastada, pelo menos no ChatGPT, que abundantemente tranquiliza o usuário sobre a validade de seus conselhos e explica os defeitos em seu pensamento apenas após o dano ser feito. Nem atualizar a memória persistente do sistema, nem o uso de prompts repetitivos parecem ter muito impacto no problema.

As pessoas podem ser igualmente obstinadas e autoenganadas – embora qualquer pessoa que errasse tão profundamente e com frequência provavelmente seria demitida cedo. Tais pessoas sofrem do oposto do ‘síndrome do impostor’ (onde um funcionário teme ter sido promovido acima de suas capacidades) – o Efeito Dunning Kruger, onde uma pessoa superestima significativamente sua capacidade de realizar uma tarefa.

O Custo da Inflação

Um novo estudo da Microsoft examina o valor do Efeito Dunning-Kruger em relação ao desempenho eficaz de arquiteturas de codificação auxiliadas por IA (como o próprio Copilot da Microsoft), em um esforço de pesquisa que é o primeiro a abordar especificamente esse subconjunto de LLMs.

O trabalho analisa como os AIs de codificação confiantes avaliam suas próprias respostas contra como elas realmente se saem, em dezenas de linguagens de programação. Os resultados mostram um padrão humano: quando os modelos eram menos capazes, eles estavam mais seguros de si.

O efeito foi mais forte em linguagens obscuras ou de baixo recurso, onde os dados de treinamento eram escassos – o modelo mais fraco ou a linguagem mais rara, a maior a ilusão de habilidade:

Desempenho real e percebido do GPT-4o em linguagens de programação, ordenado por desempenho real. Fonte: https://arxiv.org/pdf/2510.05457

Os quatro autores, todos contribuintes iguais trabalhando para a Microsoft, argumentam que o trabalho levanta novas questões sobre quanto essas ferramentas podem ser confiáveis para julgar suas próprias saídas, e eles afirmam:

‘Ao analisar a confiança do modelo e o desempenho em um conjunto diversificado de linguagens de programação, revelamos que os modelos de IA espelham padrões humanos de superconfiança, especialmente em domínios desconhecidos ou de baixo recurso.

‘Nossos experimentos demonstram que modelos menos competentes e aqueles que operam em linguagens de programação raras exibem um viés DKE mais forte, sugerindo que a força do viés é proporcional à competência dos modelos. Isso está alinhado com experimentos humanos para o viés.’

Os pesquisadores contextualizam essa linha de estudo como uma forma de entender como a confiança do modelo se torna não confiável quando o desempenho é ruim, e para testar se os sistemas de IA exibem o mesmo tipo de superconfiança visto nos humanos – com implicações downstream para confiança e implantação prática.

Embora o novo artigo desafie a Lei de Betteridge, ele é intitulado Os Modelos de Código Sofrem do Efeito Dunning-Kruger?. Embora os autores afirmem que o código foi liberado para o trabalho, a pré-impressão atual não contém detalhes sobre isso.

Método

O estudo testou como precisamente os AIs de codificação podiam julgar suas próprias respostas, dando-lhes milhares de perguntas de programação de múltipla escolha, com cada pergunta pertencente a um domínio de linguagem específico, desde Python e Java até Perl e COBOL:

Domínios de linguagem de programação usados no estudo, juntamente com o número de perguntas de programação de múltipla escolha amostradas para cada domínio.

Os modelos foram incumbidos de escolher a opção correta e, em seguida, estimar o quanto estavam confiantes em sua escolha, com seu desempenho real medido por quantas vezes obtiveram a resposta certa – e sua confiança autoavaliada indicando o quão bons eles acreditavam ser. Comparar essas duas métricas permitiu que os pesquisadores vissem onde a confiança e a competência divergiam.

Para medir o quanto os modelos pareciam confiantes, o estudo usou dois métodos: confiança absoluta e confiança relativa. No primeiro, o modelo foi solicitado a dar uma pontuação de zero a um ao lado de cada resposta, com sua confiança para uma linguagem específica definida pela média dessas pontuações em perguntas nessa linguagem.

O segundo método examinou o quanto o modelo estava confiante ao escolher entre duas perguntas; para cada par, o modelo teve que dizer qual uma sentia-se mais seguro. Essas escolhas foram pontuadas usando sistemas de classificação originalmente projetados para jogos competitivos, tratando cada pergunta como se fosse um jogador em uma partida. As pontuações finais foram normalizadas e médias para cada linguagem para dar uma pontuação de confiança relativa.

Dois formas estabelecidas do Efeito Dunning-Kruger são examinadas no artigo: uma que acompanha como um modelo único subestima seu desempenho em diferentes domínios; e outra que compara níveis de confiança entre modelos mais fracos e mais fortes.

A primeira forma, chamada DKE intra-participante, examina se um modelo único se torna mais superconfiante em linguagens onde se sai mal. A segunda, DKE inter-participante, pergunta se os modelos que se saem pior também tendem a se autoavaliar mais alto.

Em ambos os casos, a lacuna entre a confiança e o desempenho real é usada para medir a superconfiança, com lacunas maiores em configurações de baixo desempenho apontando para um comportamento semelhante ao DKE.

Resultados

O estudo testa o Efeito Dunning-Kruger em seis grandes modelos de linguagem: Mistral; Phi-3; DeepSeek-Distill; Phi-4; GPT-0.1 e GPT-4o.

Cada modelo foi testado em perguntas de programação de múltipla escolha do conjunto de dados CodeNet público, com 37 linguagens representadas para revelar como a confiança e a precisão variavam em domínios de codificação familiares e obscuros.

A análise inter-modelo mostra um padrão Dunning-Kruger claro:

Desempenho real versus percebido em seis modelos de código, mostrando como modelos de baixo desempenho, como Mistral e Phi-3, exibem alta confiança apesar de baixa precisão, enquanto modelos mais fortes, como GPT-4o, mostram níveis de confiança mais calibrados ou até mesmo subconfiantes.

Modelos com menor precisão, incluindo Mistral e Phi-3, tendiam a superestimar suas próprias habilidades, enquanto sistemas de desempenho mais alto, como o GPT-4o, mostraram níveis de confiança que se alinhavam mais estreitamente com seu desempenho real, particularmente quando julgados pela confiança relativa.

Os resultados também indicam que os modelos mais capazes podem às vezes subestimar a si mesmos (um padrão que as pontuações de confiança absoluta não capturam).

Os resultados também indicam que a análise intra-modelo também apoia a presença do Efeito Dunning-Kruger. No gráfico de resultados mostrado no início do artigo, vemos como cada modelo se saiu em diferentes linguagens de programação, ordenadas por desempenho real.

Em linguagens onde os modelos obtiveram pontuações baixas, particularmente em linguagens raras ou de baixo recurso, como COBOL, Prolog e Ceylon, sua confiança era notavelmente mais alta do que o justificado por seus resultados. Em linguagens bem conhecidas, como Python e JavaScript, sua confiança se alinhava mais estreitamente com sua precisão real e, às vezes, até mesmo caía abaixo dela.

Esse padrão apareceu em ambas as medidas de confiança absoluta e relativa, sugerindo que os modelos são menos conscientes de seus próprios limites quando operam em domínios de codificação desconhecidos.

Tratar os modelos como participantes introduziu algumas limitações, pois o pequeno número de modelos em jogo afeta a diversidade; as diferenças dentro das saídas de um modelo são ignoradas; e a distribuição de dados pode não refletir a de participantes humanos reais.

Para contornar isso, o estudo testou três configurações alternativas: primeiro, cada modelo recebeu uma persona distinta; segundo, as respostas foram amostradas a uma temperatura mais alta para criar mais variação; terceiro, os prompts foram reescritos múltiplas vezes, com cada versão tratada como um participante separado:

Correlação entre superconfiança e desempenho real em diferentes configurações experimentais, mostrando que o padrão Dunning-Kruger permanece consistente em todas as condições e é mais forte quando múltiplas respostas diversificadas são amostradas do mesmo modelo.

A tabela de resultados acima indica como fortemente o Efeito Dunning-Kruger se manifesta sob essas condições, permanecendo presente em todos os casos; e que o DKE foi mais pronunciado quando múltiplas respostas foram amostradas do mesmo modelo a alta temperatura.

Para entender melhor como o desempenho percebido diverge do desempenho real, o estudo comparou estimativas de confiança absoluta e relativa, calculando o quanto cada modelo superestimava sua própria habilidade (especificamente, a diferença entre sua pontuação de confiança e sua precisão real), e então medindo como essa superestimação se relacionava com o desempenho real do modelo:

Correlação entre superconfiança (medida como confiança absoluta menos confiança relativa) e precisão real em domínios de programação e tipos de modelo, mostrando que uma superestimação maior está consistentemente associada a um desempenho mais baixo.

Os resultados da tabela acima ilustram como a superestimação se relaciona com o desempenho real, tanto em domínios de programação quanto em modelos. Em ambos os casos, podemos ver que os modelos com menor precisão tendem a mostrar maior superconfiança.

Além disso, os modelos especializados treinados em domínios mais estreitos mostraram efeitos DKE mais fortes do que os modelos generalistas:

Correlação entre superestimação e desempenho real para modelos base, especializados em um domínio e em vários domínios, mostrando efeitos DKE mais fortes à medida que a especialização aumenta.

Usando o conjunto de dados MultiPL-E em oito linguagens de programação, os autores encontraram que o treinamento em um único domínio levou a uma superconfiança maior do que os modelos de base ou multi-domínio, sugerindo que DKE piora com a especialização aumentada.

Os testes também encontraram que os modelos tendem a ser mais superconfiantes em linguagens de programação raras. Em rankings do GitHub, IEEE e TIOBE, a raridade está fortemente correlacionada com uma confiança percebida mais alta, atingindo 0,797:

Correlação entre superconfiança do modelo e raridade da linguagem, usando três rankings de popularidade. Linguagens menos comuns estão associadas a um desempenho percebido mais alto.

Finalmente, os autores testaram se o efeito Dunning-Kruger aparece na geração de código, avaliando os modelos no conjunto de dados MultiPL-E em oito linguagens de programação.

Embora o efeito ainda estivesse presente, ele foi notavelmente mais fraco do que no cenário de perguntas de múltipla escolha, provavelmente refletindo a maior dificuldade em avaliar a confiança e a correção em tarefas abertas:

Correlação entre superestimação e desempenho real na geração de código aberta, com base nos resultados do MultiPL-E em oito linguagens.

Ao considerar a explicação ainda disputada para o efeito Dunning-Kruger, os autores concluem:

‘Uma explicação potencial que pode ser comum a humanos e modelos de IA é a explicação metacognitiva, que afirma que avaliar a qualidade de um desempenho de uma habilidade é uma parte crucial de adquirir essa habilidade.

‘Essa explicação pode ser testada experimentalmente em modelos de IA com um estudo controlado de diferentes estratégias de treinamento e se elas levam a melhorias simultâneas no desempenho e na capacidade de avaliar a qualidade do desempenho. No entanto, esse estudo está significativamente além do escopo deste artigo, e o deixamos para trabalhos futuros.’

Conclusão

Mesmo em seu domínio nativo, o efeito Dunning-Kruger (como o artigo nota) pode ser atribuído a uma causa estatística ou cognitiva. Se for a uma causa estatística, a aplicação de uma síndrome única humana a um contexto de aprendizado de máquina é bastante válida.

Embora os autores especulem que a causa poderia ser encontrada como ‘cognitiva’ em ambos os casos, isso exigiria uma perspectiva ligeiramente mais metafísica.

Talvez a descoberta mais interessante no artigo seja a extensão com que vários LLMs de codificação tendem a dobrar em suas circunstâncias menos favoráveis, ou seja, exibindo confiança máxima ao lidar com as linguagens mais escassas ou menos conhecidas – o que seria uma estratégia quase imediatamente autodestrutiva em um ambiente de trabalho real.

* As linguagens de programação usadas foram Ada, Bash, C, C#, C++, COBOL, Ceylon, Clojure, D, Dart, Dash, Elixir, Erland, F#, Fortran, Go, Haskell, Java, JavaScript, Julia, Lisp, Kotlin, Lua, OCaml, Objective-C, PHP, Pascal, Perl, Prolog, Python, Racket, Ruby, Rust, Scala, Swift, TypeScript e Visual Basic.

Publicado pela primeira vez na quarta-feira, 8 de outubro de 2025