Uma das melhores partes dos nossos modelos mais recentes do Claude é 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 dele, 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 do próprio julgamento ele aplica.
O esforço extra trouxe resultados melhores em áreas onde verificação e testes de casos extremos são mais úteis, como hardware, revisão de código e segurança.
Mas os níveis baixo e médio foram perfeitos para resolver as coisas rapidamente e me manter no controle junto com o Claude.
Para engenharia de software no dia a dia, agora uso um ciclo: peço para o modelo me entrevistar, depois implemento com esforço baixo/médio, reviso o que foi construído e, por fim, rodo a verificação com esforço alto.
O que é esforço?
Em termos gerais, 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 percepção sobre a dificuldade do trabalho.
Pense assim: se alguém pedisse para você trabalhar 12 horas seguidas em algo, você provavelmente assumiria que querem apenas que você faça aquilo e dê o seu máximo. Se pedissem a mesma tarefa em 1 hora, você tentaria entregar a melhor versão possível dentro do prazo e esperaria iterar a partir dali.
Ou talvez você contestasse e dissesse que a tarefa exige pelo menos 3 horas, trabalhando esse tempo 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 faz com que ele tome mais atitudes independentes 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 que já tivemos: 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 faria. Fiz isso em uma grande variedade de atividades, mas vou ilustrar aqui 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, 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 bem parecido com o 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 bem 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 venho usando para desenvolver funcionalidades é:
- 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, iterando 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
Mas esses são, obviamente, exemplos simples, que o Claude consegue completar tranquilamente. E 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 bastante: 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 pessoa 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 bem mais complicadas do que a média dos desafios que encontro 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 incorporaçã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 das estatísticas comerciais mensais 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 passou 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 só vez e depois o testou contra uma única página escrita manualmente.
Já uma execução com esforço alto termina em cerca de 33 minutos. Na rodada que acompanhei, o modelo fez uma revisão adversarial do 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 para ser minucioso também faz sentido em 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 tudo.
O diagrama abaixo mostra todos os resultados do Terminal-Bench 3.0 e como falharam, em diferentes modelos e níveis de esforço. De modo geral, aumentar o esforço tende a reduzir falhas causadas por casos extremos ignorados (blocos roxos), mas não resolve quando 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 no mecanismo de armazenamento a partir de seu 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 de rodar o reprodutor, e não verificava se o novo teste teria capturado o bug original.
No xhigh (cerca de 11 minutos), o Claude reproduziu a falha primeiro, 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 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 casos maiores, encontrou situações 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 gênicos (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 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 participando do processo, o Claude poderia tê-lo consultado sobre 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 sobre quando usar cada nível de esforço:
- Baixo: para quando quero respostas rápidas mantendo o controle do processo, ex.: brainstorming, esboços, mudanças simples.
- Médio: para a maior parte do meu trabalho regular de engenharia de software, ex.: implementação de novas funcionalidades.
- Alto: para trabalhos onde a verificação é importante ou existem casos extremos, ex.: corrigir um bug em uma base de código legado (brownfield).
- Máximo: quando quero que o Claude opere de forma totalmente autônoma para resolver problemas difíceis, ex.: construção e verificação de ponta a ponta de um app, busca por 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 conte se isso bate com a sua intuição.
