Skills para agentes de código fazem diferença?

Disclaimer

Este texto foi inicialmente concebido pela IA Generativa em função da transcrição de um vídeo do canal Dev Mais Eficiente. Se preferir acompanhar por vídeo, é só dar o play.

Introdução

Existe uma discussão recorrente sobre o quanto configurar skills (no Claude Code), rules (no Cursor) ou arquivos semelhantes realmente melhora o resultado dos agentes de código. Para tentar responder isso com dados, um estudo chamado SkillBench montou um benchmark com 84 tarefas de domínios variados e testou múltiplos modelos em três cenários: sem skill nenhuma, com skills geradas pelo próprio agente e com skills escritas com participação humana.

Neste post, vamos analisar os principais achados do estudo, incluindo dados do apêndice sobre taxa de falha dos modelos que costumam passar despercebidos nas discussões.

O achado principal: skills escritas por humanos fazem diferença

O gráfico central do estudo compara a taxa de resolução de tarefas em três condições: sem skill, com skill auto-gerada pelo agente e com skill escrita em conjunto com um ser humano que domina o assunto.

O resultado mais relevante: skills escritas com participação humana consistentemente melhoram a taxa de resolução em relação às outras duas condições. Os modelos testados incluem Haiku 4.5, Sonnet 4.5, Opus 4.5, Gemini 3 Pro, GPT 5.2, Opus 4.6 e Gemini 3 Flash, e o padrão se repete em praticamente todos.

Já as skills geradas pelo próprio agente tiveram efeito quase nulo comparadas a trabalhar sem skill nenhuma. Em alguns casos, como GPT 5.2 e Sonnet 4.5, o agente sem skill teve resultado levemente melhor do que com skill auto-gerada.

Isso reforça algo que segue sendo verdade: o nível de expertise de quem direciona o agente continua fazendo diferença significativa.

Como o estudo foi montado

O repositório do SkillBench contém 84 tarefas de naturezas diversas. Cada tarefa tem a instrução para o agente, metadados, timeout, testes automatizados para verificar o output e uma proposta de solução determinística.

A execução funcionava assim: subia uma imagem Docker com o agente instalado (Claude Code, Codex, Gemini CLI), configurava com ou sem skill, apontava para a pasta com as instruções e deixava o agente trabalhar. Depois verificava o resultado contra os testes.

A variação por domínio e o que ela revela

O estudo traz uma tabela com a taxa de resolução por domínio. Alguns números:

• Saúde: 86% com skill, 34% sem skill
• Engenharia de software: 38,9% com skill, 34,4% sem skill

A diferença entre esses dois domínios é reveladora, mas precisa de contexto. Primeiro, o volume de tarefas era diferente: saúde tinha poucas tarefas, engenharia de software tinha mais de vinte. Segundo, e talvez mais importante, os modelos são muito mais bem treinados para engenharia de software do que para domínios como saúde.

Isso leva a uma conclusão prática: quanto menos treinado o modelo é para um domínio específico, maior o gap que o conhecimento humano precisa preencher. Em domínios onde o modelo já tem bastante conhecimento nos dados de treino, a diferença que uma skill faz tende a ser menor.

O esforço de setup pode não compensar

Existe uma tendência a montar setups elaborados para trabalhar com agentes de código: engenharia de contexto detalhada, troca de modelos por tipo de tarefa, controle granular de consumo de tokens. O estudo sugere que, pelo menos para tarefas mais padronizadas, esse esforço pode gerar diferença marginal.

Se a tarefa é de conhecimento relativamente público e o modelo já é bem treinado naquele domínio, a diferença entre um setup sofisticado e um prompt direto pode ser pequena. Isso não significa que skills são inúteis, mas que vale avaliar se o esforço de configuração está gerando retorno proporcional.

Para práticas de engenharia de software que são bastante padronizadas (separação de controllers e casos de uso, cálculos comuns, estilo funcional com imutabilidade), o modelo provavelmente já consegue operar bem sem instruções adicionais. A skill faz mais diferença quando o domínio é específico e não tão bem representado nos dados de treino.

A taxa de falha que ninguém comenta

O apêndice do estudo traz uma tabela com as tentativas e taxas de falha de cada modelo. Alguns números:

• Opus 4.6: 1.245 tentativas, 67,1% de falha
• Gemini 3 Pro: 61% de falha
• Haiku e Sonnet: acima de 80% de falha

Esses números consideram todas as condições (com skill auto-gerada, com skill humana, sem skill). A maioria das tentativas falhou, mesmo em tarefas que envolvem conhecimento de domínio público.

Isso tem uma implicação direta para o fluxo de trabalho do dia a dia. Se a taxa de falha é essa em tarefas padronizadas, imagine dentro do contexto de negócio específico da sua empresa, com domínio que não é público e conexões que o modelo não tem como inferir. A taxa de falha provavelmente seria ainda maior.

Na prática, isso significa que o ciclo de gerar, revisar, direcionar e gerar novamente continua sendo o fluxo normal. Quanto mais aberta e ambígua a tarefa, maior a chance do modelo produzir algo diferente do esperado. A participação humana no direcionamento segue sendo importante para reduzir esse ciclo.

Analogia com VMs e otimização prematura

Uma maneira útil de pensar sobre isso é a analogia com máquinas virtuais. A JVM, por exemplo, faz otimizações sofisticadas em runtime. Na maioria dos casos, tentar micro-otimizar manualmente sem dados concretos pode até atrapalhar o trabalho da VM.

Com agentes de código pode estar acontecendo algo parecido. Em algum momento, tentar ajustar finamente o comportamento do agente com muitas regras e configurações pode ser contra-produtivo. Para a maioria das tarefas, apostar no comportamento padrão do modelo e iterar a partir do resultado pode ser mais eficiente do que montar um setup elaborado antes de começar.

Quando você tem dados concretos de que um ajuste específico faz diferença no seu contexto, aí sim vale configurar. Mas sem essa evidência, o default tende a funcionar razoavelmente bem.

Conclusão

O SkillBench traz dados úteis para calibrar expectativas. Skills escritas com participação de quem domina o assunto fazem diferença mensurável. Skills auto-geradas pelo agente praticamente não ajudam. A taxa de falha dos modelos ainda é alta mesmo em tarefas padronizadas, o que reforça que o direcionamento humano continua sendo parte essencial do fluxo.

Para quem trabalha com agentes de código no dia a dia, o ponto prático é: invista seu tempo no que você sabe sobre o problema, não na engenharia de contexto genérica. O conhecimento de domínio que você traz para a skill é o que faz a diferença, não a sofisticação do setup.

Dev + Eficiente

Desenvolva software de alta qualidade e domine Engenharia de IA com o Dev + Eficiente. Cursos práticos, acesso vitalício, comunidade ativa e acesso a vagas remotas exclusivas em diversas empresas de tecnologia. Sua jornada para se tornar um dev mais eficiente pode começar agora.