Instruction Stacking Collapse: A Benchmark and the Capability-Dependent Value of Prompt Compilation
Este artigo apresenta um benchmark demonstrando que o desempenho de seguimento de instruções em grandes modelos de linguagem degrada-se não linearmente à medida que as restrições se acumulam devido a conflitos de pares, e mostra que um compilador de prompts livre de treinamento mitiga efetivamente este problema para modelos mais fracos, enquanto deixa modelos mais fortes amplamente inalterados.
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 dar um conjunto de instruções a um assistente robô muito inteligente, mas um pouco literal. Você sabe que, se pedir para ele fazer uma coisa, como "escrever uma história", ele provavelmente fará um ótimo trabalho. Mas o que acontece se você acumular vinte regras diferentes de uma vez? "Use exatamente 50 palavras", "formate como um arquivo JSON", "inclua três citações", "não use a letra 'e'", "comece com um resumo" e "faça parecer um pirata". Este é o mundo dos Modelos de Linguagem de Grande Escala (LLMs). Eles são os cérebros de IA por trás de muitos chatbots e ferramentas que usamos hoje. Eles são treinados para seguir comandos humanos, mas não são perfeitos. Cientistas há muito tempo sabem que, quando você lhes dá regras demais, eles começam a errar. Mas ninguém realmente sabia o quão mal eles falhariam, quais regras entravam em conflito entre si ou se havia uma maneira de consertar isso sem ter que treinar o cérebro do robô do zero. Este artigo mergulha nessa pilha bagunçada de regras para ver exatamente onde o robô se confunde e como podemos ajudá-lo a organizar as coisas.
O Colapso do Empilhamento de Instruções
Pense em dar uma instrução a uma IA como entregar um cartão de receita a um chef. Se o cartão diz "Faça um sanduíche", o chef fica feliz. Mas imagine se o cartão de repente tivesse um post-it colado por cima dizendo "Use apenas ingredientes vermelhos", outro dizendo "Não é permitido usar pão", um terceiro dizendo "Deve ser servido em uma tigela azul" e um quarto gritando "Não use as mãos!". Se você empilhar vinte desses post-its conflitantes sobre a receita, o chef não fica apenas confuso; ele frequentemente desiste de metade das regras. Ele pode fazer um sanduíche, mas esquece os ingredientes vermelhos. Ele pode usar a tigela azul, mas ignora a regra do "sem pão". E a parte assustadora? O chef não avisa que falhou. Ele apenas serve um sanduíche estranho e diz: "Aqui está".
Este artigo, intitulado "Instruction Stacking Collapse" (Colapso do Empilhamento de Instruções), é um mergulho profundo em como isso acontece exatamente. Os pesquisadores construíram um grande parquinho onde testaram o quão bem três modelos de IA de alto nível (Claude Sonnet 4.6, GPT-5-mini e Gemini 2.5 Flash) conseguiam lidar com uma pilha crescente de instruções. Eles começaram com apenas uma regra e foram adicionando mais, até chegar a vinte regras de uma vez.
O Crash: Quando as Regras Lutam Entre Si
Os resultados foram dramáticos. Quando a IA tinha apenas uma instrução para seguir, ela era uma superestrela, acertando cerca de 96% das vezes. Mas conforme a pilha de regras crescia para vinte, o desempenho desabava.
- O modelo mais forte (Claude Sonnet) caiu para cerca de 60% de sucesso.
- O modelo intermediário (Gemini) caiu para 43%.
- O modelo mais fraco (GPT-5-mini) atingiu um muro, conseguindo realizar apenas 20% das instruções corretamente.
Não foi um declínio lento e monótono. Foi um "colapso". Os pesquisadores descobriram que as regras não estavam apenas se perdendo; elas estavam ativamente lutando umas contra as outras. Eles descobriram um "mapa de conflitos". Por exemplo, se você disser à IA para "gerar um JSON válido" (um formato de código de computador específico) e também disser para "usar cabeçalhos markdown" (como ##Título), a IA fica travada. Ela não consegue fazer as duas coisas. Se escolher JSON, ela quebra silenciosamente a regra do markdown. Se escolher markdown, ela quebra a regra do JSON. O artigo descobriu que a instrução "gerar JSON" era a maior causadora de problemas, gerando conflitos com nove outras regras comuns.
A Solução Mágica: O Compilador de Instruções
Então, a solução é apenas dar menos regras à IA? Não necessariamente. Os pesquisadores perguntaram: "Podemos consertar o prompt antes que a IA o veja, sem ensinar nada novo à IA?"
Eles inventaram uma ferramenta chamada Compilador de Instruções. Pense neste compilador como um assistente super organizado que olha para sua pilha bagunçada de vinte post-its antes de você entregá-los ao chef. O compilador faz três coisas:
- Agrupa: Ele coloca todas as regras de "formato" juntas e todas as regras de "extensão" juntas.
- Mescla: Se duas regras dizem a mesma coisa, ele as combina em uma única frase clara.
- Prioriza: Se duas regras conflitam (como "usar JSON" vs. "usar markdown"), o compilador adiciona uma nota dizendo: "Ei, se estas duas entrarem em conflito, faça a do JSON primeiro".
Este compilador roda uma vez, cria um checklist limpo e organizado, e então esse mesmo checklist é usado para cada pergunta que a IA responde. É como dar ao chef um único cartão de receita perfeitamente escrito em vez de uma pilha de notas bagunçadas.
A Surpresa: Quem é Ajudado?
Aqui está a parte mais interessante da história. Os pesquisadores esperavam que este "cartão de receita limpo" ajudasse a todos igualmente. Mas não ajudou. O benefício dependia inteiramente de quão "inteligente" era o chef (o modelo de IA).
- Para os modelos mais fracos (como o GPT-5-mini): O compilador foi um salvador. Ele aumentou a taxa de sucesso em +11 pontos percentuais. Transformou um modelo que falhava 80% das vezes em um que falhava apenas 69% das vezes. Isso é enorme porque esses modelos mais fracos são os mais usados no mundo real, pois são mais rápidos e baratos.
- Para os modelos mais fortes (como o Claude Sonnet): O compilador quase não fez nada. Na verdade, ele prejudicou levemente o desempenho (em cerca de -1,2 pontos).
Por quê? O artigo sugere que os modelos mais fortes são tão inteligentes que já conseguem olhar para uma pilha bagunçada de vinte regras e entender a estrutura, os conflitos e as prioridades por conta própria. Eles não precisam que o compilador organize as notas para eles; na verdade, as notas extras apenas poluem seu raciocínio. Já os modelos mais fracos ficam sobrecarregados pelo caos. Eles precisam do compilador para agir como um tradutor, transformando o caos em um plano claro e passo a passo.
O Que Isso Significa Para Você
Esta pesquisa nos diz duas grandes coisas. Primeiro, quando pedimos tarefas complexas à IA com muitas regras, não podemos simplesmente jogar um muro de texto nela e esperar que funcione. As regras entrarão em colapso e a IA falhará silenciosamente. Segundo, não precisamos construir robôs maiores e mais inteligentes para consertar isso. Às vezes, a solução é apenas uma melhor organização.
O artigo prova que uma ferramenta simples e gratuita que reorganiza as instruções pode resgatar modelos de IA mais fracos, tornando-os muito mais confiáveis para as tarefas que usamos todos os dias. É um lembrete de que, no mundo da IA, às vezes a coisa mais inteligente que você pode fazer não é tornar o robô mais inteligente, mas sim tornar as instruções mais claras. E para os robôs superinteligentes? Eles podem preferir resolver tudo por conta própria.
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.