"Should I Give Up Now?" Investigating LLM Pitfalls in Software Engineering

Este estudo investiga os desafios da integração de assistentes de IA no fluxo de trabalho de engenharia de software, identificando nove tipos de falhas que levaram a maioria dos participantes a abandonar a ferramenta devido a respostas incorretas, sobrecarga cognitiva e perda de contexto, embora a persistência no uso de prompts tenha reduzido significativamente a probabilidade de abandono.

O essencial

Imagine que você está tentando construir uma casa complexa, mas em vez de contratar um mestre de obras experiente, você contrata um estagiário superinteligente, mas um pouco alucinado, que nunca viu uma obra antes. Ele sabe muita teoria, fala muito bem, mas às vezes esquece de colocar o cimento, confunde tijolos com vidro ou entrega um plano que funciona apenas no papel.

Este é o resumo do artigo "Devo Desistir Agora?", que investiga o que acontece quando engenheiros de software tentam usar a Inteligência Artificial (como o ChatGPT) para trabalhar.

Aqui está a explicação do estudo, traduzida para o nosso dia a dia:

1. O Cenário: O Estagiário Alucinado

Os pesquisadores pediram para 26 pessoas (alguns estudantes, outros profissionais experientes) construírem um site do zero usando o ChatGPT como assistente. A ideia não era ver se a IA era perfeita, mas sim como as pessoas lidavam quando a IA falhava.

O resultado? A IA era como um assistente que:

• Esquece o que você pediu: Você pede para mudar a cor do botão, e ele muda o tamanho da janela inteira.
• Dá respostas "meia-boca": Ele entrega metade do código e some, deixando você para terminar o resto.
• Fica confuso: Se você mudar o contexto da conversa, ele esquece tudo o que foi dito antes.
• Complica o simples: Em vez de uma solução rápida, ele sugere uma máquina complexa de Rube Goldberg para fazer algo simples.

2. As Três Grandes Armadilhas (Os "Pitfalls")

O estudo descobriu que as falhas se encaixam em três categorias principais:

• A Resposta Incompleta ou Errada: É como pedir uma pizza e receber apenas a massa crua. O código vem com erros ou faltam peças essenciais.
• A Sobrecarga Mental: Às vezes, a IA responde com um "livro inteiro" de texto quando você só queria uma linha de código. Você tem que ler tudo para achar a parte útil, o que cansa a cabeça.
• O Esquecimento (Perda de Contexto): É como conversar com alguém que tem amnésia a cada 5 minutos. Você explica o problema, ele dá uma solução, você pede um ajuste, e ele esquece o ajuste anterior e começa tudo de novo.

3. A Tentativa de "Consertar" (Estratégias de Mitigação)

Quando a IA falha, os usuários tentam se adaptar, como se estivessem ensinando um cachorro novo a fazer truques:

• Refazer o Pedido: Tentar explicar de outra forma ("Não, eu quero o botão azul, não o vermelho!").
• Quebrar em Pedacinhos: Em vez de pedir "faça o site todo", pedir "faça só o cabeçalho".
• Corrigir Manualmente: Pegar o código da IA, ler, achar o erro e consertar com as próprias mãos.

O Problema: Muitas vezes, tentar "consertar" o estagiário alucinado gasta mais energia do que fazer o trabalho sozinho.

4. O Momento da Verdade: "Devo Desistir?"

A parte mais importante do estudo é sobre o abandono.

• O Gatilho: Quando as respostas da IA são inúteis, a chance de a pessoa desistir aumenta 11 vezes.
• A Persistência: Curiosamente, quanto mais a pessoa tenta (fazendo mais perguntas), menor a chance de desistir. Parece que a persistência em "conversar" com a IA ajuda a manter o foco.
• A Experiência: Os programadores mais experientes desistem mais rápido quando percebem que a IA não está ajudando. Eles sabem que é perda de tempo. Os iniciantes tendem a insistir mais, mesmo quando o caminho está bloqueado.

5. A Conclusão: A IA é uma Ferramenta, não um Mágico

O estudo mostra que, embora a IA tenha melhorado (com versões mais novas como o GPT-5.1), ela ainda não é confiável para tarefas complexas e contínuas.

