Uma das melhores partes dos nossos modelos Claude mais recentes é como eles respondem ao esforço sem quebrar o cache de prompt no Claude Code, mas recebi muitas dúvidas dos usuários sobre isso. O que realmente é o esforço e quando usar cada nível? Por que precisamos de esforço, afinal?
Para responder a isso, decidi mergulhar fundo nas avaliações (evals) e fazer meus próprios testes de esforço em tarefas do dia a dia.
nota: você pode ver diagramas interativos e explicações adicionais sobre este post em https://claude.dev/blog/spending-your-effort/
De forma geral, descobri que o esforço é uma ótima maneira de controlar quanto o Claude verifica e testa casos extremos, além de definir quanto ele confia no próprio julgamento.
O esforço extra trouxe resultados melhores em áreas onde a verificação e os testes de casos extremos são mais úteis, como hardware, revisão de código e segurança.
Mas o esforço baixo e médio foi perfeito para resolver as coisas rapidamente e manter o controle do processo junto com o Claude.
Para engenharia de software no dia a dia, agora sigo um ciclo: peço para o modelo me entrevistar, depois implemento com esforço baixo/médio, reviso o que ele construiu e, por fim, rodo a verificação com esforço alto.
O que é esforço?
Em resumo, o esforço dá ao modelo uma estimativa de quanto poder computacional você quer que ele gaste na tarefa. Isso tem relação com a sua própria percepção da dificuldade do trabalho.
Pense assim: se alguém pedisse para você trabalhar 12 horas seguidas em algo, você provavelmente assumiria que a pessoa só quer que aquilo seja feito, custe o que custar. Mas se te dessem 1 hora para a mesma tarefa, você tentaria entregar a melhor versão possível dentro desse prazo e esperaria iterar a partir dali.
Ou talvez você contestasse, dizendo que a tarefa exige pelo menos 3 horas, e trabalhasse essas 3 horas para entregá-la.
Você deve pensar no esforço da mesma forma. O Claude sempre vai tentar realizar sua tarefa de maneira adequada, mas um esforço maior significa que ele tomará mais iniciativas próprias para julgar e verificar o resultado.
Curvas de esforço
As curvas de esforço do Fable 5.1 e do Opus 5.5 são as melhores até agora; em cada nível, há um aumento nas pontuações dos benchmarks e nos tokens consumidos. Abaixo está um gráfico das pontuações do Terminal Bench 3.0 por nível de esforço, medido durante minhas rodadas de avaliação para este post.
Mas o que isso significa na prática? Para avaliar isso, testei várias tarefas em diferentes níveis de esforço e analisei minuciosamente os benchmarks.
Construindo com esforço
A melhor forma de entender como os modelos funcionam é fazendo experimentos. Tentei executar as mesmas tarefas em vários níveis de esforço no Opus 5.5 para entender o tipo de trabalho que ele realizaria. Fiz isso em uma grande variedade de atividades, mas vou ilustrar com alguns exemplos simples.
Tarefa de construção pouco especificada
Se eu pedir ao Claude para "criar um aplicativo pessoal de monitoramento de condicionamento físico e treinos", o esforço muda drasticamente o quão completo o app fica, e também faz com que o Claude tome mais decisões ao longo do caminho. Com esforço baixo, o app de fitness é apenas um registro e um gráfico simples. Em níveis mais altos, o app fica mais complexo e detalhado. No esforço máximo, surge até um mapa de calor.
Se eu quisesse uma base simples para iterar depois, o esforço baixo daria conta do recado. O esforço máximo seria ideal se eu quisesse a melhor tentativa única do Claude.
Tarefa de design levemente especificada
E se eu tiver uma tarefa já bem definida, mas quiser explorar algumas ideias com o Claude? Como exemplo, pedi para ele redesenhar o menu /config no Claude Code. Todas as passadas tiveram basicamente a mesma ideia: usar submenus e melhorar a busca.
Com esforço baixo (que levou 1 minuto), recebi um esboço interativo que transmitia a ideia, mas não parecia muito com o Claude Code.
Com esforço máximo (que levou 28 minutos), recebi um mockup com a cara do Claude Code, junto com vários tutoriais passo a passo para diferentes fluxos.
Se meu objetivo fosse iterar e dar feedback, o esforço baixo chegaria lá muito mais rápido. Mas o esforço máximo me entrega algo muito mais polido logo de cara. Para essa tarefa específica, acho que prefiro usar o esforço baixo para entender a visão do Claude.
Tarefa de construção altamente especificada
E se eu der muitos detalhes ao Claude? Tentei pedir para ele me entrevistar a fundo sobre o app de fitness e, em seguida, passei essa especificação para ser implementada por diferentes modelos em diferentes níveis de esforço.
Descobri que, com essa especificação, os modelos se comportaram de forma muito mais parecida. Recebi designs bastante semelhantes e com implementações equivalentes, mas com detalhes diferentes; no esforço máximo, o Claude dedicou um tempo para simplificar alguns desses detalhes.
Principais conclusões
Na engenharia de software comum, especialmente no desenvolvimento de novas funcionalidades, o nível de esforço depende muito de quanto eu quero participar do processo. O esforço baixo permite que o Claude responda rapidamente com um ponto de partida; níveis mais altos entregam mais trabalho pronto, mas o Claude também fará mais suposições por mim.
Um ciclo particularmente produtivo que tenho usado para desenvolver recursos é:
- Dar uma especificação ao Claude e pedir para ele me entrevistar sobre qualquer detalhe que esteja faltando
- Implementar com esforço baixo
- Revisar para garantir que ele entendeu a essência corretamente e iterar com esforço baixo conforme necessário
- Verificar e testar com esforço alto
Como os níveis de esforço impactam o resultado em tarefas difíceis
Claro que esses são exemplos simples, que o Claude resolve com facilidade. Mas o que acontece quando a diferença está entre o modelo concluir ou não a tarefa?
Para encontrar esses problemas difíceis, é preciso recorrer aos benchmarks, então mergulhei em um que gosto muito: o Terminal Bench 3, um benchmark criado pela comunidade.
Os problemas do Terminal-Bench 3.0 podem ser divididos em categorias como segurança, hardware, ML, ciência, software, operações e mídia. Você pode ver todos os problemas aqui: https://github.com/harbor-framework/terminal-bench/releases/tag/v3.0.0. Eles vêm da comunidade, então qualquer um pode contribuir.
Vale a pena ler para ter uma ideia do tipo de problema que esses modelos enfrentam. Fiquei surpreso com o escopo e a ambição de muitas dessas tarefas. Elas são muito mais complicadas do que a média dos desafios que enfrento no dia a dia.
Por exemplo, algumas das tarefas incluíam:
- Hardware (retro-console-soc): construir um console de jogos de 8 bits em Verilog que caiba em um FPGA pequeno e renderize uma ROM de teste.
- Ciência (takens-embedding-lean): provar formalmente o teorema de imersão de Takens no Lean 4.
- ML (mp-checkpoint-consolidation): mesclar 16 fragmentos de um checkpoint mixture-of-experts em um único arquivo que reproduza os logits de referência.
- Operações (intrastat-meldung): executar de ponta a ponta o envio mensal de estatísticas comerciais da UE de uma empresa.
- Mídia (layout-config-recreation): reconstruir a imagem de um pôster como um arquivo de layout editável.
Níveis de esforço mais altos ajudam quando há muitos casos extremos
Minha principal conclusão ao analisar os resultados do Terminal Bench 3 foi que um esforço maior é ideal para tarefas com muitos casos extremos ocultos.
Um exemplo claro é o html-js-filter, uma tarefa do Terminal-Bench 3.0 que pede um sanitizador HTML capaz de bloquear todas as formas de injetar JavaScript em uma página. O Fable 5.1 saltou de 1/5 no esforço baixo para 5/5 no xhigh.
Uma tentativa típica com esforço baixo leva cerca de 2 minutos. Cada uma dessas tentativas escreveu um filtro praticamente de uma vez e depois o testou contra uma única página escrita manualmente.
Já uma rodada com esforço alto termina em cerca de 33 minutos. Na execução que acompanhei, o modelo fez uma revisão adversarial do seu primeiro rascunho, leu o código-fonte do parser instalado para procurar bugs, rodou vários casos de teste limpos até obterem a mesma saída que a entrada, executou uma suíte padrão de testes XSS e, por fim, criou um fuzzer de documentos aleatórios.
Para algo tão cheio de casos extremos quanto um sanitizador HTML, esse esforço extra vale muito a pena. Gastar mais tokens em prol do rigor também faz sentido para tarefas complexas com altas exigências de produção, como otimização de desempenho ou revisão de segurança.
Mas você não precisa desse nível de esforço para todas as tarefas.
O diagrama abaixo mostra todos os resultados do Terminal-Bench 3.0 e como eles falharam, em diferentes modelos e níveis de esforço. De modo geral, aumentar o esforço tende a reduzir as falhas causadas por casos extremos ignorados (blocos roxos), mas não corrige situações em que o modelo adota a abordagem errada (blocos azuis).
Áreas problemáticas onde o esforço ajuda
Uma das conclusões mais interessantes para mim ao avaliar esses modelos no TerminalBench foi que algumas áreas se beneficiaram do esforço muito mais do que outras. Você pode ver o detalhamento no diagrama a seguir:
Para ilustrar isso, escolhi alguns problemas de diferentes áreas do Terminal Bench 3.0 em que o Opus 5.5 falhou com esforço baixo, mas teve sucesso com esforço alto — principalmente porque testou e considerou os casos extremos:
mvcc-lsm-compaction: uma tarefa do Terminal-Bench 3.0 que pede a correção de um bug em um motor de armazenamento a partir do relatório de falha, sem quebrar a compactação. O Opus 5.5 passou de 0/5 no esforço baixo para 4/5 no xhigh.
No esforço baixo (cerca de um minuto por tentativa), o Claude editava o código antes de compilá-lo ou rodar o reprodutor, e não verificava se seu novo teste teria capturado o bug original.
No xhigh (cerca de 11 minutos), o Claude primeiro reproduziu a falha, escreveu um teste aleatorizado comparando com uma referência que nunca compacta e verificou se seus testes falhavam em correções incompletas.
cli-2ph-simple: é uma tarefa do Terminal-Bench 3.0 que pede um resolvedor de programação linear via CLI escrito em Python. O Opus 5.5 passou de 0/5 no esforço baixo para 5/5 no esforço alto.
As tentativas com esforço baixo escreveram um resolvedor de uma só vez, testaram com alguns problemas pequenos e pararam por volta dos 10 mil tokens. Na mensagem final, o Claude avisou que poderia ser lento em problemas grandes, mas não chegou a verificar.
Durante as tentativas com esforço alto, o Claude testou seu resolvedor em problemas aleatórios comparando com outro resolvedor de força bruta, cronometrou problemas maiores, encontrou casos que demoravam demais ou travavam e refez sua lógica de busca.
gsea-proteomics: uma tarefa do Terminal-Bench 3.0 que pede uma análise de enriquecimento de conjuntos de genes (GSEA) em dados proteômicos para descobrir quais de oito tratamentos se assemelham a um tecido-alvo. O Opus 5.5 passou de 0/5 no esforço baixo para 4/5 no esforço alto.
Com esforço baixo, o Claude escolheu uma forma razoável de preparar os dados, rodou a análise daquele jeito e relatou o resultado.
Com esforço alto, o Claude tentou duas formas de preparar os dados, percebeu que a lista de tratamentos significativos mudava e investigou o motivo antes de escolher a opção correta.
Se houvesse um usuário acompanhando o processo, o Claude talvez tivesse perguntado como configurar o problema, mas sem essa interação, o esforço alto se sai melhor.
Quando usar cada nível de esforço no Claude Code
Aqui vai minha regra prática de quando usar cada nível de esforço:
- Baixo (Low): para quando quero respostas rápidas mantendo o controle do processo, ex.: brainstorming, esboços, alterações simples.
- Médio (Medium): para a maior parte do meu trabalho regular de engenharia de software, ex.: implementação de novas funcionalidades.
- Alto (High): para trabalhos onde a verificação é importante ou existem casos extremos, ex.: corrigir um bug em um código legado (brownfield).
- Máximo (Max): quando quero que o Claude opere de forma totalmente autônoma para resolver problemas difíceis, ex.: construir e verificar um app de ponta a ponta, encontrar vulnerabilidades de segurança em softwares críticos.
Experimente variar o esforço para o Opus 5.5 e o Fable 5.1 de acordo com a sua tarefa, ou até mesmo no meio de uma conversa, usando o comando /effort no Claude Code, e me diga se isso bate com a sua intuição.
