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

Pesquisa recente mostra que 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 alegam alta certeza, mesmo quando suas respostas se desmoronam. O estudo relaciona a superconfiança do modelo à baixa performance e à 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 mesmo um tempo moderado interagindo com Modelos de Linguagem Grande sobre questões factuais já sabe que os LLMs frequentemente tendem a dar uma resposta confiante, mas errada a uma consulta do usuário.

Além de formas mais óbvias de alucinação, o motivo para essa boastfulness vazia não é 100% claro. Pesquisa publicada durante o verão sugere 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 arquiteturais, entre outras possibilidades.

O que o usuário final pode ter certeza é que a experiência é incrivelmente frustrante, pois somos programados para depositar fé 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 ‘Whoops! Butterfingers…’ após ter ajudado o usuário a destruir involuntariamente algo importante, ou pelo menos desperdiçar uma tarde do tempo deles; supondo que ele admita a responsabilidade.

Pior, essa falta de prudência parece impossível de ser afastada, pelo menos no ChatGPT, que abundará em garantir ao usuário a validade de seus conselhos e explicará 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 na questão.

As pessoas podem ser igualmente obstinadas e autodeludidas – embora qualquer um que errasse profundamente e com frequência provavelmente seria demitido 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 sub-setor 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 mesmos.

O efeito foi mais forte em linguagens obscuros ou de baixo recurso, onde os dados de treinamento eram escassos – o modelo mais fraco ou a linguagem mais rara, 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 sua própria saída, 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 se alinha 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 pouco confiável quando o desempenho é fraco, 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 manchetes 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 os AIs de codificação podiam julgar suas próprias respostas, dando-lhes milhares de perguntas de múltipla escolha de programação, 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 múltipla escolha de codificação amostradas para cada domínio.

Os modelos foram solicitados a escolher a opção correta e, em seguida, estimar o quão confiantes estavam em sua escolha, com seu desempenho real medido por quão frequentemente obtinham 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 quão confiantes os modelos pareciam ser, 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 todas as perguntas daquela linguagem.

O segundo método olhou para o quão confiante o modelo estava ao escolher entre duas perguntas; para cada par, o modelo teve que dizer qual um sentia 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 rastreia 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, olha 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 altamente.

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

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 único 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 foi dado uma personalidade distinta; segundo, as respostas foram amostradas a uma temperatura mais alta para criar mais variação; terceiro, os prompts foram parafraseados várias 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.

Os resultados da tabela acima indicam 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 uma temperatura alta.

Para melhor entender 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 capacidade (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.

A tabela de resultados acima ilustra 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 generalistas:

Correlação entre superestimação e desempenho real para modelos base, especializados em um domínio e especializados 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 multi-domínio ou base, sugerindo que o 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. Ao longo das classificações do GitHub, IEEE e TIOBE, a raridade se correlaciona fortemente com uma confiança percebida mais alta, atingindo um pico de 0,797:

Correlação entre superconfiança do modelo e raridade da linguagem, usando três classificações 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 confiança e correção em tarefas abertas:

Correlação entre superestimação e desempenho real na geração de código aberto, 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 potencialmente ser testada experimentalmente em modelos de IA com um estudo controlado de diferentes estratégias de treinamento e se todas 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 um trabalho futuro.’

Conclusão

Mesmo em seu domínio nativo, o Efeito Dunning-Kruger (como o artigo observa) pode ser atribuído a uma causa estatística ou cognitiva. Se for a uma causa estatística, a aplicação de um síndrome até então exclusivamente humano 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 um ponto de vista ligeiramente mais metafísico.

Talvez a descoberta mais interessante no artigo seja a extensão com que vários LLMs de codificação tendem a se dobrar em suas circunstâncias menos favoráveis, ou seja, exibindo confiança máxima quando lidam 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