• A Analogia Final: Usar a IA para programar é como tentar dirigir um carro com um GPS que às vezes aponta para o fundo do mar. Se você confiar cegamente, vai se perder. Se você souber que o GPS é falho e ficar de olho no mapa, pode chegar lá.
• O Veredito: A IA é ótima para tarefas simples e rápidas (como "como se escreve 'olá' em Python?"), mas para construir algo grande e complexo, ela ainda exige que o humano faça o trabalho pesado de checar, corrigir e, muitas vezes, desistir e fazer sozinho.

Em resumo: A IA é um assistente poderoso, mas ainda precisa de um "chefe" humano muito atento. Se o chefe ficar cansado de corrigir os erros do assistente, ele acaba jogando a IA no lixo e faz o trabalho sozinho. O estudo nos ensina a saber quando usar a IA e quando desistir dela para não perder tempo.

Resumo técnico

1. Problema e Motivação

A integração de Assistentes de IA baseados em Grandes Modelos de Linguagem (LLMs), como o ChatGPT, no fluxo de trabalho de engenharia de software (ES) promete aumentar a produtividade e reduzir a carga cognitiva. No entanto, a experiência dos engenheiros varia drasticamente. Enquanto alguns encontram utilidade, outros consideram os LLMs contraproducentes devido a respostas imprecisas, alucinações e falta de consistência.

O problema central identificado é que a literatura existente sobre adoção de ferramentas assume que o software se comporta de maneira determinística e estável. Os LLMs, por outro lado, são probabilísticos, adaptativos e multi-turno. Isso cria um cenário onde falhas se acumulam ao longo da interação (em vez de ocorrerem isoladamente), levando a um fenômeno pouco estudado: o abandono do assistente de IA no meio de uma tarefa complexa. O estudo busca entender sob quais condições os LLMs falham, por que os usuários desistem e quais estratégias de mitigação são eficazes.

2. Metodologia

O estudo emprega uma abordagem mista (qualitativa e quantitativa) baseada em observação direta e análise de dados reais.

• Design da Tarefa: Os participantes realizaram uma tarefa complexa de desenvolvimento web (criação de um site com múltiplos arquivos, HTML, CSS, JS e implantação), simulando cenários reais onde os desenvolvedores lidam com tecnologias ou estruturas desconhecidas.
• Participantes:
  • 26 participantes no total (21 estudantes de pós-graduação e 5 desenvolvedores de software profissionais - SDEs).
  • Incluiu uma replicação com 6 SDEs utilizando uma versão mais recente do modelo (GPT-5.1) para garantir que os achados não fossem obsoletos devido à rápida evolução dos modelos.
• Protocolo:
  • Sessões virtuais gravadas (áudio e tela) com protocolo "pensar em voz alta" (think-aloud).
  • Sem treinamento em engenharia de prompts: Os participantes receberam apenas uma introdução básica ao ChatGPT, simulando o uso realista e de baixa estruturação (low-scaffolding).
  • Coleta de Dados: Logs de interação (prompts e respostas), gravações de tela, transcrições de entrevistas pós-tarefa e rubricas de avaliação de completude da tarefa.
• Análise:
  • Qualitativa: Análise temática indutiva para categorizar falhas, causas e estratégias de mitigação. Triangulação de dados (comportamento, fala e logs).
  • Quantitativa: Regressão logística para testar hipóteses sobre fatores que influenciam o abandono (ajustando para experiência de codificação e tipo de participante).

3. Principais Contribuições

1. Conjunto de Dados de Interação: Um dataset detalhado de históricos de interação com ChatGPT em tarefas complexas de ES, incluindo logs de prompts, código gerado e comportamentos de abandono.
2. Taxonomia de Falhas: Identificação de 9 tipos distintos de falhas, agrupados em três categorias principais:
   • Respostas incompletas ou incorretas.
   • Sobrecarga cognitiva e má gestão de informações.
   • Perda de contexto e esforço redundante.
3. Causas Raiz: Mapeamento de 12 causas subjacentes, divididas entre falhas do usuário (ex: prompts vagos) e limitações do modelo (ex: ignorar instruções, perda de contexto).
4. Estratégias de Mitigação: Identificação de 7 estratégias usadas pelos usuários para lidar com falhas (ex: scaffolding de tarefas, esclarecimento de prompts, depuração manual).
5. Evidência Estatística de Abandono: Modelagem quantitativa que correlaciona a utilidade das respostas e o comportamento do usuário com a probabilidade de desistir da ferramenta.

4. Resultados Chave

A. Tipos de Falhas (RQ1)

As falhas não são apenas erros de código, mas rupturas na interação:

• Respostas Incompletas/Incorretas (40%): O modelo omite detalhes cruciais ao lidar com prompts grandes ou falha em especificar pré-requisitos (ex: instalação de pacotes).
• Sobrecarga Cognitiva (24%): Respostas excessivamente longas e desestruturadas que dificultam a extração de informações relevantes.
• Perda de Contexto (17%): O modelo esquece informações fornecidas em turnos anteriores, exigindo que o usuário repita detalhes ou corrigindo inconsistências.
• Nota sobre GPT-5.1: A replicação com modelos mais novos mostrou melhorias em respostas de "um único tiro" (one-shot), mas as mesmas categorias de falha persistiram em tarefas multi-turno e iterativas.

B. Causas das Falhas (RQ2)

As falhas surgem da interação entre usuário e modelo:

• Contribuição do Usuário: Prompts vagos, tarefas delegadas excessivamente complexas em um único turno, e dificuldade em articular necessidades técnicas.
• Contribuição do ChatGPT: Ignorar o nível de expertise do usuário, falta de suporte para interação com múltiplos arquivos, incapacidade de localizar onde fazer alterações no código e alucinações visuais.

C. Estratégias de Mitigação (RQ3)

Os usuários tentaram corrigir falhas através de:

• Scaffolding (quebrar a tarefa em sub-tarefas menores).
• Refinamento de prompts.
• Depuração manual do código gerado.
• Resultado: Apesar dessas tentativas, 17 dos 26 participantes (65%) abandonaram o ChatGPT durante a tarefa devido a falhas persistentes.

D. Fatores de Abandono (RQ5)

A análise de regressão logística revelou fatores estatisticamente significativos:

• Utilidade da Resposta: Respostas "inúteis" aumentaram a probabilidade de abandono em 11 vezes (Odds Ratio = 11) em comparação com respostas úteis.
• Número de Prompts: Cada prompt adicional reduziu a probabilidade de abandono em 17%, sugerindo que a persistência na interação está correlacionada com a conclusão da tarefa.
• Experiência: Desenvolvedores com mais anos de experiência tinham menor probabilidade de abandonar, possivelmente devido a melhores habilidades de depuração e ajuste de prompts.
• Desempenho da Tarefa: Curiosamente, a pontuação de completude da tarefa não foi um preditor significativo de abandono; os usuários desistiam mesmo quando a tarefa estava parcialmente completa, devido à frustração com a ferramenta.

5. Significado e Implicações

• Teoria de Interação Humano-AI: O estudo desafia os modelos tradicionais de adoção de ferramentas, propondo que o abandono em LLMs é um processo dinâmico e cumulativo, não uma decisão binária baseada em uma única falha. A "sobrecarga cognitiva" e a "perda de contexto" são barreiras críticas.
• Limitações das Atualizações de Modelo: Mesmo com modelos mais avançados (GPT-5.1), as falhas de interação em tarefas complexas e iterativas persistem. Melhorar a precisão do código em one-shot não resolve os problemas de colaboração multi-turno.
• Design de Ferramentas:
  • Os LLMs precisam melhorar a retenção de contexto e a localização de código (indicar exatamente onde alterar).
  • É necessário um mecanismo para detectar "loops de prompt improdutivos" e sugerir alternativas (ex: consultar documentação externa) antes que o usuário desista.
  • A adaptação da resposta ao nível de expertise do usuário é crucial para evitar respostas muito complexas ou muito simples.
• Prática de Engenharia: O estudo sugere que, em cenários reais, os desenvolvedores profissionais tendem a usar LLMs para tarefas bem definidas, mas recorrem a fontes externas (StackOverflow, documentação) ou codificação manual quando a tarefa envolve estruturas complexas ou desconhecidas, evitando a "armadilha" de confiar cegamente na IA para partes críticas do sistema.

Em resumo, o artigo conclui que a integração eficaz de LLMs na engenharia de software não depende apenas da qualidade do código gerado, mas da capacidade do sistema de manter a coerência, o contexto e a confiança do usuário ao longo de interações longas e complexas.