<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Tiago Vilas Boas (Montanha)</title>
    <description>The latest articles on DEV Community by Tiago Vilas Boas (Montanha) (@tiagovilasboas).</description>
    <link>https://dev.to/tiagovilasboas</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F469157%2F1a0f67ff-0b7e-401f-a797-a19b71695fc2.png</url>
      <title>DEV Community: Tiago Vilas Boas (Montanha)</title>
      <link>https://dev.to/tiagovilasboas</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/tiagovilasboas"/>
    <language>en</language>
    <item>
      <title>Como os melhores devs usam o Claude Code além do prompt</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Fri, 13 Nov 2026 12:00:00 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/como-os-melhores-devs-usam-o-claude-code-alem-do-prompt-1m62</link>
      <guid>https://dev.to/tiagovilasboas/como-os-melhores-devs-usam-o-claude-code-alem-do-prompt-1m62</guid>
      <description>&lt;p&gt;Quando estava construindo o &lt;a href="https://github.com/tiagovilasboas/downshift-ai" rel="noopener noreferrer"&gt;Downshift&lt;/a&gt;, precisei entender melhor como o Claude Code gastava contexto e escolhia os modelos dos subagentes. Eu vinha de uma dor bem concreta: pagava o plano Pro e, em poucos dias de trabalho, já tinha esgotado o limite semanal. Queria entender o que estava consumindo tanto e onde fazia sentido otimizar.&lt;/p&gt;

&lt;p&gt;É como trabalhar com outro dev: passar a tarefa é só o começo. A gente também combina os limites, divide o que pode andar em paralelo e confere se a entrega atende ao que foi pedido. Com agentes, precisamos ainda decidir qual modelo usar, quanto esforço dedicar e o que vale carregar na conversa.&lt;/p&gt;

&lt;p&gt;A decisão que vale levar para o próximo projeto é esta: &lt;strong&gt;escolher capacidade conforme o problema e dar ao agente uma forma concreta de verificar a entrega&lt;/strong&gt;. Vamos aplicar isso a uma correção de API, com comandos e configurações que você pode adaptar.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Escolha modelo e esforço antes de aumentar o prompt
&lt;/h2&gt;

&lt;p&gt;Imagine que &lt;code&gt;POST /pedidos&lt;/code&gt; recebe &lt;code&gt;{"quantidade": -1}&lt;/code&gt; e retorna &lt;code&gt;201 Created&lt;/code&gt;. Neste &lt;strong&gt;exemplo didático&lt;/strong&gt;, o contrato exige quantidade positiva e prevê &lt;code&gt;400 Bad Request&lt;/code&gt; para esse caso. Precisamos corrigir a validação e manter a criação de pedidos válidos funcionando.&lt;/p&gt;

&lt;p&gt;Para começar, confira três coisas diferentes:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Configuração&lt;/th&gt;
&lt;th&gt;O que significa&lt;/th&gt;
&lt;th&gt;Como conferir&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Versão do Claude Code&lt;/td&gt;
&lt;td&gt;O programa instalado e os recursos disponíveis&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;claude --version&lt;/code&gt; no terminal&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Modelo&lt;/td&gt;
&lt;td&gt;Quem recebe e resolve a tarefa&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;/model&lt;/code&gt; na sessão&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Effort&lt;/td&gt;
&lt;td&gt;O esforço solicitado para raciocinar e executar&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;/effort status&lt;/code&gt; na sessão&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;O material que inspirou este artigo destaca uma mudança específica: &lt;strong&gt;Opus 5.5 em &lt;code&gt;medium&lt;/code&gt; iguala ou supera Opus 5 em &lt;code&gt;high&lt;/code&gt; nas avaliações de código e trabalho de conhecimento da Anthropic&lt;/strong&gt;. Carregar a configuração antiga para a versão nova pode deixar de ser uma boa escolha. Isso não é um benchmark do nosso projeto. &lt;a href="https://code.claude.com/docs/en/model-config#choose-an-effort-level" rel="noopener noreferrer"&gt;Fonte: configuração de modelos e esforço&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Na documentação consultada em &lt;strong&gt;12/11/2026&lt;/strong&gt;, &lt;code&gt;opus&lt;/code&gt;, &lt;code&gt;sonnet&lt;/code&gt; e &lt;code&gt;haiku&lt;/code&gt; resolvem para a família 5.5 na API da Anthropic. Outros provedores podem usar versões anteriores. Opus 5.5 exige Claude Code v2.1.280+, Sonnet 5.5 v2.1.284+ e Haiku 5.5 v2.1.293+. Para repetir uma comparação, registre o ID completo. &lt;a href="https://code.claude.com/docs/en/model-config#model-aliases" rel="noopener noreferrer"&gt;Tabela por provedor&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Modelo e effort não são a mesma alavanca.&lt;/strong&gt; O modelo define a capacidade; o esforço influencia quanto trabalho ele dedica ao turno, incluindo investigação e verificação. Mais esforço pode gerar mais tokens e espera. Não define um teto fixo de gasto. &lt;a href="https://claude.com/resources/articles/claude-model-and-effort-level-in-claude-code" rel="noopener noreferrer"&gt;Explicação da Anthropic&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Na API do exemplo, eu usaria esta referência inicial, como hipótese para testar:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Situação&lt;/th&gt;
&lt;th&gt;Combinação inicial&lt;/th&gt;
&lt;th&gt;Motivo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Extrair campos e localizar consumidores conhecidos&lt;/td&gt;
&lt;td&gt;Haiku 5.5, &lt;code&gt;medium&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Pesquisa delimitada, com retorno fácil de conferir&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Corrigir validação com teste reproduzível&lt;/td&gt;
&lt;td&gt;Sonnet 5.5, &lt;code&gt;medium&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Implementação com escopo e aceite claros&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Investigar regressão com hipóteses concorrentes&lt;/td&gt;
&lt;td&gt;Opus 5.5, &lt;code&gt;medium&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Diagnóstico exige cruzar evidências&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Diagnóstico continua inconclusivo&lt;/td&gt;
&lt;td&gt;Comparar Opus 5.5 em &lt;code&gt;medium&lt;/code&gt; e &lt;code&gt;high&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Verificar se aprofundar melhora a solução&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Na prática:&lt;/strong&gt; se o teste já mostra que falta uma validação, Sonnet em &lt;code&gt;medium&lt;/code&gt; é meu ponto de partida. Se o erro só aparece com duas requisições simultâneas, preciso investigar concorrência: aí testaria Opus, começando em &lt;code&gt;medium&lt;/code&gt;. A incerteza da tarefa orienta a escolha.&lt;/p&gt;

&lt;p&gt;Subir para &lt;code&gt;high&lt;/code&gt; ou &lt;code&gt;max&lt;/code&gt; por hábito também tem efeito colateral: em tarefas delimitadas, esforço excessivo aumenta o tempo de raciocínio (&lt;em&gt;overthinking&lt;/em&gt;) e leva o agente a inventar abstrações que você não pediu. Para rotinas recorrentes, vale calibrar o menor par (&lt;code&gt;model&lt;/code&gt; × &lt;code&gt;effort&lt;/code&gt;) que passa nos testes do repositório. O mesmo ceticismo se aplica a benchmarks de lançamento publicados pelos próprios laboratórios: agregadores independentes como o &lt;a href="https://epoch.ai/benchmarks/eci" rel="noopener noreferrer"&gt;Epoch Capabilities Index (ECI)&lt;/a&gt; ajudam como triagem inicial entre modelos, mas não substituem a medição nos seus próprios casos de falha.&lt;/p&gt;

&lt;p&gt;Para abrir a sessão de implementação no terminal:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;claude --model claude-sonnet-5-5 --effort medium
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A escala da família 5.5 inclui &lt;code&gt;low&lt;/code&gt;, &lt;code&gt;medium&lt;/code&gt;, &lt;code&gt;high&lt;/code&gt;, &lt;code&gt;xhigh&lt;/code&gt; e &lt;code&gt;max&lt;/code&gt;. Comece no padrão e aumente quando houver uma lacuna concreta na investigação. Para mudar, use &lt;code&gt;/effort high&lt;/code&gt;; a seleção direta salva a preferência para o modelo. A variável &lt;code&gt;CLAUDE_CODE_EFFORT_LEVEL&lt;/code&gt; pode prevalecer e políticas da organização podem limitar o nível. &lt;a href="https://code.claude.com/docs/en/model-config#adjust-effort-level" rel="noopener noreferrer"&gt;Níveis e precedência&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Um detalhe de versão: no Claude Code &lt;strong&gt;v2.1.311+&lt;/strong&gt;, &lt;code&gt;ultrathink&lt;/code&gt; tem tratamento específico e pode elevar aquele turno a &lt;code&gt;xhigh&lt;/code&gt; nos casos suportados. &lt;code&gt;think&lt;/code&gt; e &lt;code&gt;think hard&lt;/code&gt; são texto comum. A afirmação de que todas essas palavras perderam efeito ficou desatualizada. &lt;a href="https://code.claude.com/docs/en/model-config#use-ultrathink-for-one-off-deep-reasoning" rel="noopener noreferrer"&gt;Semântica atual&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Dê um contrato de trabalho e um mapa curto
&lt;/h2&gt;

&lt;p&gt;Em vez de começar com “analise profundamente e siga todas as boas práticas”, descreva o comportamento que precisa mudar:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Tarefa: POST /pedidos aceita quantidade -1 e retorna 201.
O contrato prevê 400 para quantidade não positiva; corrija a validação.
Primeiro, escreva um teste que reproduza a falha.

Limites: preserve os campos e os status previstos no contrato.
Pedidos válidos devem continuar retornando 201.
Não altere o esquema do banco.

Pronto: o teste falha antes da correção e passa depois;
as verificações relevantes passam e o diff pode ser revisado.
Se faltar informação sobre o contrato, apresente a dúvida antes de alterá-lo.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Isso dá ao agente uma tarefa executável e permite ao revisor conferir o resultado. Para experimentar sem um repositório pronto, salve o arquivo abaixo como &lt;code&gt;pedidos_test.go&lt;/code&gt;. Ele contém o handler e os testes e usa apenas a biblioteca padrão do Go.&lt;/p&gt;

&lt;p&gt;&lt;/p&gt;
  Exemplo completo: handler e testes em um arquivo
  &lt;br&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;pedidos&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="s2"&gt;"encoding/json"&lt;/span&gt;
    &lt;span class="s2"&gt;"net/http"&lt;/span&gt;
    &lt;span class="s2"&gt;"net/http/httptest"&lt;/span&gt;
    &lt;span class="s2"&gt;"strings"&lt;/span&gt;
    &lt;span class="s2"&gt;"testing"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="nf"&gt;novoHandler&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;criar&lt;/span&gt; &lt;span class="k"&gt;func&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Handler&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;HandlerFunc&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;func&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;w&lt;/span&gt; &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ResponseWriter&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;r&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Request&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="kd"&gt;var&lt;/span&gt; &lt;span class="n"&gt;pedido&lt;/span&gt; &lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="nc"&gt;Quantidade&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt; &lt;span class="sb"&gt;`json:"quantidade"`&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;NewDecoder&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;r&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Body&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Decode&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;pedido&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="kc"&gt;nil&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"JSON inválido"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;StatusBadRequest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="c1"&gt;// Correção: rejeitar antes do efeito colateral.&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;pedido&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Quantidade&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"quantidade deve ser positiva"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;StatusBadRequest&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;return&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="nf"&gt;criar&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="n"&gt;w&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;WriteHeader&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;StatusCreated&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="nc"&gt;TestCriarPedido&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;testing&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;casos&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;nome&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;corpo&lt;/span&gt;      &lt;span class="kt"&gt;string&lt;/span&gt;
        &lt;span class="n"&gt;status&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;criacoes&lt;/span&gt; &lt;span class="kt"&gt;int&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"negativa"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sb"&gt;`{"quantidade":-1}`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;400&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"zero"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sb"&gt;`{"quantidade":0}`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;400&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"positiva"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sb"&gt;`{"quantidade":1}`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;201&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="mi"&gt;1&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;caso&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="k"&gt;range&lt;/span&gt; &lt;span class="n"&gt;casos&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;caso&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;nome&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;func&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;testing&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;criadas&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt;
            &lt;span class="n"&gt;handler&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="nf"&gt;novoHandler&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="k"&gt;func&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="n"&gt;criadas&lt;/span&gt;&lt;span class="o"&gt;++&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;req&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;httptest&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;NewRequest&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;http&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MethodPost&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"/pedidos"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
                &lt;span class="n"&gt;strings&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;NewReader&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;caso&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;corpo&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Header&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Set&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"Content-Type"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"application/json"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;res&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;httptest&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;NewRecorder&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="n"&gt;handler&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ServeHTTP&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;res&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;req&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;res&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="n"&gt;caso&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;status&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
                &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Errorf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"status: esperado %d, recebido %d"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;caso&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;status&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;res&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Code&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="p"&gt;}&lt;/span&gt;
            &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;criadas&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="n"&gt;caso&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;criacoes&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
                &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Errorf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"criações: esperado %d, recebido %d"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;caso&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;criacoes&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;criadas&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;




&lt;p&gt;&lt;/p&gt;

&lt;p&gt;Execute no diretório onde salvou o arquivo:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;go &lt;span class="nb"&gt;test&lt;/span&gt; -v pedidos_test.go
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Para reproduzir o bug&lt;/strong&gt;, remova temporariamente o bloco &lt;code&gt;if pedido.Quantidade &amp;lt;= 0&lt;/code&gt; e repita o comando. Os casos negativo e zero falham: recebem &lt;code&gt;201&lt;/code&gt; e criam um pedido. Restaure a validação e rode novamente: os três casos passam. O teste confere tanto o status quanto o efeito colateral; devolver &lt;code&gt;400&lt;/code&gt; depois de criar o pedido não resolveria o problema.&lt;/p&gt;

&lt;p&gt;Conferi esse ciclo localmente para o artigo: sem a validação, dois casos falharam; com ela, os três passaram. É uma demonstração de comportamento HTTP, sem banco, autenticação ou servidor de produção. Em uma API real, mantenha os demais campos válidos para a falha acontecer pelo motivo que está testando.&lt;/p&gt;

&lt;p&gt;O &lt;code&gt;CLAUDE.md&lt;/code&gt; complementa esse pedido com o que vale para o projeto: comando de testes, convenções próprias e caminhos das regras. Não precisa recontar o funcionamento de Go ou copiar toda a documentação. A recomendação oficial é mantê-lo abaixo de 200 linhas. &lt;strong&gt;Imports &lt;code&gt;@&lt;/code&gt; carregam conteúdo; dividir um documento usando imports não elimina seu custo de contexto.&lt;/strong&gt; Use ponteiros e regras por caminho quando fizer sentido. &lt;a href="https://code.claude.com/docs/en/memory" rel="noopener noreferrer"&gt;Memória e regras&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;No Downshift (projeto open-source meu em Go que roda acoplado a ferramentas como Claude Code, Codex CLI e Cursor — o que chamamos de &lt;strong&gt;harness&lt;/strong&gt;, a camada de software ao redor do modelo que controla contexto, ferramentas, permissões e hooks), aplicamos essa divisão diretamente no repositório. Como o Downshift existe para compactar saídas de terminal e aplicar limites de modelo nos subagentes dentro da política do projeto, precisamos manter as instruções dele enxutas em qualquer agente. O &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/CLAUDE.md" rel="noopener noreferrer"&gt;&lt;code&gt;CLAUDE.md&lt;/code&gt;&lt;/a&gt; tem apenas três linhas: importa &lt;code&gt;@AGENTS.md&lt;/code&gt; e aponta para &lt;code&gt;docs/contrib/layering.md&lt;/code&gt;, mantendo o contrato compartilhado em &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/AGENTS.md" rel="noopener noreferrer"&gt;&lt;code&gt;AGENTS.md&lt;/code&gt;&lt;/a&gt; cravado no teto de 200 linhas para que todos os harnesses leiam o mesmo texto sem duplicar instruções.&lt;/p&gt;

&lt;p&gt;Em vez de empilhar proibições em &lt;code&gt;CAIXA ALTA&lt;/code&gt; no prompt esperando que o modelo se lembre delas no fim da sessão, as regras estruturais viram testes executáveis em &lt;code&gt;go test ./internal/archtest&lt;/code&gt;. O arquivo &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/internal/archtest/filesize_test.go" rel="noopener noreferrer"&gt;&lt;code&gt;internal/archtest/filesize_test.go&lt;/code&gt;&lt;/a&gt; falha se qualquer arquivo &lt;code&gt;.go&lt;/code&gt; de produção ultrapassar 300 linhas (&lt;code&gt;maxFileLines = 300&lt;/code&gt;), enquanto &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/internal/archtest/layers_test.go" rel="noopener noreferrer"&gt;&lt;code&gt;internal/archtest/layers_test.go&lt;/code&gt;&lt;/a&gt; trava as fronteiras de importação entre pacotes — por exemplo, garantindo que &lt;code&gt;accounting&lt;/code&gt; (o pacote que contabiliza tokens) importe apenas &lt;code&gt;telemetry&lt;/code&gt;, &lt;code&gt;execwrap&lt;/code&gt; (o wrapper de comandos) e &lt;code&gt;catalog&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="c1"&gt;// internal/archtest/layers_test.go&lt;/span&gt;
&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="nc"&gt;TestLayerDirectImports&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;testing&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;allowed&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="k"&gt;map&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="kt"&gt;string&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="kt"&gt;string&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="s2"&gt;"accounting"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="s2"&gt;"telemetry"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"execwrap"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"catalog"&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;pkg&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ok&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="k"&gt;range&lt;/span&gt; &lt;span class="n"&gt;allowed&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Run&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pkg&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="k"&gt;func&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;testing&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;bad&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="nf"&gt;outsideAllowlist&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;directImports&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;pkg&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ok&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;bad&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
                &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Errorf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"internal/%s imports %v; it may import only %v"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;pkg&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;bad&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ok&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
            &lt;span class="p"&gt;}&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Se um agente tentar cruzar uma camada ou inflar um arquivo, o teste quebra de forma determinística antes da revisão humana, sem gastar tokens repetindo a regra a cada turno.&lt;/p&gt;

&lt;p&gt;O Plan Mode continua útil para explorar uma mudança ampla antes de editar. Ele controla a etapa de trabalho e as ferramentas disponíveis; não aumenta o effort. Para esse bug delimitado, eu começaria pelo teste. &lt;a href="https://code.claude.com/docs/en/best-practices" rel="noopener noreferrer"&gt;Boas práticas&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feyztzowg5968yhvbno3f.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Feyztzowg5968yhvbno3f.png" alt="Fluxo de contexto, ação, verificação e revisão humana, com retorno de falhas para correção" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Separe a pesquisa quando ela atrapalhar a correção
&lt;/h2&gt;

&lt;p&gt;Se descobrir os consumidores exigir ler dezenas de arquivos, essa exploração pode ocupar a conversa inteira. Um subagente consegue pesquisar em contexto separado e devolver as evidências relevantes. Para uma busca curta, abrir outro agente pode acrescentar mais coordenação do que benefício.&lt;/p&gt;

&lt;p&gt;Uma definição didática em &lt;code&gt;.claude/agents/contratos-api.md&lt;/code&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;---
name: contratos-api
description: Investiga consumidores de endpoints sem editar arquivos.
tools: Read, Grep, Glob
model: haiku
effort: medium
---
Identifique campos, status e consumidores do endpoint solicitado.
Retorne arquivo e linha de cada evidência e declare as lacunas.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Peça: &lt;strong&gt;“Use contratos-api para investigar os consumidores deste endpoint; retorne o contrato observado e o que não conseguiu confirmar.”&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Um retorno útil nesse cenário seria: &lt;strong&gt;“O contrato prevê 400 para quantidade não positiva e 201 para pedido válido. Localizei o consumidor web, mas não confirmei o comportamento do aplicativo mobile.”&lt;/strong&gt; É uma resposta ilustrativa; numa execução real, ela precisa trazer arquivo e linha das evidências. Essa lacuna deve continuar visível na revisão.&lt;/p&gt;

&lt;p&gt;Aqui, a escolha do modelo é explícita e as ferramentas permitem apenas leitura. O alias acompanha o provedor; fixe o ID completo quando precisar reproduzir um teste. O subagente também consome cota: preservar a conversa principal não significa eliminar esse consumo. &lt;a href="https://code.claude.com/docs/en/sub-agents" rel="noopener noreferrer"&gt;Configuração de subagentes&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Também não suponha que o effort será sempre herdado. Sem configuração própria, no mesmo modelo ele acompanha a seleção da sessão; em outro modelo, essa seleção não se aplica. Declare &lt;code&gt;effort&lt;/code&gt; quando precisar controlar essa escolha e confira o modelo em &lt;code&gt;/tasks&lt;/code&gt;. &lt;a href="https://code.claude.com/docs/en/sub-agents#choose-an-effort-level" rel="noopener noreferrer"&gt;Regras de esforço&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Nos agentes reais do Downshift, como &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/agents/researcher.md" rel="noopener noreferrer"&gt;&lt;code&gt;agents/researcher.md&lt;/code&gt;&lt;/a&gt; e &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/agents/mechanical-worker.md" rel="noopener noreferrer"&gt;&lt;code&gt;agents/mechanical-worker.md&lt;/code&gt;&lt;/a&gt;, seguimos a mesma estrutura de escopo fechado, mas sem fixar um &lt;code&gt;model:&lt;/code&gt; literal no frontmatter:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;---
name: researcher
domain: core
mode: read
default_tier: small
playbook: research
tools: Read, Grep, Glob, Bash
---
&lt;span class="k"&gt;- &lt;/span&gt;Be precise: cite file and line number for every claim.
&lt;span class="k"&gt;- &lt;/span&gt;If you cannot find something, say so. Do not guess.
&lt;span class="k"&gt;- &lt;/span&gt;Do not write or modify code. Report findings only.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O agente herda o modelo da sessão por padrão, mas quem coordena a tarefa pode sinalizar trabalhos mecânicos com &lt;code&gt;[tier=small]&lt;/code&gt; (como prevê &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/agents/mechanical-worker.md" rel="noopener noreferrer"&gt;&lt;code&gt;agents/mechanical-worker.md&lt;/code&gt;&lt;/a&gt;) para que o hook roteie o filho dentro da política do projeto sem chumbá-lo a um ID fixo. Note que &lt;code&gt;default_tier&lt;/code&gt; e &lt;code&gt;playbook&lt;/code&gt; no trecho acima são campos do catálogo do Downshift; no Claude Code puro (&lt;code&gt;.claude/agents/*.md&lt;/code&gt;), você usa &lt;code&gt;model:&lt;/code&gt; e &lt;code&gt;effort:&lt;/code&gt;, como vimos em &lt;code&gt;contratos-api.md&lt;/code&gt;. Já a seção obrigatória &lt;code&gt;## Gaps&lt;/code&gt; força o subagente a declarar o que não encontrou em vez de preencher lacunas com suposições.&lt;/p&gt;

&lt;p&gt;Outra trava simples para cortar tokens de saída e acelerar a revisão humana é controlar a verbosidade da resposta. O retorno de um subagente deveria parecer saída de CI: arquivo, linha, status e só. Em &lt;a href="https://github.com/tiago.boas/downshift-ai/blob/main/agents/mechanical-worker.md" rel="noopener noreferrer"&gt;&lt;code&gt;agents/mechanical-worker.md&lt;/code&gt;&lt;/a&gt;, aplicamos essa disciplina direto no contrato:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;&lt;span class="k"&gt;- &lt;/span&gt;Report: what you changed (file and line), what you ran and its exit status, and
  anything you left undone. No prose beyond that.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Sem essa regra, modelos capazes devolvem resumos narrativos em cada subtarefa; com ela, você lê o diff e o status de saída sem pagar por prosa redundante.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Faça o agente demonstrar que terminou
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjkvvpypqzfo269kwujur.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjkvvpypqzfo269kwujur.png" alt="Exemplo didático: reproduzir o retorno incorreto 201, corrigir a validação e verificar 400 para entrada inválida e 201 para pedido válido" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Na nossa API, uma entrega útil mostra três evidências: o teste reproduziu o problema, passou após a correção e as verificações relevantes foram executadas sobre o código final. “Revise duas vezes” não define nenhuma dessas provas.&lt;/p&gt;

&lt;p&gt;Para continuar automaticamente até uma condição de término, &lt;code&gt;/goal&lt;/code&gt; aceita um objetivo como:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;/goal Corrigir o endpoint e incluir o teste de regressão.
Prova: executar as verificações do projeto e trazer à conversa
os comandos, códigos de saída e resumo dos resultados.
Preservar contrato público e esquema do banco.
Após 15 turnos, parar e relatar o bloqueio se não houver prova.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;O avaliador de &lt;code&gt;/goal&lt;/code&gt; lê a conversa; não abre arquivos nem executa comandos por conta própria.&lt;/strong&gt; Por isso, a prova precisa aparecer no histórico. O limite de turnos escrito no objetivo é interpretado pelo avaliador, não um teto rígido de execução. O recurso também consome tokens e não muda as permissões. &lt;a href="https://code.claude.com/docs/en/goal" rel="noopener noreferrer"&gt;Funcionamento de &lt;code&gt;/goal&lt;/code&gt;&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Na revisão, eu pediria:&lt;/strong&gt; o nome dos testes executados, o resultado antes e depois e se o código mudou após a última execução. Isso permite conferir a entrega sem aceitar um “agora funciona” como prova. E vale lembrar que critério sem acesso real ao ambiente falha em silêncio: para APIs, o agente precisa rodar &lt;code&gt;go test&lt;/code&gt; ou o linter; para fluxos visuais de front-end, precisa de automação de navegador (como Playwright ou Chrome DevTools) capaz de validar o estado renderizado.&lt;/p&gt;

&lt;p&gt;No código do Downshift, automatizamos essa auditoria em &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/internal/adapters/claudecode/verification.go" rel="noopener noreferrer"&gt;&lt;code&gt;internal/adapters/claudecode/verification.go&lt;/code&gt;&lt;/a&gt;. Em vez de confiar na frase final do subagente, &lt;code&gt;readSubagentVerification&lt;/code&gt; lê o log JSONL da execução, casa cada chamada &lt;code&gt;Bash&lt;/code&gt; de teste ou lint (&lt;code&gt;go test&lt;/code&gt;, &lt;code&gt;pytest&lt;/code&gt;, &lt;code&gt;vitest&lt;/code&gt;, &lt;code&gt;golangci-lint&lt;/code&gt;, etc.) com o &lt;code&gt;tool_result&lt;/code&gt; correspondente e lê a flag &lt;code&gt;IsError&lt;/code&gt; — mantendo sempre o último resultado (&lt;code&gt;passed&lt;/code&gt;, &lt;code&gt;failed&lt;/code&gt; ou &lt;code&gt;none&lt;/code&gt;), sem gravar comandos nem saídas:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="c1"&gt;// internal/adapters/claudecode/verification.go (trecho de readSubagentVerification)&lt;/span&gt;
&lt;span class="k"&gt;switch&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Type&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
&lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="s2"&gt;"tool_use"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Name&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="s2"&gt;"Bash"&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;ID&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="s2"&gt;""&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class="n"&gt;verifyCommand&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;MatchString&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Input&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Command&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;pending&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;ID&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="s2"&gt;"tool_result"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;pending&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ToolUseID&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nb"&gt;delete&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;pending&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;ToolUseID&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;b&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;IsError&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;verificationFailed&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="k"&gt;else&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;verificationPassed&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Limites críticos também precisam de controles além do texto. Em hooks baseados em comando, um hook &lt;code&gt;PreToolUse&lt;/code&gt; bloqueia uma chamada antes da execução quando retorna código de saída &lt;code&gt;2&lt;/code&gt; e envia o motivo em &lt;code&gt;stderr&lt;/code&gt; para o contexto do Claude (enquanto &lt;code&gt;exit 1&lt;/code&gt; é tratado apenas como erro não bloqueante do script e deixa a ferramenta rodar). Ainda assim, sua eficácia depende das ações que o hook consegue identificar e interceptar; um filtro de comandos não protege sozinho todos os acessos ao banco. &lt;a href="https://code.claude.com/docs/en/hooks" rel="noopener noreferrer"&gt;Contrato dos hooks&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Quando o hook serve para reescrever uma chamada sem quebrar as permissões do usuário, o cuidado de protocolo é o mesmo. Em &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/internal/adapters/claudecode/shell.go" rel="noopener noreferrer"&gt;&lt;code&gt;internal/adapters/claudecode/shell.go&lt;/code&gt;&lt;/a&gt;, &lt;code&gt;ShellRewrite&lt;/code&gt; troca apenas &lt;code&gt;tool_input.command&lt;/code&gt;, copia todos os campos irmãos (&lt;code&gt;description&lt;/code&gt;, &lt;code&gt;timeout&lt;/code&gt;, &lt;code&gt;run_in_background&lt;/code&gt;) intactos e omite &lt;code&gt;permissionDecision&lt;/code&gt; de propósito para não atropelar regras de &lt;code&gt;allow&lt;/code&gt;, &lt;code&gt;ask&lt;/code&gt; e &lt;code&gt;deny&lt;/code&gt; configuradas pelo desenvolvedor:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="c1"&gt;// internal/adapters/claudecode/shell.go (trecho de ShellRewrite)&lt;/span&gt;
&lt;span class="n"&gt;ti&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="s2"&gt;"command"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;encoded&lt;/span&gt;
&lt;span class="n"&gt;updated&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;_&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Marshal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;ti&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;shellOutput&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="nc"&gt;HookSpecificOutput&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;shellHookOutput&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="nc"&gt;HookEventName&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"PreToolUse"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="nc"&gt;UpdatedInput&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;  &lt;span class="n"&gt;updated&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="c1"&gt;// sem permissionDecision: preserva allow/ask/deny&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;nil&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O segundo ganho dessa interceptação está em &lt;strong&gt;filtrar dados via código determinístico antes de jogá-los na janela de contexto&lt;/strong&gt;. Em vez de mandar milhares de linhas de &lt;code&gt;go test -v&lt;/code&gt; ou &lt;code&gt;git log&lt;/code&gt; para o LLM resumir, o &lt;strong&gt;Compactor&lt;/strong&gt; com &lt;strong&gt;CCR (&lt;em&gt;Command Context Recovery&lt;/em&gt;)&lt;/strong&gt; em &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/internal/execwrap/balance.go" rel="noopener noreferrer"&gt;&lt;code&gt;internal/execwrap/balance.go&lt;/code&gt;&lt;/a&gt; e &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/internal/execwrap/keep.go" rel="noopener noreferrer"&gt;&lt;code&gt;internal/execwrap/keep.go&lt;/code&gt;&lt;/a&gt; só corta saídas acima de &lt;code&gt;16 KB&lt;/code&gt; (&lt;code&gt;BalanceThreshold = 16 &amp;lt;&amp;lt; 10&lt;/code&gt;) &lt;strong&gt;depois&lt;/strong&gt; que &lt;code&gt;keep&lt;/code&gt; salva o original em disco e devolve o ID de recuperação (&lt;code&gt;[downshift compact: X to Y bytes; downshift retrieve &amp;lt;id&amp;gt;]&lt;/code&gt;):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="c1"&gt;// internal/execwrap/balance.go (trecho de balance)&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;keep&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="kc"&gt;nil&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="n"&gt;balanceRefused&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;family&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;shown&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;=&lt;/span&gt; &lt;span class="n"&gt;threshold&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="kc"&gt;nil&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;cut&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;applied&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;compressor&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;BalanceWith&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;balanceKindOf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;family&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;body&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;cfg&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;limits&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;applied&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="kc"&gt;nil&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;stored&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="nf"&gt;keep&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="kt"&gt;byte&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="kc"&gt;nil&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;raw&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="o"&gt;!&lt;/span&gt;&lt;span class="n"&gt;stored&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="kc"&gt;nil&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nb"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;append&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;&lt;span class="kt"&gt;byte&lt;/span&gt;&lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;cut&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nc"&gt;MarkerWithID&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;raw&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;cut&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;id&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kc"&gt;true&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Repare nas travas de segurança: leituras de arquivos locais (&lt;code&gt;FamilyFileRead&lt;/code&gt;) nunca sofrem corte com perda, se o armazenamento falhar o texto volta intacto (&lt;em&gt;fail-open&lt;/em&gt;) e respostas HTTP que podem carregar cabeçalhos sensíveis como &lt;code&gt;Set-Cookie&lt;/code&gt; não têm permissão para gravar saída bruta em disco.&lt;/p&gt;

&lt;p&gt;É a aplicação prática de &lt;strong&gt;guias e sensores&lt;/strong&gt; em &lt;a href="https://martinfowler.com/articles/harness-engineering.html" rel="noopener noreferrer"&gt;harness engineering, por Birgitta Böckeler&lt;/a&gt;: instruções orientam; controles e verificações dão retorno sobre o que aconteceu.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Skills sem efeito placebo: criar pelo erro, orçar tokens e testar como código
&lt;/h2&gt;

&lt;p&gt;O mesmo critério de prova vale para skills e plugins. No código, ninguém coloca uma dependência nova sem conferir peso e cobertura; em contexto de agente, o pessoal costuma instalar pacotes inteiros de &lt;code&gt;SKILL.md&lt;/code&gt; sem medir o que muda na sessão.&lt;/p&gt;

&lt;h3&gt;
  
  
  5.1 Como as skills carregam no Claude Code (e o orçamento real em &lt;code&gt;skills/README.md&lt;/code&gt;)
&lt;/h3&gt;

&lt;p&gt;Uma skill no Claude Code não é gratuita, mesmo quando ninguém a chama naquela conversa. O carregamento funciona em dois estágios:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Estágio 1 — Custo fixo por turno:&lt;/strong&gt; a linha &lt;code&gt;description:&lt;/code&gt; do frontmatter YAML de toda skill elegível entra no contexto em &lt;strong&gt;todas as sessões&lt;/strong&gt; (com orçamento padrão de até 1% da janela de contexto). Além disso, como registramos nos próprios testes do Downshift (&lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/orchestrator_skill_test.go" rel="noopener noreferrer"&gt;&lt;code&gt;skills/orchestrator_skill_test.go&lt;/code&gt;&lt;/a&gt;), o harness escolhe qual skill acionar &lt;strong&gt;apenas pela &lt;code&gt;description&lt;/code&gt;&lt;/strong&gt; e ignora chaves extras como &lt;code&gt;triggers:&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Estágio 2 — Carga sob demanda:&lt;/strong&gt; o corpo do arquivo &lt;code&gt;SKILL.md&lt;/code&gt; só entra na conversa quando a descrição casa com a tarefa pedida.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Quando você instala o plugin do Downshift no Claude Code, ele também embarca um conjunto enxuto de skills próprias (&lt;code&gt;/downshift:&amp;lt;nome&amp;gt;&lt;/code&gt;) para ensinar o agente a usar esses limites e comandos sem desperdiçar contexto. No arquivo &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/README.md" rel="noopener noreferrer"&gt;&lt;code&gt;skills/README.md&lt;/code&gt;&lt;/a&gt;, documentamos exatamente o custo de cada uma (medido em 17/10/2026 como estimativa &lt;code&gt;bytes / 4&lt;/code&gt;, não um tokenizador exato):&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Skill no Downshift&lt;/th&gt;
&lt;th&gt;
&lt;code&gt;description&lt;/code&gt; (sempre carregada)&lt;/th&gt;
&lt;th&gt;Corpo (ao acionar)&lt;/th&gt;
&lt;th&gt;Papel e ciclo de vida&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/ponytail/SKILL.md" rel="noopener noreferrer"&gt;&lt;code&gt;ponytail/SKILL.md&lt;/code&gt;&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;~45 tokens&lt;/td&gt;
&lt;td&gt;~620 tokens&lt;/td&gt;
&lt;td&gt;Menor mudança completa (53 linhas)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/downshift-setup/SKILL.md" rel="noopener noreferrer"&gt;&lt;code&gt;downshift-setup/SKILL.md&lt;/code&gt;&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;~66 tokens&lt;/td&gt;
&lt;td&gt;~730 tokens&lt;/td&gt;
&lt;td&gt;Instalação com &lt;code&gt;--dry-run&lt;/code&gt;; pode ser apagada após &lt;code&gt;downshift doctor&lt;/code&gt; passar&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/downshift-audit/SKILL.md" rel="noopener noreferrer"&gt;&lt;code&gt;downshift-audit/SKILL.md&lt;/code&gt;&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;~70 tokens&lt;/td&gt;
&lt;td&gt;~890 tokens&lt;/td&gt;
&lt;td&gt;Inspeção somente leitura da sessão&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/downshift-tune/SKILL.md" rel="noopener noreferrer"&gt;&lt;code&gt;downshift-tune/SKILL.md&lt;/code&gt;&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;~86 tokens&lt;/td&gt;
&lt;td&gt;~750 tokens (+ ~400 por ref)&lt;/td&gt;
&lt;td&gt;Diagnóstico ordenado de gasto de tokens&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Somando todo o conjunto instalado pelo plugin do Downshift (incluindo a skill complementar &lt;code&gt;downshift-effort&lt;/code&gt;, o agente mecânico e o comando de status), a taxa fixa fica em torno de &lt;strong&gt;390 tokens por sessão&lt;/strong&gt;. Uma skill não economiza nada por existir: ela só se paga quando muda uma ação concreta do modelo. Por isso, restringimos as descrições do Downshift para disparar apenas quando o usuário cita o Downshift ou pergunta sobre hooks e consumo — nunca em qualquer menção genérica a &lt;code&gt;CLAUDE.md&lt;/code&gt; — e explicitamos na tabela quando uma skill descartável (como &lt;code&gt;downshift-setup&lt;/code&gt;) pode ser deletada.&lt;/p&gt;

&lt;h3&gt;
  
  
  5.2 Criar a partir do erro observado: a skill &lt;code&gt;downshift-effort&lt;/code&gt; dentro do Downshift
&lt;/h3&gt;

&lt;p&gt;O erro mais comum ao escrever skills é sentar na frente de um arquivo em branco e inventar um manual de 300 linhas antes mesmo de testar o modelo. O guia da Anthropic (e a prática do Downshift) inverte a ordem:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Rode a tarefa &lt;strong&gt;sem skill nenhuma&lt;/strong&gt; em casos reais do repositório.&lt;/li&gt;
&lt;li&gt;Anote &lt;strong&gt;exatamente onde o modelo tropeçou&lt;/strong&gt; (por exemplo: esqueceu rollback numa migration ou aplicou esforço máximo numa troca de nome trivial).&lt;/li&gt;
&lt;li&gt;Quando a sessão finalmente convergir, &lt;strong&gt;destile o &lt;code&gt;SKILL.md&lt;/code&gt; a partir do histórico daquela conversa&lt;/strong&gt; — registrando só as decisões e correções observadas — e valide no modelo que você realmente usa em produção.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Um exemplo real dessa abordagem dentro do próprio repositório do Downshift é a skill &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/downshift-effort/SKILL.md" rel="noopener noreferrer"&gt;&lt;code&gt;skills/downshift-effort/SKILL.md&lt;/code&gt;&lt;/a&gt; (47 linhas no arquivo inteiro, embarcada junto com o plugin). Em vez de tentar ensinar engenharia de software do zero, ela ataca um erro recorrente de uso de tokens: gastar esforço alto em tarefa mecânica ou economizar verificação em código crítico.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight markdown"&gt;&lt;code&gt;---
name: downshift-effort
description: Advice for the orchestrator on matching reasoning and verification effort to what a task puts at risk. Use when deciding how hard to think, how much to check, or what effort to give a subagent, with Downshift installed.
---

&lt;span class="gu"&gt;# Effort follows the stakes
&lt;/span&gt;
| Level | Typical work | Effort | Verification |
|---|---|---|---|
| Mechanical and reversible | rename, format, boilerplate, a typo, a lookup | fast, low | a glance at the diff |
| Ordinary code change with tests | a feature slice, a bug fix, a refactor with coverage | medium | run the tests that cover the change |
| High stakes | auth, security, money, production data, or a claim the user will act on unchecked | high | check it directly before you report |
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Repare no desenho enxuto: ela classifica o risco em três faixas, proíbe subir esforço apenas "para parecer cuidadoso" e declara explicitamente que &lt;strong&gt;nunca escolhe o valor de &lt;code&gt;effort&lt;/code&gt; por conta própria&lt;/strong&gt; — quem decide é o agente principal, dentro da política declarada pelo usuário (como explico na Seção 6).&lt;/p&gt;

&lt;h3&gt;
  
  
  5.3 O protocolo de 3 braços do &lt;code&gt;skill-placebo&lt;/code&gt; (e por que &lt;code&gt;ponytail&lt;/code&gt; sobreviveu)
&lt;/h3&gt;

&lt;p&gt;Testar uma skill comparando apenas "com skill" contra "sem skill" engana, porque &lt;strong&gt;qualquer bloco de texto extra&lt;/strong&gt; injetado no contexto muda os pesos de atenção e o gasto de tokens do modelo.&lt;/p&gt;

&lt;p&gt;Para isolar o efeito real, o estudo independente &lt;a href="https://github.com/simonether/skill-placebo" rel="noopener noreferrer"&gt;skill-placebo&lt;/a&gt; (Simon Ether) avaliou nove pacotes populares ao longo de &lt;strong&gt;450 execuções no Claude Opus 5.5&lt;/strong&gt; (15 tarefas públicas de SWE-bench Verified, Terminal-Bench e TBLite, com 30 repetições por braço) usando &lt;strong&gt;três braços&lt;/strong&gt;:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Sem skill (&lt;em&gt;plain&lt;/em&gt;):&lt;/strong&gt; a tarefa pura no modelo base.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Placebo de mesmo tamanho:&lt;/strong&gt; texto neutro, sem instruções úteis, com a mesma contagem de tokens e instalado do mesmo jeito.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Skill real:&lt;/strong&gt; o pacote avaliado.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;O resultado serve de freio para quem coleciona pacotes de terceiros:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;6 de 9&lt;/strong&gt; pacotes empataram estatisticamente com texto neutro de mesmo tamanho;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;1 pacote&lt;/strong&gt; (&lt;code&gt;planning-with-files&lt;/code&gt;) foi &lt;strong&gt;pior&lt;/strong&gt; que o placebo, derrubando a taxa de aprovação de 100% para 80%;&lt;/li&gt;
&lt;li&gt;Apenas &lt;strong&gt;2 de 9&lt;/strong&gt; (&lt;code&gt;ponytail&lt;/code&gt; e &lt;code&gt;agent-skills&lt;/code&gt;) superaram seus placebos equivalentes em eficiência de custo — ainda que nenhum dos nove tenha custado menos que rodar sem skill alguma nessa amostra genérica.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;No Downshift, embarcamos justamente &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/ponytail/SKILL.md" rel="noopener noreferrer"&gt;&lt;code&gt;skills/ponytail/SKILL.md&lt;/code&gt;&lt;/a&gt; (53 linhas), que concentra regras curtas contra over-engineering (&lt;em&gt;"The shortest working diff wins... Lazy code without its check is unfinished"&lt;/em&gt;). Mesmo assim, o aprendizado do &lt;code&gt;skill-placebo&lt;/code&gt; vale para qualquer regra nova: o texto precisa provar que resolve um erro recorrente melhor do que espaço vazio.&lt;/p&gt;

&lt;h3&gt;
  
  
  5.4 Três camadas de sensores para testar e limpar skills como código
&lt;/h3&gt;

&lt;p&gt;Em vez de tratar &lt;code&gt;SKILL.md&lt;/code&gt; como prosa estática que ninguém revisa, vale aplicar três sensores em camadas:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;1. Testes unitários sobre o próprio Markdown (&lt;code&gt;go test ./skills/...&lt;/code&gt;):&lt;/strong&gt;&lt;br&gt;
O Downshift já teve uma primeira tentativa chamada &lt;em&gt;Universal Skill&lt;/em&gt; — uma skill monolítica que tentava ensinar tudo num único arquivo, chumbando nomes fixos de modelos (&lt;code&gt;flash_lite / haiku-5-5&lt;/code&gt;) e nomes antigos de ferramentas &lt;strong&gt;MCP&lt;/strong&gt; (&lt;em&gt;Model Context Protocol&lt;/em&gt;, protocolo padrão para conectar agentes a ferramentas externas) que o servidor não registrava, em vez de consultar a ferramenta MCP &lt;code&gt;providers&lt;/code&gt; que devolve os modelos disponíveis na sessão. Quando apagamos esse arquivo, criamos testes em &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/shipped_text_test.go" rel="noopener noreferrer"&gt;&lt;code&gt;skills/shipped_text_test.go&lt;/code&gt;&lt;/a&gt;, &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/orchestrator_skill_test.go" rel="noopener noreferrer"&gt;&lt;code&gt;skills/orchestrator_skill_test.go&lt;/code&gt;&lt;/a&gt; e &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/skills/effort_skill_test.go" rel="noopener noreferrer"&gt;&lt;code&gt;skills/effort_skill_test.go&lt;/code&gt;&lt;/a&gt; que barram modelos chumbados, ferramentas inexistentes e skills inchadas:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="c1"&gt;// skills/shipped_text_test.go e skills/effort_skill_test.go&lt;/span&gt;
&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="nc"&gt;TestShippedTextNamesNoModel&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;testing&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;ids&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="nf"&gt;catalogIDs&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;for&lt;/span&gt; &lt;span class="n"&gt;from&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="k"&gt;range&lt;/span&gt; &lt;span class="nf"&gt;shippedTexts&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;found&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="nf"&gt;modelLiterals&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;ids&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="nb"&gt;len&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;found&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="mi"&gt;0&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
            &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Errorf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"%s names models %v; models come from the providers tool"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;from&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;found&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
        &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="nc"&gt;TestEffortSkillHasNoDollarsOrModelIDs&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;testing&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="no"&gt;T&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;text&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="nf"&gt;effortText&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;strings&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Contains&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"$"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Error&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"effort skill must keep accounting in tokens, found a dollar sign"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;strings&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Count&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;text&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s2"&gt;"\n"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt; &lt;span class="o"&gt;&amp;gt;=&lt;/span&gt; &lt;span class="mi"&gt;80&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="n"&gt;t&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nc"&gt;Errorf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;"effort skill has %d lines, want under 80"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;n&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;2. Auditoria de custo e uso real com &lt;code&gt;/skill-doctor&lt;/code&gt;:&lt;/strong&gt;&lt;br&gt;
Introduzido no Claude Code &lt;strong&gt;v2.1.261&lt;/strong&gt;, o comando &lt;code&gt;/skill-doctor&lt;/code&gt; (junto do &lt;code&gt;/doctor&lt;/code&gt;) mostra quanto da janela cada descrição elegível está consumindo e quais skills nunca foram invocadas na prática. Skill que cobra taxa fixa em todo turno e nunca dispara sai do projeto.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Benchmark A/B com &lt;code&gt;claude plugin eval&lt;/code&gt;:&lt;/strong&gt;&lt;br&gt;
Introduzido no Claude Code &lt;strong&gt;v2.1.269&lt;/strong&gt;, o &lt;code&gt;claude plugin eval&lt;/code&gt; executa uma suíte versionada em &lt;code&gt;evals/&lt;/code&gt; (&lt;code&gt;prompt.md&lt;/code&gt; + avaliadores em &lt;code&gt;graders/&lt;/code&gt;, desde checagens determinísticas gratuitas como &lt;code&gt;regex&lt;/code&gt;, &lt;code&gt;tool_used&lt;/code&gt;, &lt;code&gt;tool_order&lt;/code&gt; e &lt;code&gt;file_exists&lt;/code&gt; até juízes &lt;code&gt;llm&lt;/code&gt; e &lt;code&gt;baseline&lt;/code&gt;), rodando cada cenário &lt;strong&gt;com e sem a skill&lt;/strong&gt; para medir o delta (Δ) real antes de manter a instrução no time. O fluxo abaixo resume essa comparação em três braços (sem skill, texto neutro e skill real):&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqem599sy60b0oaj2qb19.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqem599sy60b0oaj2qb19.png" alt="Proposta de avaliação com e sem skill e com texto neutro, mantendo modelo, tarefas e critérios" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  6. Como medir consumo sem confundir tokens com a conta
&lt;/h2&gt;

&lt;p&gt;Ao concluir uma tentativa, abra &lt;strong&gt;&lt;code&gt;/usage&lt;/code&gt;&lt;/strong&gt;. O bloco de sessão apresenta tokens por modelo, incluindo entrada, saída, leitura e escrita de cache, além de duração e custo estimado. No Pro, o valor em dólares não é uma cobrança adicional: a tela também mostra os limites do plano. Para faturamento de API, confira o provedor. &lt;a href="https://code.claude.com/docs/en/costs#using-the-usage-command" rel="noopener noreferrer"&gt;Referência de consumo&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Na comparação, salve uma linha por tentativa:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;tarefa | modelo/versão | effort | passou? | tokens por categoria |
custo estimado | duração | tentativas | intervenção humana
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Use o mesmo estado inicial do código, prompt, testes, skills e ferramentas. Abra sessões novas, alterne a ordem das configurações e registre o estado do cache; não compare uma sessão já aquecida com outra fria como se fossem equivalentes. Repita os casos antes de concluir que houve ganho.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Inclua as falhas na conta:&lt;/strong&gt; some o consumo de todas as tentativas de uma configuração e divida pelas entregas aceitas. Se nenhuma passou, não há custo por entrega aceita a reportar. Mantenha tokens de cache separados: um token lido do cache e um token de saída não têm o mesmo preço. A ocupação da janela de contexto também não representa todo o consumo acumulado.&lt;/p&gt;

&lt;h3&gt;
  
  
  O que essa comparação mostrou no Downshift
&lt;/h3&gt;

&lt;p&gt;Foi essa distinção que precisei levar para o Downshift. No &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/evidence/four-arm-mechanical-2026-10-21.md" rel="noopener noreferrer"&gt;estudo de 21/10/2026&lt;/a&gt;, a bateria teve 46 execuções com tarefas mecânicas e delegação obrigatória:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Configuração&lt;/th&gt;
&lt;th&gt;Aceitas&lt;/th&gt;
&lt;th&gt;Tokens por execução aceita&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;opusplan&lt;/code&gt; nativo&lt;/td&gt;
&lt;td&gt;10 de 11&lt;/td&gt;
&lt;td&gt;2,00 milhões&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;code&gt;opusplan&lt;/code&gt; com roteamento do Downshift&lt;/td&gt;
&lt;td&gt;12 de 12&lt;/td&gt;
&lt;td&gt;1,52 milhão&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;O relatório registra &lt;strong&gt;24,1% menos tokens por execução aceita&lt;/strong&gt;, contando as falhas no consumo do grupo. O compactador estava desligado nos dois grupos comparados; essa diferença é do experimento de roteamento. O intervalo de 95% foi amplo: de 2,1% a 46,7%. Mais de 98% dos tokens eram de cache. Portanto, esse percentual não significa a mesma redução na fatura ou aumento do limite semanal do Pro.&lt;/p&gt;

&lt;p&gt;É um resultado histórico do roteamento usado naquele experimento, anterior à mudança de arquitetura registrada como &lt;strong&gt;decisão O8&lt;/strong&gt; no repositório — quando o roteador deixou de escolher o modelo por conta própria e passou apenas a aplicar, no hook &lt;code&gt;PreToolUse&lt;/code&gt;, a escolha feita pelo agente principal dentro da política declarada pelo usuário, como ressalva o &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/README.md#what-the-evidence-shows" rel="noopener noreferrer"&gt;README atual&lt;/a&gt;. Não comprova o efeito da implementação atual, nem se estende a tarefas gerais. O aprendizado aplicável aqui é medir a entrega aceita e identificar de onde vem a diferença antes de anunciar economia.&lt;/p&gt;

&lt;p&gt;Já para o corte determinístico de saídas antes da janela de contexto (a segunda alavanca do Downshift), as medições separadas registradas no mesmo README mostram onde o filtro de código reduz volume sem envolver outro LLM:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Medição de compactação&lt;/th&gt;
&lt;th&gt;Resultado&lt;/th&gt;
&lt;th&gt;Escopo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Compactação sem perda (&lt;em&gt;lossless&lt;/em&gt;)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;59,3% menos bytes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;64 fixtures em corpus sintético&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Compactação com CCR ativo&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;69,4% menos bytes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;113 fixtures em corpus sintético (&lt;code&gt;52,6%&lt;/code&gt; com CCR desligado)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Compactação balanceada (&lt;code&gt;&amp;gt; 16 KB&lt;/code&gt;)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;76,3% menos bytes&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;4 saídas reais do repositório (&lt;code&gt;go test -v&lt;/code&gt;, &lt;code&gt;git show&lt;/code&gt;, &lt;code&gt;git log -p&lt;/code&gt;, &lt;code&gt;grep -rn&lt;/code&gt;; &lt;code&gt;35,0%&lt;/code&gt; só com &lt;em&gt;lossless&lt;/em&gt;), com linhas cortadas recuperáveis via &lt;code&gt;downshift retrieve&lt;/code&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Como bytes reduzidos no terminal e tokens por execução aceita estão em unidades e amostras distintas, nenhuma das tabelas acima permite afirmar economia automática na fatura mensal ou no limite semanal do plano Pro.&lt;/p&gt;

&lt;h2&gt;
  
  
  Conclusão: por onde começar na próxima sessão
&lt;/h2&gt;

&lt;p&gt;Quando voltei para o problema que abriu esta investigação — o limite semanal do plano Pro acabando em poucos dias enquanto eu construía o Downshift —, ficou claro que o gasto raramente nasce de um único prompt longo. Ele se acumula na soma de modelo superdimensionado para tarefa mecânica, logs brutos despejados na janela de contexto, skills que cobram pedágio em todo turno sem mudar o comportamento e proibições escritas em prosa onde deveria haver um teste ou hook determinístico.&lt;/p&gt;

&lt;p&gt;Se você quiser aplicar esse fluxo amanhã no seu repositório sem refazer tudo do zero, comece por estes cinco passos na ordem:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Calibre &lt;code&gt;model&lt;/code&gt; × &lt;code&gt;effort&lt;/code&gt; pelo risco:&lt;/strong&gt; entre em &lt;code&gt;Sonnet 5.5&lt;/code&gt; com &lt;code&gt;medium&lt;/code&gt; quando a falha já tem reprodução clara (como no &lt;code&gt;POST /pedidos&lt;/code&gt;) e reserve o &lt;code&gt;Opus 5.5&lt;/code&gt; para investigações com hipóteses concorrentes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Corte o &lt;code&gt;CLAUDE.md&lt;/code&gt; para abaixo de 200 linhas:&lt;/strong&gt; troque avisos em &lt;code&gt;CAIXA ALTA&lt;/code&gt; por testes de arquitetura (&lt;code&gt;go test&lt;/code&gt;) e hooks &lt;code&gt;PreToolUse&lt;/code&gt; com &lt;code&gt;exit 2&lt;/code&gt; para regras inegociáveis.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Isole pesquisas extensas e filtre saídas longas:&lt;/strong&gt; delegue buscas pesadas a subagentes somente leitura com retorno seco (&lt;code&gt;file:line&lt;/code&gt; + &lt;code&gt;## Gaps&lt;/code&gt;) e compacte logs volumosos (&lt;code&gt;&amp;gt; 16 KB&lt;/code&gt;) antes da janela de contexto.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Exija prova executada no &lt;code&gt;/goal&lt;/code&gt; e pode skills ociosas:&lt;/strong&gt; amarre o critério de parada ao comando e ao código de saída impressos na conversa, rode &lt;code&gt;/skill-doctor&lt;/code&gt; e valide skills próprias com &lt;code&gt;claude plugin eval&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Meça no &lt;code&gt;/usage&lt;/code&gt; contando as falhas:&lt;/strong&gt; some todas as tentativas até a entrega aceita — e, se quiser automatizar a compactação de comandos e a política de subagentes descritas aqui, o &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/guides/install.md" rel="noopener noreferrer"&gt;guia de instalação do Downshift&lt;/a&gt; mostra como testar em modo seguro com &lt;code&gt;downshift setup --dry-run&lt;/code&gt; e &lt;code&gt;downshift doctor&lt;/code&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;O ganho prático desse desenho é conseguir responder, em qualquer revisão de código assistido: &lt;strong&gt;por que usamos essa capacidade, o que o agente pôde tocar e qual evidência executada prova que a mudança funciona.&lt;/strong&gt; Nenhuma automação de harness substitui o domínio humano sobre a arquitetura, as fronteiras entre módulos e os modos de falha do sistema — e é exatamente esse critério que impede transformar uma sessão barata em dívida técnica cara.&lt;/p&gt;

&lt;p&gt;Olhando para o seu &lt;code&gt;CLAUDE.md&lt;/code&gt; ou para as skills instaladas hoje no seu ambiente: qual regra ainda está escrita como pedido no prompt, mas já deveria ter virado um teste ou um hook determinístico?&lt;/p&gt;

&lt;h2&gt;
  
  
  Referências
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Vídeos que inspiraram a seleção dos temas: &lt;a href="https://www.youtube.com/watch?v=IvHwiECBh94" rel="noopener noreferrer"&gt;IA em 6 minutos&lt;/a&gt; e &lt;a href="https://www.youtube.com/watch?v=JqPjDPlPfvs" rel="noopener noreferrer"&gt;Maestros da IA&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://code.claude.com/docs/en/model-config" rel="noopener noreferrer"&gt;Modelos, versões e esforço&lt;/a&gt;, &lt;a href="https://claude.com/resources/articles/claude-model-and-effort-level-in-claude-code" rel="noopener noreferrer"&gt;explicação do mecanismo&lt;/a&gt; e &lt;a href="https://epoch.ai/benchmarks/eci" rel="noopener noreferrer"&gt;Epoch Capabilities Index (ECI)&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://code.claude.com/docs/en/memory" rel="noopener noreferrer"&gt;Memória e CLAUDE.md&lt;/a&gt;, &lt;a href="https://code.claude.com/docs/en/best-practices" rel="noopener noreferrer"&gt;boas práticas&lt;/a&gt;, &lt;a href="https://code.claude.com/docs/en/skills" rel="noopener noreferrer"&gt;skills&lt;/a&gt; e &lt;a href="https://code.claude.com/docs/en/sub-agents" rel="noopener noreferrer"&gt;subagentes&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://code.claude.com/docs/en/hooks" rel="noopener noreferrer"&gt;Hooks&lt;/a&gt;, &lt;a href="https://code.claude.com/docs/en/goal" rel="noopener noreferrer"&gt;&lt;code&gt;/goal&lt;/code&gt;&lt;/a&gt; e &lt;a href="https://code.claude.com/docs/en/costs" rel="noopener noreferrer"&gt;medição de consumo&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/tiagovilasboas/downshift-ai" rel="noopener noreferrer"&gt;Downshift: código citado (&lt;code&gt;AGENTS.md&lt;/code&gt;, &lt;code&gt;archtest&lt;/code&gt;, &lt;code&gt;agents/&lt;/code&gt;, &lt;code&gt;claudecode/&lt;/code&gt;, &lt;code&gt;execwrap/&lt;/code&gt; e &lt;code&gt;skills/&lt;/code&gt;)&lt;/a&gt; e &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/evidence/four-arm-mechanical-2026-10-21.md" rel="noopener noreferrer"&gt;estudo controlado de tarefas mecânicas, 21/10/2026&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/simonether/skill-placebo" rel="noopener noreferrer"&gt;Skill-placebo: método e resultados&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://martinfowler.com/articles/harness-engineering.html" rel="noopener noreferrer"&gt;Harness engineering — Birgitta Böckeler&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>braziliandevs</category>
      <category>claudecode</category>
      <category>ai</category>
      <category>programming</category>
    </item>
    <item>
      <title>Como economizar tokens no Claude Code: conheça o Downshift</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Wed, 11 Nov 2026 12:00:00 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/como-economizar-tokens-no-claude-code-conheca-o-downshift-4f0m</link>
      <guid>https://dev.to/tiagovilasboas/como-economizar-tokens-no-claude-code-conheca-o-downshift-4f0m</guid>
      <description>&lt;p&gt;Há cerca de seis meses, comecei a usar o Claude Code no &lt;strong&gt;plano Pro, que me custava US$ 20 por mês&lt;/strong&gt;. Em poucos dias de trabalho, eu já esgotava o limite semanal sem entender por quê. Era como uma mesa cheia de papéis: eu precisava de uma informação, mas o restante ocupava espaço.&lt;/p&gt;

&lt;p&gt;Foi dessa dor que nasceu o &lt;strong&gt;Downshift&lt;/strong&gt;, meu projeto open source em Go e um dos mais importantes da minha carreira. As principais funcionalidades são:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Compactor:&lt;/strong&gt; encurta resultados de comandos antes que a IA os leia, preservando erros e códigos de saída. No &lt;strong&gt;Computer Use&lt;/strong&gt;, quando o agente opera aplicativos, também compacta as descrições de tela do Agent Desktop e pode enviar apenas o que mudou entre leituras da mesma janela.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Model-routing:&lt;/strong&gt; aplica regras para escolher o modelo e quanto esforço ele deve dedicar às tarefas recebidas pelos subagentes, os agentes auxiliares. A escolha considera a política definida, os modelos disponíveis e o suporte da ferramenta utilizada.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agents:&lt;/strong&gt; reúne perfis especializados e &lt;em&gt;skills&lt;/em&gt;, instruções reutilizáveis para atividades como pesquisa, implementação, revisão e segurança. Eles orientam como dividir o trabalho e o que cada agente deve entregar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Telemetry:&lt;/strong&gt; permite acompanhar sessões, escolhas de modelos e resultados da compactação. Esses dados ajudam a enxergar onde os recursos estão sendo usados e o que vale otimizar.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;O projeto está em beta. O &lt;a href="https://github.com/tiagovilasboas/downshift-ai" rel="noopener noreferrer"&gt;código e a documentação estão no GitHub&lt;/a&gt;. Já há resultados em cenários específicos, mas ainda falta medir quanto eles prolongam o uso do plano Pro no dia a dia.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqockswxvn51v6xtulw63.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fqockswxvn51v6xtulw63.png" alt="Ilustração dos agentes do Downshift trabalhando em conjunto" width="800" height="410"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  O que precisei estudar para construir o Downshift
&lt;/h2&gt;

&lt;p&gt;Para entender esse consumo, precisei estudar &lt;strong&gt;contexto&lt;/strong&gt;, o conjunto de informações que o modelo recebe, e &lt;strong&gt;tokens&lt;/strong&gt;, as unidades de texto que ele processa. Uma pergunta curta pode carregar arquivos, histórico e resultados de comandos, como explica a &lt;a href="https://code.claude.com/docs/en/costs" rel="noopener noreferrer"&gt;documentação do Claude Code&lt;/a&gt;. A &lt;a href="https://www.anthropic.com/research/effective-context-engineering-for-ai-agents" rel="noopener noreferrer"&gt;engenharia de contexto&lt;/a&gt;, apresentada pela Anthropic, trata de como escolher e organizar esse material.&lt;/p&gt;

&lt;p&gt;Também estudei como dividir tarefas entre agentes e escolher modelos e níveis de esforço. &lt;a href="https://www.anthropic.com/research/building-effective-agents" rel="noopener noreferrer"&gt;Building effective agents&lt;/a&gt; é uma referência para essa arquitetura. Junto disso vieram os testes: uma saída menor precisa continuar dando ao agente condições de executar a tarefa. Essa relação entre otimização e qualidade aparece em &lt;a href="https://www.anthropic.com/research/demystifying-evals-for-ai-agents" rel="noopener noreferrer"&gt;Demystifying evals for AI agents&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Como reduzir o consumo de tokens no Claude Code
&lt;/h2&gt;

&lt;p&gt;Ao construir o &lt;strong&gt;Compactor&lt;/strong&gt;, percebi que boa parte do tratamento das saídas dos comandos podia ser feita por funções em Go: reconhecer formatos, contar testes e separar o que passou do que falhou. Esse processamento segue regras e acontece localmente, sem chamar um modelo de IA para resumir o resultado. A informação já chega mais enxuta ao agente.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Exemplo didático:&lt;/strong&gt; você pede ao agente para corrigir uma falha em um projeto Go. Ele investiga o código, faz a alteração e executa os testes. A resposta do terminal também entra no contexto. É nessa etapa que o compactador pode entregar uma versão mais curta, preservando o código de saída e os detalhes de falhas.&lt;/p&gt;

&lt;p&gt;No Claude Code configurado, o hook encaminha comandos compatíveis e associa a execução à sessão. Para experimentar a compactação manualmente, fora desse fluxo:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;downshift compactor -- go &lt;span class="nb"&gt;test&lt;/span&gt; ./...
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Uma execução local de &lt;strong&gt;10 de novembro&lt;/strong&gt;, com uma seleção de testes do Downshift e saída detalhada (&lt;code&gt;go test -v&lt;/code&gt;), mostra a diferença. Trechos reais:&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Antes:&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;=== RUN   TestStripColour
--- PASS: TestStripColour (0.00s)
=== RUN   TestScreenText
--- PASS: TestScreenText (0.00s)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Depois:&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Go test -v: PASS (5 passed, 0 failed, 0 skipped) in 0.187s
Subtests: 16 passed or skipped under those tests
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;A entrega completa caiu de &lt;strong&gt;2.006 para 271 bytes&lt;/strong&gt;, incluindo a indicação de recuperação: &lt;strong&gt;86,5% menos bytes nessa execução&lt;/strong&gt;. O original pôde ser recuperado com &lt;code&gt;downshift retrieve ID_DA_SUA_SAIDA&lt;/code&gt;. É uma demonstração local; esse percentual não mede tokens nem duração do plano Pro.&lt;/p&gt;

&lt;p&gt;O padrão passa a ser &lt;strong&gt;balanced&lt;/strong&gt;: cortes com perda só acima de um limite de tamanho, sempre com a saída completa recuperável via &lt;code&gt;retrieve&lt;/code&gt;. O &lt;strong&gt;lossless&lt;/strong&gt; é a opção conservadora, sem cortes com perda; o &lt;strong&gt;aggressive&lt;/strong&gt; faz cortes mais intensos. Nas minhas medições mais recentes no Claude Code, usei lossless; antes, usava balanced.&lt;/p&gt;

&lt;p&gt;Também há situações em que o Compactor devolve a saída inteira. Por exemplo: em uma execução de testes com falha, uma linha que o parser não reconhece antes do bloco de erros pode impedir a compactação. O agente recebe o resultado original, com os detalhes necessários para investigar. Esse comportamento está descrito na &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/features/compaction.md#failing-runs" rel="noopener noreferrer"&gt;documentação de compactação de testes com falha&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fl1p689vdsq7e41zwqiul.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fl1p689vdsq7e41zwqiul.png" alt="Fluxo de compactação da saída de comandos no Downshift" width="799" height="350"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  Roteamento de modelos: capacidade proporcional à tarefa
&lt;/h2&gt;

&lt;p&gt;Na mesma correção, o agente principal pode delegar uma parte do trabalho a um &lt;strong&gt;subagente&lt;/strong&gt;. Renomear uma variável e avaliar uma mudança de arquitetura exigem capacidades diferentes. O Downshift aplica as regras configuradas às escolhas do agente principal, considerando os modelos conhecidos da sessão.&lt;/p&gt;

&lt;p&gt;Essa etapa acontece localmente, sem consultar outro modelo de linguagem. Quando não é possível estabelecer uma escolha segura, o modelo solicitado é mantido. O modelo da sessão principal permanece o mesmo.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4im1agvq8hvi8un3vu1n.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F4im1agvq8hvi8un3vu1n.png" alt="Diagrama do roteamento de subagentes e verificação de política do Downshift" width="800" height="275"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Na sessão instrumentada, &lt;code&gt;downshift session --why&lt;/code&gt; mostra a árvore de subagentes e seus motivos; &lt;code&gt;downshift report&lt;/code&gt; reúne os dados de consumo disponíveis. Essas informações ajudam a investigar saídas e decisões de delegação antes de mudar a configuração. A chamada manual da demonstração acima não é associada à sessão nem entra nesse painel.&lt;/p&gt;

&lt;h2&gt;
  
  
  Computer Use: o “Opalão” no consumo de tokens
&lt;/h2&gt;

&lt;p&gt;Outra descoberta foi como o &lt;strong&gt;Computer Use&lt;/strong&gt; pode virar um “Opalão” no consumo de tokens. O agente consulta a interface, executa uma ação e precisa olhar de novo para conferir o resultado. Para trabalhar com o Agent Desktop, estudei as árvores de acessibilidade: estruturas que descrevem textos, botões e campos do aplicativo.&lt;/p&gt;

&lt;p&gt;Pense em um formulário: depois de clicar em “Salvar”, o agente precisa conferir a confirmação. Receber toda a descrição da janela novamente repete informações que não mudaram. Na &lt;strong&gt;v0.13.0, de 9 de novembro&lt;/strong&gt;, estendi a compactação a essas leituras: o Downshift encurta a primeira descrição e pode enviar só as alterações, chamadas de &lt;em&gt;deltas&lt;/em&gt;, nas seguintes. A leitura completa continua recuperável. Com menos texto repetido no contexto, o agente pode gastar menos tokens para acompanhar a mesma interface.&lt;/p&gt;

&lt;p&gt;Um teste sintético de três leituras registrou &lt;strong&gt;84,9% menos bytes&lt;/strong&gt;. A economia de tokens em um desktop real ainda precisa ser medida. A integração cobre leituras pela linha de comando do Agent Desktop; seus resultados via MCP não são compactados. Os detalhes estão no &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/guides/agent-desktop.md" rel="noopener noreferrer"&gt;guia da integração&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Economia de tokens: o que os benchmarks demonstraram
&lt;/h2&gt;

&lt;p&gt;No &lt;strong&gt;Claude Code&lt;/strong&gt;, um estudo controlado com &lt;strong&gt;46 execuções em quatro grupos&lt;/strong&gt; registrou &lt;strong&gt;24,1% menos tokens por execução aceita&lt;/strong&gt; com roteamento, comparado ao modo nativo &lt;code&gt;opusplan&lt;/code&gt;. O grupo roteado passou nos testes em &lt;strong&gt;12 de 12 execuções&lt;/strong&gt;; o controle, em 10 de 11. As tentativas que falharam entram na conta.&lt;/p&gt;

&lt;p&gt;Esse resultado mede roteamento; o compactador estava desligado nos dois grupos comparados. Foram tarefas mecânicas delegadas, com um operador, em 21 de outubro, antes de mudanças posteriores no roteamento. O &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/evidence/four-arm-mechanical-2026-10-21.md" rel="noopener noreferrer"&gt;benchmark completo&lt;/a&gt; documenta a versão e o método.&lt;/p&gt;

&lt;p&gt;No &lt;strong&gt;KiroCrew&lt;/strong&gt;, um ensaio de uso real registrou &lt;strong&gt;até cerca de 53% menos tokens por tarefa&lt;/strong&gt;, combinando roteamento e compactação. Foram seis tarefas de controle em uma sessão de várias horas: uma evidência preliminar, que não permite atribuir todo o ganho ao roteamento. Veja o &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/guides/evidence.md#subsequent-controlled-and-real-use-batteries-2026-10-21" rel="noopener noreferrer"&gt;registro e suas limitações&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Na compactação, o &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/reference/bench.md" rel="noopener noreferrer"&gt;benchmark de 110 casos sintéticos&lt;/a&gt; registrou &lt;strong&gt;67,1% menos bytes&lt;/strong&gt;, com recuperação da saída completa habilitada. &lt;strong&gt;Bytes, tokens e custo são medidas diferentes.&lt;/strong&gt; Esses percentuais vêm de cenários distintos e não devem ser somados.&lt;/p&gt;

&lt;h2&gt;
  
  
  Como instalar e testar o Downshift
&lt;/h2&gt;

&lt;p&gt;Siga o &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/guides/install.md" rel="noopener noreferrer"&gt;guia de instalação&lt;/a&gt; e, no seu repositório, execute:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;downshift setup
downshift doctor
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O setup apresenta as mudanças antes de aplicá-las; o doctor verifica a configuração. Escolha uma tarefa recorrente, como a correção com testes do exemplo, e compare consumo, tempo para concluir e correções manuais com e sem Downshift. Inclua as tentativas que deram errado: o que importa é chegar a uma entrega aceita.&lt;/p&gt;

&lt;p&gt;A integração varia entre Claude Code, Codex, OpenCode, Cursor e outros ambientes. Confira a &lt;a href="https://github.com/tiagovilasboas/downshift-ai/blob/main/docs/reference/harness-matrix.md" rel="noopener noreferrer"&gt;matriz de suporte&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Fiz o Downshift com carinho, partindo de uma dificuldade minha e pensando em quem também passa por isso. Compartilhei o código e os aprendizados para que esse trabalho possa beneficiar outras pessoas também.&lt;/p&gt;

&lt;p&gt;Fiquem à vontade para conhecer o projeto, experimentar e contribuir com ideias ou melhorias. Se usarem nos projetos de vocês, compartilhem os resultados: quero saber como ele funciona no dia a dia de cada um. Espero que seja útil para vocês. &lt;strong&gt;Façam bom proveito!&lt;/strong&gt; 💚&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Projeto:&lt;/strong&gt; &lt;a href="https://github.com/tiagovilasboas/downshift-ai" rel="noopener noreferrer"&gt;github.com/tiagovilasboas/downshift-ai&lt;/a&gt;&lt;/p&gt;

</description>
      <category>braziliandevs</category>
      <category>claudecode</category>
      <category>ai</category>
      <category>tokens</category>
    </item>
    <item>
      <title>Além do LLM: como tirar seu projeto de IA do protótipo e colocar em produção</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Mon, 05 Oct 2026 15:16:34 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/alem-do-llm-como-tirar-seu-projeto-de-ia-do-prototipo-e-colocar-em-producao-4295</link>
      <guid>https://dev.to/tiagovilasboas/alem-do-llm-como-tirar-seu-projeto-de-ia-do-prototipo-e-colocar-em-producao-4295</guid>
      <description>&lt;p&gt;Construí o &lt;a href="https://github.com/tiagovilasboas/downshift" rel="noopener noreferrer"&gt;Downshift&lt;/a&gt; porque mandar toda tarefa do agente de código para o modelo mais caro é pagar sênior para carimbar envelope. É um hook open-source: quando o Claude Code cria um subagente, ele lê a tarefa e escolhe o modelo. Renomear variável vai pro Haiku; desenhar algoritmo fica no Opus (&lt;a href="https://github.com/tiagovilasboas/downshift#how-it-works" rel="noopener noreferrer"&gt;README&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;O difícil foi provar o valor que ele entrega. Meus primeiros números vieram de um dia de uso pessoal. Com um braço de controle e um conjunto de testes separado, o resultado foi mais modesto: em trabalho mecânico delegado, 12 de 12 tarefas passaram nos dois braços e o custo caiu 12%; em correções reais, o roteador rebaixou 3 de 34 subagentes e a diferença de custo não é dele (&lt;a href="https://github.com/tiagovilasboas/downshift/blob/main/docs/evidence/subagent-routing-ab-2026-10-15.md" rel="noopener noreferrer"&gt;A/B de 15/10/2026&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;A pergunta deixou de ser "qual modelo?" e virou "o que o código garante, e como provo?": &lt;strong&gt;o modelo pensa, o código governa, a avaliação prova.&lt;/strong&gt; O texto reúne decisões e critérios para levar uma feature com LLM à produção. O Downshift é o caso real; o delivery, um exemplo didático. Meus harness e modelos estão &lt;a href="https://dev.to/tiagovilasboas/cursor-kiro-chatgpt-tres-harness-uma-arquitetura-7li"&gt;neste post&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Índice:&lt;/strong&gt; 1. Simples primeiro · 2. Provedor isolado · 3. Roteamento · 4. Prompt · 5. RAG · 6. Agentes · 7. Checklist&lt;/p&gt;

&lt;h2&gt;
  
  
  1. Comece pela solução mais simples
&lt;/h2&gt;

&lt;p&gt;Antes de escolher um modelo, pergunte qual é a solução mais simples que atende aos requisitos de qualidade e segurança. Avance só quando a opção anterior não resolver.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F89j8ugxv3etkhrg1aqdc.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F89j8ugxv3etkhrg1aqdc.png" alt="Da esquerda para a direita: regras resolvem casos previsíveis; classificadores tratam intenções conhecidas; tarefas ainda ambíguas seguem para um LLM." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Da esquerda para a direita: regras → classificador → LLM. Encerre o caminho assim que houver uma solução suficiente.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;No Downshift, sinais determinísticos definem o tier, e um reforço local por hash FNV pode elevá-lo. O MiniLM externo saiu no &lt;a href="https://github.com/tiagovilasboas/downshift/pull/142" rel="noopener noreferrer"&gt;PR #142&lt;/a&gt;. Um LLM classificador reconheceria vocabulário novo, mas acrescentaria custo e latência a cada spawn.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Isole o provedor e valide a saída
&lt;/h2&gt;

&lt;p&gt;Adoto a distinção da &lt;a href="https://martinfowler.com/articles/harness-engineering.html" rel="noopener noreferrer"&gt;Birgitta Böckeler&lt;/a&gt;: o harness combina &lt;strong&gt;guias&lt;/strong&gt;, que orientam antes da ação, e &lt;strong&gt;sensores&lt;/strong&gt;, que conferem depois. Teste e schema são sensores computacionais; juiz-LLM é inferencial, mais caro e menos determinístico.&lt;/p&gt;

&lt;p&gt;O provedor fica atrás de um adaptador; seu código valida e decide o destino da falha:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight go"&gt;&lt;code&gt;&lt;span class="k"&gt;package&lt;/span&gt; &lt;span class="n"&gt;triage&lt;/span&gt;

&lt;span class="k"&gt;import&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;
    &lt;span class="s"&gt;"encoding/json"&lt;/span&gt;
    &lt;span class="s"&gt;"errors"&lt;/span&gt;
    &lt;span class="s"&gt;"fmt"&lt;/span&gt;
&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;type&lt;/span&gt; &lt;span class="n"&gt;Triage&lt;/span&gt; &lt;span class="k"&gt;struct&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="n"&gt;Intent&lt;/span&gt;     &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="kt"&gt;string&lt;/span&gt; &lt;span class="s"&gt;`json:"intent"`&lt;/span&gt;
    &lt;span class="n"&gt;NeedsHuman&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="kt"&gt;bool&lt;/span&gt;   &lt;span class="s"&gt;`json:"needs_human"`&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;

&lt;span class="k"&gt;func&lt;/span&gt; &lt;span class="n"&gt;Validate&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;raw&lt;/span&gt; &lt;span class="p"&gt;[]&lt;/span&gt;&lt;span class="kt"&gt;byte&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;Triage&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="kt"&gt;error&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;var&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt; &lt;span class="n"&gt;Triage&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt; &lt;span class="o"&gt;:=&lt;/span&gt; &lt;span class="n"&gt;json&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Unmarshal&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;raw&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;&amp;amp;&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt; &lt;span class="o"&gt;!=&lt;/span&gt; &lt;span class="no"&gt;nil&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;Triage&lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt; &lt;span class="n"&gt;err&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="k"&gt;if&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Intent&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="no"&gt;nil&lt;/span&gt; &lt;span class="o"&gt;||&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;NeedsHuman&lt;/span&gt; &lt;span class="o"&gt;==&lt;/span&gt; &lt;span class="no"&gt;nil&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;Triage&lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt; &lt;span class="n"&gt;errors&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;New&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"required field missing"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
    &lt;span class="k"&gt;switch&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Intent&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;case&lt;/span&gt; &lt;span class="s"&gt;"status"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;"delay"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;"refund"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="s"&gt;"other"&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="no"&gt;nil&lt;/span&gt;
    &lt;span class="k"&gt;default&lt;/span&gt;&lt;span class="o"&gt;:&lt;/span&gt;
        &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="n"&gt;Triage&lt;/span&gt;&lt;span class="p"&gt;{},&lt;/span&gt; &lt;span class="n"&gt;fmt&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Errorf&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s"&gt;"invalid intent: %q"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="o"&gt;*&lt;/span&gt;&lt;span class="n"&gt;result&lt;/span&gt;&lt;span class="o"&gt;.&lt;/span&gt;&lt;span class="n"&gt;Intent&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
    &lt;span class="p"&gt;}&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Valide sempre.&lt;/strong&gt; Modo JSON garante JSON válido, não o seu schema. Structured Outputs com &lt;code&gt;strict&lt;/code&gt; restringe a saída ao schema suportado (&lt;a href="https://platform.openai.com/docs/guides/structured-outputs" rel="noopener noreferrer"&gt;OpenAI&lt;/a&gt;); o código ainda precisa tratar recusas e respostas incompletas e verificar o conteúdo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fixe o snapshot.&lt;/strong&gt; Alias aponta pro snapshot mais novo e muda quando o provedor atualiza (&lt;a href="https://docs.anthropic.com/en/docs/about-claude/models/overview" rel="noopener noreferrer"&gt;Anthropic&lt;/a&gt;). Avalie antes de trocar e teste o fallback com os mesmos casos.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Guia e sensor.&lt;/strong&gt; O schema no prompt é guia; a validação é sensor computacional, roda em toda chamada. &lt;strong&gt;Falha do roteador:&lt;/strong&gt; o Downshift é fail-open: se o roteador quebra, o subagente roda com o modelo pedido. Essa escolha preserva a execução; autorização e limites de orçamento continuam obrigatórios no sistema que executa a tarefa. &lt;strong&gt;Trade-off:&lt;/strong&gt; adaptador próprio com um ou dois provedores, gateway (LiteLLM, OpenRouter) quando vários times reinventarem retry e log.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Roteie por tarefa, com piso de risco
&lt;/h2&gt;

&lt;p&gt;As regras do Downshift:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Sem confiança, preserve o modelo solicitado:&lt;/strong&gt; a abstenção evita uma troca sem evidência suficiente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Piso de risco:&lt;/strong&gt; tarefa simples que toca auth, segredo, pagamento, PII ou concorrência sobe no mínimo pro tier intermediário (&lt;a href="https://github.com/tiagovilasboas/downshift/blob/main/docs/reference/complexity-weights.md" rel="noopener noreferrer"&gt;complexity-weights&lt;/a&gt;).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Números&lt;/strong&gt; (&lt;a href="https://github.com/tiagovilasboas/downshift/blob/main/benchmark/report.md" rel="noopener noreferrer"&gt;benchmark/report.md&lt;/a&gt;):&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Rede de regressão, 200 tarefas:&lt;/strong&gt; 69,0% de acerto de tier (IC 95% de 62,5% a 75,5%), 0 de 50 complexas no pequeno, 49 de 100 simples no intermediário: errar para cima foi escolha. É conjunto de ajuste, não prova generalização.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Splits só de avaliação&lt;/strong&gt; (&lt;a href="https://github.com/tiagovilasboas/downshift/pull/123" rel="noopener noreferrer"&gt;#123&lt;/a&gt;): 53,0% (n=100) e 41,7% (n=120, cego). A maioria dos erros é abstenção; confiante, acerta 35 de 37 e 22 de 28.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;40 tarefas Go com teste:&lt;/strong&gt; com modelo fixo, 40/40 (fronteira), 31/40 (intermediário), 27/40 (pequeno). No tier escolhido pelo classificador, 37/40; era 38/40 e caiu de propósito quando o boost semântico parou de inflar prompt sem sinal (&lt;a href="https://github.com/tiagovilasboas/downshift/pull/125" rel="noopener noreferrer"&gt;#125&lt;/a&gt;).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;O hook pede, o harness decide.&lt;/strong&gt; Reescrita observada no Claude Code e no Antigravity; inferida no Codex; não confirmada no Cursor; no KiroCrew o hook só bloqueia e pede retry (&lt;a href="https://github.com/tiagovilasboas/downshift#harness-support" rel="noopener noreferrer"&gt;harness support&lt;/a&gt;).&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Prompt é contrato, não pedido
&lt;/h2&gt;

&lt;p&gt;Prompt bom diz o que entra, o que sai, o que é proibido e como saber se deu certo. Para conhecimento externo, avalie recuperação antes de fine-tuning. No estudo de &lt;a href="https://arxiv.org/abs/2312.05934" rel="noopener noreferrer"&gt;Ovadia et al.&lt;/a&gt;, RAG teve resultado superior para injeção de conhecimento nas condições avaliadas. Isso não estabelece uma regra para toda tarefa: recuperar fontes, ajustar comportamento e executar ferramentas resolvem necessidades diferentes.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Caso&lt;/strong&gt; (&lt;a href="https://dev.to/tiagovilasboas/prompt-appsec-4-gaps-autorizacao-1k77"&gt;post completo&lt;/a&gt;). "Audite a segurança" devolveu 23 alertas, 22 descartáveis. Reescrito como contrato:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;- Achado sem arquivo:linha é descartado.
- CWE ou CVE inventado encerra a sessão.
- Denominador obrigatório: "1 de 174 rotas", não "achei um bug".
- Uma invariante falsificável por rodada: "toda rota que devolve pedido filtra pelo user_id da sessão?"
- Silêncio é resultado válido.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Resultado: 1 IDOR real em 174 rotas, corrigido antes de produção. No mesmo formato, dois reports meus de hardening viraram correção dos mantenedores: Formbricks (&lt;a href="https://github.com/formbricks/formbricks/issues/9081" rel="noopener noreferrer"&gt;issue&lt;/a&gt;, &lt;a href="https://github.com/formbricks/formbricks/pull/9553" rel="noopener noreferrer"&gt;PR&lt;/a&gt;) e Dub (&lt;a href="https://github.com/dubinc/dub/issues/4415" rel="noopener noreferrer"&gt;issue&lt;/a&gt;, &lt;a href="https://github.com/dubinc/dub/pull/4449" rel="noopener noreferrer"&gt;PR&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Guia e sensor.&lt;/strong&gt; O contrato é guia; descartar achado sem &lt;code&gt;arquivo:linha&lt;/code&gt; é sensor computacional.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. RAG: consultar a base antes de responder
&lt;/h2&gt;

&lt;p&gt;Pense em um atendente que consulta o manual da empresa antes de orientar o cliente. Ele precisa encontrar a regra certa e explicar como ela se aplica àquela situação.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;RAG significa Retrieval-Augmented Generation&lt;/strong&gt;, ou geração aumentada por recuperação. É um &lt;strong&gt;padrão de arquitetura que combina busca com geração de respostas&lt;/strong&gt;. O sistema consulta uma base de conhecimento — manuais, políticas ou FAQs — e entrega os trechos encontrados ao modelo junto da pergunta. Isso fornece contexto sem treinar o modelo de novo (&lt;a href="https://www.ibm.com/think/topics/retrieval-augmented-generation" rel="noopener noreferrer"&gt;IBM&lt;/a&gt;, &lt;a href="https://aws.amazon.com/what-is/retrieval-augmented-generation/" rel="noopener noreferrer"&gt;AWS&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Exemplo didático:&lt;/strong&gt; um cliente pergunta sobre cancelamento no delivery. O sistema busca a política vigente na região dele e o modelo explica a regra, citando a fonte. Buscar a política de outra região produz uma orientação errada; mesmo com o trecho certo, o modelo pode distorcê-lo.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Para produto:&lt;/strong&gt; quem mantém a fonte, quando a busca recebe uma atualização e quem pode consultar cada documento? Meça dúvidas resolvidas corretamente, tempo de resposta e custo por atendimento. RAG ajuda a responder com informação específica e verificável, mas não elimina erros (&lt;a href="https://www.ibm.com/think/topics/retrieval-augmented-generation" rel="noopener noreferrer"&gt;IBM&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fahduyj6qllzakq07jjyw.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fahduyj6qllzakq07jjyw.png" alt="Fluxo RAG: documentos divididos em trechos, filtro por metadados, busca lexical e vetorial combinadas, reordenação e resposta com citações. Abaixo, avaliações independentes da busca e da geração." width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Acima: preparar trechos → filtrar região, vigência e acesso → buscar → ordenar → responder com fontes. Abaixo: conferir a busca à esquerda e a resposta à direita.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Neste desenho, &lt;strong&gt;BM25&lt;/strong&gt; busca palavras; &lt;strong&gt;embeddings&lt;/strong&gt; representam o texto em números para buscar por significado; &lt;strong&gt;RRF&lt;/strong&gt; combina as listas; o &lt;strong&gt;reranker&lt;/strong&gt; reordena os candidatos conforme a pergunta (&lt;a href="https://www.anthropic.com/engineering/contextual-retrieval" rel="noopener noreferrer"&gt;Anthropic&lt;/a&gt;). São escolhas de implementação: RAG também pode usar busca por palavras, sem banco vetorial (&lt;a href="https://learn.microsoft.com/azure/ai-studio/concepts/retrieval-augmented-generation" rel="noopener noreferrer"&gt;Microsoft&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;O reranker deste desenho avalia 20 candidatos. Se faltar evidência, diga que não sabe ou encaminhe a dúvida. Ajuste esse critério na validação; reserve perguntas inéditas, o &lt;strong&gt;holdout&lt;/strong&gt;, para a medição final.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Duas avaliações, separadas:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Busca:&lt;/strong&gt; encontrou a informação certa? Hit rate@k mede se há ao menos um trecho relevante entre os k primeiros; recall@k mede quantos dos relevantes vieram; MRR considera a posição do primeiro acerto (&lt;a href="https://nlp.stanford.edu/IR-book/html/htmledition/evaluation-of-ranked-retrieval-results-1.html" rel="noopener noreferrer"&gt;IR book&lt;/a&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Resposta:&lt;/strong&gt; usou bem o que encontrou? Meça fidelidade às fontes (&lt;em&gt;faithfulness&lt;/em&gt;), se a citação sustenta aquela frase e se o sistema admite quando falta informação, sem recusar perguntas que poderia responder (&lt;a href="https://arxiv.org/abs/2309.15217" rel="noopener noreferrer"&gt;RAGAS&lt;/a&gt;).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Caso: um laboratório medido.&lt;/strong&gt; Central de ajuda de um delivery fictício (25 seções com região e vigência), 44 perguntas rotuladas e 18 novas como &lt;strong&gt;holdout&lt;/strong&gt;. Neste artigo, R@3 é a proporção de buscas que encontram ao menos um trecho relevante entre os três primeiros resultados. No holdout:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Configuração&lt;/th&gt;
&lt;th&gt;Embedding leve (R@3)&lt;/th&gt;
&lt;th&gt;Embedding multilíngue (R@3)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Por palavras (BM25)&lt;/td&gt;
&lt;td&gt;0,69&lt;/td&gt;
&lt;td&gt;0,69&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Por significado (embeddings)&lt;/td&gt;
&lt;td&gt;0,62&lt;/td&gt;
&lt;td&gt;0,75&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Palavras + significado&lt;/td&gt;
&lt;td&gt;0,69&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;0,94&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;O embedding decide se a híbrida vale:&lt;/strong&gt; com o leve, ela não passou do BM25.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Metadado decide o 1º lugar.&lt;/strong&gt; SP e RJ têm políticas quase iguais; sem filtro de região, o acerto regional cai de 100% para 50%.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Quase publiquei número inflado.&lt;/strong&gt; Um glossário escrito olhando as falhas levou o recall@1 de 0,65 para 0,88 no ajuste, e no holdout só de 0,56 para 0,62. Overfitting, a mesma lição do Downshift: 69% no conjunto de ajuste, 53% no cego.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Semelhança não garante resposta.&lt;/strong&gt; O score de cosseno mede proximidade entre as representações dos textos. O limiar que recusa todas as sem resposta recusa 47% das respondíveis.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Geração, medida em 17/10/2026.&lt;/strong&gt; Busca fixa, 62 perguntas, 174 casos por prompt, prompt ingênuo contra prompt de contrato. Gerador &lt;code&gt;gemini-2.5-flash-lite&lt;/code&gt;, juiz &lt;code&gt;gpt-4o-mini&lt;/code&gt;, ambos com ZDR.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Citação correta, nos 112 casos avaliados para esse critério:&lt;/strong&gt; 0/112 no ingênuo, 112/112 no contrato, sem ID inventado.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Abstenção, nos 62 casos sem evidência:&lt;/strong&gt; 59/62 (95,2%) nos dois prompts, com 0 recusa indevida nas perguntas respondíveis.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A fidelidade às fontes não separou os prompts&lt;/strong&gt;, por efeito teto. E o juiz concordou com o rótulo humano em só 78,8%: dos 9 "infiel" que ele marcou, 2 eram reais. Juiz sozinho é piso, não medida.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Custo:&lt;/strong&gt; US$ 0,03 por rodada.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Limites.&lt;/strong&gt; Busca: amostra pequena (uma pergunta muda 6 pontos), sem reranker. Geração: corpus fictício, 1 gerador, 1 juiz, 1 rodada, busca não medida nesta rodada. As 62 perguntas e os 174 casos são unidades diferentes; os resultados de citação e abstenção usam subconjuntos próprios. Para reproduzir a rodada, ainda falta publicar a composição dos casos e o critério operacional de citação correta. Um ID existente, sozinho, não comprova que a fonte sustenta a afirmação.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Quando vale a complexidade?&lt;/strong&gt; Comece com arquivos organizados e busca textual; para uma base pequena, o conteúdo direto no contexto pode bastar (&lt;a href="https://www.anthropic.com/engineering/contextual-retrieval" rel="noopener noreferrer"&gt;Anthropic&lt;/a&gt;). Busca híbrida e reranking acrescentam preparação, manutenção, custo e latência. Adote quando as avaliações mostrarem ganho suficiente. Compare com as mesmas perguntas; mantenha vigência e controle de acesso em qualquer opção.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Agente precisa de parada, humano e segurança fora do prompt
&lt;/h2&gt;

&lt;p&gt;Num &lt;strong&gt;workflow&lt;/strong&gt;, o código decide o próximo passo; num &lt;strong&gt;agente&lt;/strong&gt;, o modelo decide e chama tools em loop (&lt;a href="https://www.anthropic.com/engineering/building-effective-agents" rel="noopener noreferrer"&gt;Anthropic&lt;/a&gt;). Passo conhecido é código; agente só com ambiguidade real e parada explícita (passos, orçamento, timeout, humano).&lt;/p&gt;

&lt;p&gt;Um jeito simples de explicar esse ciclo é o &lt;strong&gt;BDI&lt;/strong&gt;. Aqui, ele é um recurso visual, não uma arquitetura que todo agente segue: crenças são o que o agente sabe sobre a situação; desejos, o que quer alcançar; intenções, o plano que escolheu. Quando a ferramenta responde, o agente atualiza o contexto e decide o próximo passo.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjkxfao91tlhzoy40dpft.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fjkxfao91tlhzoy40dpft.png" alt="Ciclo BDI de um agente: crenças, desejos e intenções levam a uma ação; o resultado atualiza o contexto para a próxima decisão." width="800" height="375"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Em produção, esse ciclo precisa de permissão, schema, orçamento, aprovação humana conforme o risco e sensores.&lt;/p&gt;

&lt;p&gt;Evite uma ferramenta genérica como &lt;code&gt;execute_sql(query)&lt;/code&gt;. A ferramenta deve obter o usuário da sessão, validar os argumentos e pedir aprovação humana para escritas de alto risco.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Argumento passa por schema&lt;/strong&gt; antes de executar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escrita&lt;/strong&gt; exige idempotência e, conforme o risco, humano (reembolso acima de R$ X).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Segurança fora do prompt.&lt;/strong&gt; "Não revele dados" no system prompt não é controle. Injeção pode vir indireta, num documento do RAG ou e-mail (&lt;a href="https://genai.owasp.org/llmrisk/llm01-prompt-injection/" rel="noopener noreferrer"&gt;OWASP LLM01&lt;/a&gt;). Autorização no código, segredo fora do contexto.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;No Downshift&lt;/strong&gt;, o hook lê a tarefa só em memória, não guarda prompt, e a telemetria registra o tipo de subagente sem o nome de agente customizado (&lt;a href="https://github.com/tiagovilasboas/downshift/pull/124" rel="noopener noreferrer"&gt;#124&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Caso.&lt;/strong&gt; O &lt;a href="https://github.com/tiagovilasboas/agentic-code-review" rel="noopener noreferrer"&gt;Agentic Code Review&lt;/a&gt; segue isso com sensores computacionais: IDOR alto ou segredo é &lt;strong&gt;BLOCK&lt;/strong&gt;, o diff é dado não confiável e achado sem &lt;code&gt;path:line&lt;/code&gt; não sai.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Trade-off.&lt;/strong&gt; Aprovação frequente, sozinha, não justifica automatizar. Mova a decisão pro código quando houver uma regra verificável, cobertura das exceções e um destino definido para os casos que exigem julgamento humano.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Checklist antes de produção
&lt;/h2&gt;

&lt;p&gt;HTTP 200 com resposta inventada é normal em LLM; qualidade se prova com casos fixos e checagem executável a cada troca. Juiz-LLM só onde não há checagem determinística, calibrado contra rótulo humano: ele tem viés de posição e verbosidade (&lt;a href="https://arxiv.org/abs/2306.05685" rel="noopener noreferrer"&gt;Zheng et al.&lt;/a&gt;), e na seção 5 bateu com o humano em só 78,8%.&lt;/p&gt;

&lt;p&gt;Checklist copiável: &lt;a href="https://gist.github.com/tiagovilasboas/3928f12235fecbe09500c7cf70bbe275" rel="noopener noreferrer"&gt;gist&lt;/a&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[ ] Existe uma versão sem LLM para o caso mais frequente?
[ ] Saída validada por schema; falha tem destino (subir modelo ou humano)
[ ] Snapshot do modelo fixado; fallback testado com os mesmos casos
[ ] Timeout, retry com backoff em 429/5xx, idempotência em toda escrita
[ ] Orçamento por chamada e por conversa; limite de passos no agente
[ ] Tools com menor privilégio; user_id da sessão; humano no irreversível
[ ] RAG: busca medida (hit rate@k, MRR) e geração medida (faithfulness, citação, abstenção), em holdout
[ ] Conjunto de avaliação roda num comando, no CI, antes de cada troca
[ ] Trace por execução: modelo, versão do prompt, tokens, latência, resultado
[ ] Métrica de produção: custo por tarefa resolvida, não por token
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Da avaliação ao lançamento.&lt;/strong&gt; Defina os limites antes de avaliar. Exemplo didático para um assistente de FAQ: nenhuma exposição indevida nos casos de segurança, pelo menos 95% de respostas corretas no conjunto acordado e latência p95 de até 5 segundos. Os valores dependem do produto e não foram validados neste laboratório. Regressão bloqueia o lançamento. Comece com uma parcela pequena do tráfego e compare qualidade, latência e custo por tarefa; se os limites forem violados, reverta modelo e prompt para a versão anterior. Quem opera o serviço precisa ser dono desse acompanhamento e do rollback.&lt;/p&gt;




&lt;p&gt;Do protótipo ao produto, o que mudou não foi o modelo: foi dar a cada risco uma guia e um sensor, e medir. No RAG, a geração agora tem número; no Downshift, a economia em uso geral ainda não. Gaps abertos: medir busca e geração na mesma rodada, testar outro gerador e calibrar o juiz. A próxima experiência proposta compara geradores com as mesmas perguntas, busca e critérios, registrando qualidade, latência, falhas e custo por tarefa. Para testes de programação no OpenCode, pretendo experimentar &lt;strong&gt;MiMo-V2.6-Flash Free, Ling 3.1 Flash Free, Nemotron 3.5 Lightning Free e Big Pickle&lt;/strong&gt;, conforme a disponibilidade em &lt;code&gt;/models&lt;/code&gt; (&lt;a href="https://docs.opencode.ai/docs/zen/" rel="noopener noreferrer"&gt;OpenCode Zen&lt;/a&gt;). São candidatos a testar; os resultados acima continuam sendo do Gemini 2.5 Flash Lite como gerador e GPT-4o Mini como juiz.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Para os comentários:&lt;/strong&gt; no sistema com LLM que você mantém, qual sensor diz que ele funciona? E se você já calibrou juiz-LLM contra rótulo humano, quanto deu a concordância?&lt;/p&gt;

</description>
      <category>ai</category>
      <category>llm</category>
      <category>architecture</category>
      <category>braziliandevs</category>
    </item>
    <item>
      <title>I Built a Full PWA Game in One Day with Claude Opus 5.5 and Claude Code (Here Is the Real Token Cost &amp; Harness Setup)</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Sun, 04 Oct 2026 18:27:45 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/i-built-a-full-pwa-game-in-one-day-with-claude-opus-55-and-claude-code-here-is-the-real-token-41p7</link>
      <guid>https://dev.to/tiagovilasboas/i-built-a-full-pwa-game-in-one-day-with-claude-opus-55-and-claude-code-here-is-the-real-token-41p7</guid>
      <description>&lt;p&gt;On Sunday I sat down to turn a three-sentence idea into a browser game, &lt;strong&gt;Montanha: Zero Day&lt;/strong&gt;. A prompt that short is a photo of a cabinet: you can see the shape, and you still have no jig for the cuts.&lt;/p&gt;

&lt;p&gt;Without the jig, the model invents the workshop. A framework, a bundler, a new folder layout, and the token limit goes into the second and third attempt. I have watched that happen. The hard part is not the idea. It is holding the cut after the first structure comes out wrong.&lt;/p&gt;

&lt;p&gt;What held it was not a longer prompt. A harness already sits next to the repo: guides before the model writes, sensors after it says the work is done. Opus 5.5, through Claude Code, used about half of my daily allotment on the usage panel and shipped the game. The hero is me (Montanha), the heroine is Gle, and the villain is a ransomware called RANSOM-TITAN. It runs in the browser and on phones, offline, as a PWA.&lt;/p&gt;

&lt;p&gt;👉 &lt;strong&gt;Play it live:&lt;/strong&gt; &lt;a href="https://tiagovilasboas.github.io/montanha-zero-day/" rel="noopener noreferrer"&gt;tiagovilasboas.github.io/montanha-zero-day&lt;/a&gt; (Portuguese only when the browser language is Portuguese and the timezone is Brazil; English otherwise)&lt;br&gt;&lt;br&gt;
👉 &lt;strong&gt;Source Code:&lt;/strong&gt; &lt;a href="https://github.com/tiagovilasboas/montanha-zero-day" rel="noopener noreferrer"&gt;github.com/tiagovilasboas/montanha-zero-day&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcnianh2pgumiepj47hjz.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fcnianh2pgumiepj47hjz.webp" alt="Montanha: Zero Day Title Screen" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  The Initial Prompt: Less than You Think
&lt;/h2&gt;

&lt;p&gt;People often ask what kind of 5-page prompt was required to spin up an entire game from scratch. The reality? &lt;strong&gt;Almost nothing.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;The kickoff prompt was surprisingly concise:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;em&gt;"Build a cyberpunk Mega Man X–style platformer game in pure JavaScript (ES modules) with canvas. The hero is Montanha (backpack jetpack, cybernetic hacking watch), the heroine is Gle, and the final boss is a ransomware virus named RANSOM-TITAN. It needs to run offline as a PWA on mobile and desktop."&lt;/em&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;How can a model go from a 3-sentence prompt to 24 modular ES architecture files without derailing into chaos or hallucinated spaghetti code?&lt;/p&gt;

&lt;p&gt;The secret wasn't prompt engineering. It was &lt;strong&gt;Harness Engineering&lt;/strong&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  Built on Top of a Central Engineering Harness
&lt;/h3&gt;

&lt;p&gt;Rather than dumping monolithic instructions into every conversation, my local setup is governed by a &lt;strong&gt;central harness core&lt;/strong&gt; (&lt;code&gt;harness-core&lt;/code&gt;). &lt;/p&gt;

&lt;p&gt;This harness provides continuous feedforward rules (&lt;em&gt;Guides&lt;/em&gt;) and automated feedback loops (&lt;em&gt;Sensors&lt;/em&gt;):&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Clean Architectural Boundaries:&lt;/strong&gt; Single Responsibility Principle (SRP) per module, decoupling state, physics, rendering, input, and audio into event-driven ES modules without framework overhead.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Behavioral Invariants:&lt;/strong&gt; Zero-assumptions development. The agent must verify facts through execution, inspect DOM/canvas states directly, and confirm before claiming completion.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Domain-Driven Commits:&lt;/strong&gt; Structured git workflows with atomic commits scoped strictly by semantic domains (&lt;code&gt;feat(hero)&lt;/code&gt;, &lt;code&gt;fix(gameplay)&lt;/code&gt;, &lt;code&gt;style(mobile)&lt;/code&gt;).&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;This is where Claude Code and Opus 5.5 were useful. Claude Code ran the local tools (Python, ffmpeg, git) and the cloud reasoning in the same session, and it stayed inside those constraints instead of adding a library the game did not need.&lt;/p&gt;




&lt;h2&gt;
  
  
  Opus 5.5 by the Numbers
&lt;/h2&gt;

&lt;p&gt;Anthropic released Opus 5.5 on September 22, 2026. The numbers below are &lt;strong&gt;reported by Anthropic&lt;/strong&gt;, so read them with healthy skepticism: there is no single, independent, identical-harness comparison across all frontier models yet.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Benchmark&lt;/th&gt;
&lt;th&gt;Opus 5.5&lt;/th&gt;
&lt;th&gt;Fable 5.1&lt;/th&gt;
&lt;th&gt;Opus 5&lt;/th&gt;
&lt;th&gt;GPT-6 Astra&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Terminal-Bench 4.0&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;66.4%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;55.8%&lt;/td&gt;
&lt;td&gt;52.3%&lt;/td&gt;
&lt;td&gt;57.9%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;FrontierCode v1.1&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;54.4%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;50.3%&lt;/td&gt;
&lt;td&gt;48.0%&lt;/td&gt;
&lt;td&gt;53.3%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CursorBench 4.0&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;57.8%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;51.8%&lt;/td&gt;
&lt;td&gt;46.6%&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GDPval-AA v2.1 (Elo)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;1846&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;1735&lt;/td&gt;
&lt;td&gt;1708&lt;/td&gt;
&lt;td&gt;1542&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Humanity's Last Exam (with tools)&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;67.7%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;65.6%&lt;/td&gt;
&lt;td&gt;63.6%&lt;/td&gt;
&lt;td&gt;57.2%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AutomationBench&lt;/td&gt;
&lt;td&gt;40.0%&lt;/td&gt;
&lt;td&gt;31.4%&lt;/td&gt;
&lt;td&gt;26.9%&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;41.4%&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Terminal-Bench-Science 0.1&lt;/td&gt;
&lt;td&gt;58.7%&lt;/td&gt;
&lt;td&gt;52.6%&lt;/td&gt;
&lt;td&gt;29.0%&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;64.6%&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Being objective: GPT-6 Astra leads on AutomationBench and Terminal-Bench-Science. And as noted in Vellum's analysis, certain science evaluation tasks dropped back to Opus 5 due to safety classifiers, which slightly impacts the 5.5 composite score.&lt;/p&gt;

&lt;h3&gt;
  
  
  The Artificial Analysis Intelligence Index
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://artificialanalysis.ai/models" rel="noopener noreferrer"&gt;Artificial Analysis&lt;/a&gt; rolls independent multi-metric evaluations into an aggregate Intelligence Index:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Model&lt;/th&gt;
&lt;th&gt;Intelligence Index&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Claude Opus 5.5 (max)&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;58&lt;/strong&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Claude Sonnet 5.5 (max)&lt;/td&gt;
&lt;td&gt;56&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Claude Opus 5.5 (xhigh)&lt;/td&gt;
&lt;td&gt;56&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Claude Opus 5.5 (high)&lt;/td&gt;
&lt;td&gt;54&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Claude Fable 5.1 (max)&lt;/td&gt;
&lt;td&gt;53&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;MiMo-V2.6-Pro&lt;/td&gt;
&lt;td&gt;46&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Opus 5.5 holds first place (the median for comparable models sits at 26). However, the trade-off is clear: throughout the benchmark index, the model &lt;strong&gt;generated 260 million tokens&lt;/strong&gt;, versus an 81M median. It reasons and ponders extensively before acting. The measured throughput was 92.4 tokens/second.&lt;/p&gt;

&lt;h3&gt;
  
  
  Pricing &amp;amp; Token Economy
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Opus 5.5&lt;/th&gt;
&lt;th&gt;Opus 5&lt;/th&gt;
&lt;th&gt;Fable 5.1&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Input (per 1M tokens)&lt;/td&gt;
&lt;td&gt;$4&lt;/td&gt;
&lt;td&gt;$5&lt;/td&gt;
&lt;td&gt;$10&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Output (per 1M tokens)&lt;/td&gt;
&lt;td&gt;$20&lt;/td&gt;
&lt;td&gt;$25&lt;/td&gt;
&lt;td&gt;$50&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Anthropic claims real-world workflows run &lt;strong&gt;~40% cheaper than on Opus 5&lt;/strong&gt; because the model needs fewer iterations for the same goal. My Sunday does not confirm that percentage. The usage panel showed about half of the daily allotment for code, art, design, and the playtest runs. The panel does not split input, output, and cache, so "half" is a reading, not a token bill.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Game
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Stage 1:&lt;/strong&gt; You pilot Montanha (jetpack vertical boost + hacker watch that shoots and overrides terminal nodes). Reaching the end reveals Gle trapped in a cryo-capsule. Love hearts float up, but RANSOM-TITAN drops an extraction claw from the sky and abducts Montanha. It was bait.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Stages 2 and 3:&lt;/strong&gt; Gle, freed from containment, retaliates armed with a golden buster gauntlet and high-speed light boots.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ending:&lt;/strong&gt; She shatters the boss core, retrieves his decryption key, and opens Montanha's prison cell.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Under the hood: &lt;strong&gt;Vanilla JavaScript ES modules&lt;/strong&gt; (~2,700 lines across 24 single-purpose files), HTML5 Canvas, a deterministic 60 Hz simulation loop, service workers for offline PWA installation, a 100% synthesized WebAudio procedural soundtrack (no bulky MP3/OGG assets), and HD-2D art pipeline. Zero frameworks, zero bundlers.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F48iu4lww5zltzb3eatht.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F48iu4lww5zltzb3eatht.jpg" alt="The stage 1 ending: hearts, the RANSOM-TITAN claw drops, grabs Montanha and lifts him away from Gle's capsule" width="800" height="139"&gt;&lt;/a&gt;&lt;br&gt;
&lt;em&gt;The stage 1 ending, frame by frame: hearts, the claw drops, grabs Montanha and lifts him away.&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9vddejzql36h77bs8hcg.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F9vddejzql36h77bs8hcg.jpg" alt="Gle gliding on her golden light boots through the flooded server room of stage 2" width="800" height="369"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fs2ga63w01ghamqjtwjeo.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fs2ga63w01ghamqjtwjeo.jpg" alt="Gle facing the RANSOM-TITAN boss, a giant padlock with a red eye, in the Core arena" width="800" height="369"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  Generating High-Def Assets with Artlist Credits
&lt;/h2&gt;

&lt;p&gt;A retro-modern platformer lives or dies by its art and animation. For this, we tapped into &lt;strong&gt;&lt;a href="https://artlist.io/" rel="noopener noreferrer"&gt;Artlist.io&lt;/a&gt;&lt;/strong&gt; using generation credits.&lt;/p&gt;

&lt;p&gt;What is Artlist in this context? Artlist has evolved into a powerhouse creative suite featuring generative AI models for video, character design, and music. &lt;/p&gt;

&lt;p&gt;Here is what we did with those credits:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Character Sprites with Nano Banana 2:&lt;/strong&gt; We generated high-definition, cel-shaded character art. Because we supplied reference images, the character likeness (Montanha's dark beard, snapback cap, hoodie, and watch) remained rock-solid across multiple poses.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Animation Cycles with Seedance:&lt;/strong&gt; We converted still character poses into 720p 24fps motion clips.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Pure Chroma Isolation:&lt;/strong&gt; We generated all characters on flat magenta (&lt;code&gt;#FF00FF&lt;/code&gt;) or green backgrounds.&lt;/li&gt;
&lt;/ol&gt;

&lt;h3&gt;
  
  
  Bridging Artlist and the Local Python Pipeline
&lt;/h3&gt;

&lt;p&gt;During the session, the containerized runtime faced a network restriction accessing the external Artlist media host. Instead of giving up or waiting for human intervention, the agent navigated through its environment:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;It utilized the local browser to inspect the video stream.&lt;/li&gt;
&lt;li&gt;Extracted raw frames directly into an HTML5 &lt;code&gt;&amp;lt;canvas&amp;gt;&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Measured the pixel delta across frames to calculate the exact seamless 2-step cycle (19 frames at 24 fps).&lt;/li&gt;
&lt;li&gt;Streamed the frames into the project's local Python pipeline (&lt;code&gt;tools/process_art.py&lt;/code&gt;), where &lt;code&gt;scipy&lt;/code&gt; and &lt;code&gt;Pillow&lt;/code&gt; ran automatic chroma-key despill, centered the torso/feet anchor points, and packed the final spritesheet into WebP.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Total cost: &lt;strong&gt;590 Artlist credits&lt;/strong&gt;. Result: fully custom, beautifully animated characters without manually drawing a single pixel.&lt;/p&gt;




&lt;h2&gt;
  
  
  Autonomous Playwright E2E Testing &amp;amp; Navigation
&lt;/h2&gt;

&lt;p&gt;Session scene. Not player telemetry. The bot ran in that chat. The scripts are not in the repository, so a clone of the game does not include this sensor.&lt;/p&gt;

&lt;p&gt;Rather than treating a clean compile as proof, the agent started &lt;strong&gt;Playwright in headless Chromium&lt;/strong&gt; and played:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Playtesting bot:&lt;/strong&gt; It did more than load the page. It drove a scripted bot through the game's physics (&lt;code&gt;js/physics.js&lt;/code&gt;), jumped gaps, and pressed on collision boxes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One pixel short:&lt;/strong&gt; During the stage 3 expansion (pulse beams), the bot found a platform jump &lt;strong&gt;1 pixel out of reach&lt;/strong&gt; from the absolute edge. The agent moved the chunk in &lt;code&gt;config.js&lt;/code&gt; and ran the jump again.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Walk through the beam:&lt;/strong&gt; The bot caught an invulnerability hole: spend 3 HP and walk through a live hazard while blinking. The beam collision was changed so it stays solid during invulnerability.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One walk of the three stages:&lt;/strong&gt; Title, cutscenes, boss, and ending, checking that portraits and the audio state changed with the scene. That walk is one session. It is not a suite you can re-run from CI.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F26fnbvqiyw7khkl8ly12.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F26fnbvqiyw7khkl8ly12.webp" alt="Montanha hovering with his jetpack in Neo-Sampa" width="800" height="450"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb5b1lntvtaob9r76vvhn.webp" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Fb5b1lntvtaob9r76vvhn.webp" alt="Gle facing the rhythmic pulse beams in Stage 3" width="800" height="370"&gt;&lt;/a&gt;&lt;/p&gt;




&lt;h2&gt;
  
  
  What the Model Actually Delivered
&lt;/h2&gt;

&lt;h3&gt;
  
  
  1. Parallel Subagent Auditing
&lt;/h3&gt;

&lt;p&gt;When tasked with reviewing game feel and narrative consistency, Claude Code branched out &lt;strong&gt;two subagents in parallel&lt;/strong&gt;: one dedicated to story plot holes, and another hunting edge cases in the game engine. &lt;/p&gt;

&lt;p&gt;Session scene. Not a production bug count. They surfaced 16 prioritized issues and checked them by running the build:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;em&gt;Boss Resurrection Bug:&lt;/em&gt; Dying while the boss explosion triggered would resurrect the boss at full health upon pressing "Retry".&lt;/li&gt;
&lt;li&gt;
&lt;em&gt;Level 1 Fall Glitch:&lt;/em&gt; Knockback from low-tier enemies knocked the hero backwards directly into unrecoverable pits.&lt;/li&gt;
&lt;/ul&gt;

&lt;h3&gt;
  
  
  2. Diagnosing "Character Feel"
&lt;/h3&gt;

&lt;p&gt;Session scene. I gave feedback that &lt;em&gt;"Gle felt much more fluid to play than Montanha."&lt;/em&gt; Rather than blindly tweaking speed variables, the model verified that the physics parameters were mathematically identical. &lt;/p&gt;

&lt;p&gt;It then inspected the animation sprites:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Montanha was literally turning backwards during jump ascents because the video generation had mirrored his horizontal orientation.&lt;/li&gt;
&lt;li&gt;His run cycle was repeating the identical leading foot on every step, resembling a gallop rather than a sprint.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;It mirrored the sprite sheet, hooked up an ascending vs hovering jetpack frame selector, and introduced distinct neon trails (cyan for Montanha, radiant gold for Gle).&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6ic9x4g9xqer3gw5qoay.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F6ic9x4g9xqer3gw5qoay.png" alt="Montanha's jump frames before (facing backwards, two frames facing the camera) and after (mirrored side frames)" width="800" height="449"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1ecix5zwmf0ctyox3e8o.png" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1ecix5zwmf0ctyox3e8o.png" alt="Montanha's run cycle before (same leg forward every step) and after (regenerated two-step loop)" width="800" height="292"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;h3&gt;
  
  
  3. A 12-Chunk Stage Expansion
&lt;/h3&gt;

&lt;p&gt;When asked to expand Stage 3 before the boss, it added &lt;strong&gt;pulse beams&lt;/strong&gt;: laser barriers that blink before they fire, offset from the beam next to them. The stage grew from 7 to 12 sections. Session scene. One bot run reported a clean, no-damage clear in 39 seconds. That number is not a sample of players.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Takeaway
&lt;/h2&gt;

&lt;p&gt;Sunday went from a three-sentence prompt to a playable PWA: code, generated art, procedural audio, and a service worker. The usage panel read about half of the daily allotment. Artlist cost &lt;strong&gt;590 credits&lt;/strong&gt;. One bot run reported a 39-second clear.&lt;/p&gt;

&lt;p&gt;That bot is not in the repo. Clone the &lt;a href="https://github.com/tiagovilasboas/montanha-zero-day" rel="noopener noreferrer"&gt;game&lt;/a&gt; and you get the PWA, not the Playwright sensor. I will not call the build bug-free. The same day found a boss that came back at full health, a knockback into a pit, and a beam you could walk through while invulnerable. What you play is the build after those fixes. Nobody has measured how real players die.&lt;/p&gt;




&lt;h2&gt;
  
  
  The Bigger Picture: Opus 5.5 Is Sparking a Browser Game Renaissance
&lt;/h2&gt;

&lt;p&gt;&lt;em&gt;Montanha: Zero Day&lt;/em&gt; is not an isolated experiment. Across the community, Opus 5.5 combined with Claude Code is triggering an explosion of indie game development without traditional engines (no Unity, no Unreal):&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://github.com/VibeFin/awesome-opus-5.5-games" rel="noopener noreferrer"&gt;Awesome Opus 5.5 Games&lt;/a&gt;:&lt;/strong&gt; Curated directory featuring nearly 200 playable games built with Opus 5.5.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://rundevue.com/built-with/opus-5-5" rel="noopener noreferrer"&gt;Rundevue (Built with Opus 5.5)&lt;/a&gt;:&lt;/strong&gt; Community showcase featuring Rocket League clones, open-world experiments, pod racers, and tycoon titles running in WebGL/Three.js.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;&lt;a href="https://hearthlight.github.io/" rel="noopener noreferrer"&gt;Hearthlight&lt;/a&gt;:&lt;/strong&gt; A cozy 10-chapter pixel-art adventure game with 8 characters, dungeons, and up to 8-player multiplayer, built entirely using Claude Code + Opus 5.5 + Three.js with natural language playtesting iterations (&lt;a href="https://www.reddit.com/r/ClaudeAI/comments/1wtcs7k/i_opensourced_the_cozy_pixelart_game_opus_55_made/" rel="noopener noreferrer"&gt;Reddit discussion&lt;/a&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;NUTSHOT!:&lt;/strong&gt; Created by Brazilian dev Yan Mantovani, showcasing how a 3D browser shooter was spun up from a single kickoff prompt and refined via playtesting loops.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The Fallout: New York Phenomenon:&lt;/strong&gt; A sprawling browser fan game featuring 117 locations, 112 characters, and 46 weapons crafted with Opus 5.5 that went viral across gaming outlets.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The emerging stack is unmistakable:&lt;br&gt;&lt;br&gt;
&lt;code&gt;Opus 5.5 + Claude Code&lt;/code&gt; → &lt;code&gt;TypeScript / Vanilla ES Modules&lt;/code&gt; → &lt;code&gt;Canvas / Three.js / WebGL&lt;/code&gt; → &lt;code&gt;Procedural / Generative Assets&lt;/code&gt; → &lt;code&gt;Instant Browser Delivery&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;A harness can keep the architecture from drifting. It does not, by itself, put a test in the repository or a player on the other side of the screen.&lt;/p&gt;

&lt;p&gt;When an agent finds a bug by playing, do you commit the test, or does the proof stay in the chat?&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Sources &amp;amp; Links:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;&lt;a href="https://tiagovilasboas.github.io/montanha-zero-day/" rel="noopener noreferrer"&gt;Play Montanha: Zero Day&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/tiagovilasboas/montanha-zero-day" rel="noopener noreferrer"&gt;GitHub Repository&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://www.anthropic.com/claude-opus-5-5" rel="noopener noreferrer"&gt;Anthropic Opus 5.5 Announcement&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://artificialanalysis.ai/models" rel="noopener noreferrer"&gt;Artificial Analysis Leaderboard&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://artlist.io/" rel="noopener noreferrer"&gt;Artlist Generative Suite&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://github.com/VibeFin/awesome-opus-5.5-games" rel="noopener noreferrer"&gt;Awesome Opus 5.5 Games&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://rundevue.com/built-with/opus-5-5" rel="noopener noreferrer"&gt;Rundevue Showcase&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;

</description>
      <category>ai</category>
      <category>gamedev</category>
      <category>javascript</category>
      <category>claude</category>
    </item>
    <item>
      <title>SaS além da vitrine: Service as Software, o que o agente compra e o humano só vê</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Fri, 02 Oct 2026 15:01:32 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/sas-alem-da-vitrine-service-as-software-o-que-o-agente-compra-e-o-humano-so-ve-3f3i</link>
      <guid>https://dev.to/tiagovilasboas/sas-alem-da-vitrine-service-as-software-o-que-o-agente-compra-e-o-humano-so-ve-3f3i</guid>
      <description>&lt;p&gt;A gente vai sofrer uma revolução muito rápida. O agente pessoal já tem um computador na nuvem: trabalha com o celular na mão e o notebook fechado. O de sessão já vive no editor de quem escreve software. Nenhum dos dois abre o Salesforce, o HubSpot ou o Adobe para trabalhar. Eles pedem a ação direto. Por isso um mercado novo está surgindo nos EUA.&lt;/p&gt;

&lt;p&gt;O nome tira um A. &lt;strong&gt;SaaS&lt;/strong&gt; é Software as a Service: você paga a ferramenta e opera a tela. &lt;strong&gt;SaS&lt;/strong&gt; é Service as Software: o vendor vende o serviço feito. A &lt;a href="https://www.thoughtworks.com/en-sg/insights/blog/generative-ai/service-as-software-a-new-economic-model-for-age-of-ai-agents" rel="noopener noreferrer"&gt;Thoughtworks&lt;/a&gt; escreve essa inversão. O jeito de construir isso o mercado chama de &lt;strong&gt;headless&lt;/strong&gt;. No anúncio do &lt;a href="https://www.salesforce.com/news/stories/salesforce-headless-360-announcement/" rel="noopener noreferrer"&gt;Salesforce Headless 360&lt;/a&gt; o título é "No Browser Required": sem abrir o navegador. Caso sem abrir o Salesforce, campanha sem abrir o Adobe, e-mail que vira deal sem abrir o HubSpot. Em abril de 2026 o Salesforce e a &lt;a href="https://news.adobe.com/news/2026/04/adobe-redefines-custome-experience" rel="noopener noreferrer"&gt;Adobe CX Enterprise&lt;/a&gt; já abriram essa porta.&lt;/p&gt;

&lt;p&gt;Eu já rodava isso. O &lt;a href="https://hermes-agent.nousresearch.com/docs/" rel="noopener noreferrer"&gt;Hermes&lt;/a&gt; era o meu agente pessoal, numa VPS na nuvem. Agora &lt;a href="https://learn.chatgpt.com/docs/dots" rel="noopener noreferrer"&gt;Dots&lt;/a&gt;, &lt;a href="https://x.ai/news/introducing-grok-bot" rel="noopener noreferrer"&gt;Grok Bot&lt;/a&gt; e &lt;a href="https://about.fb.com/news/2026/09/introducing-muse-personal-ai-agent/" rel="noopener noreferrer"&gt;Muse&lt;/a&gt; vendem a mesma peça no celular e no desktop, sem montar servidor. Quando o pessoal ganhou esse computador de fábrica, o SaaS que eu pago deixou de parecer tela obrigatória. Passou a parecer um sistema que o agente chama. O mapa abaixo é o que esse mercado já abriu.&lt;/p&gt;

&lt;h2&gt;
  
  
  Índice
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;1. SaS não é SaaS com chat&lt;/li&gt;
&lt;li&gt;2. Dois compradores: agente pessoal e agente de sessão&lt;/li&gt;
&lt;li&gt;3. Quatro gavetas do que já existe&lt;/li&gt;
&lt;li&gt;4. Quem paga a conta&lt;/li&gt;
&lt;li&gt;5. O assento quebra. O crédito ainda não resolve&lt;/li&gt;
&lt;li&gt;6. O que some quando ninguém abre a tela&lt;/li&gt;
&lt;li&gt;7. Oportunidades, e o que não é&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  1. SaS não é SaaS com chat
&lt;/h2&gt;

&lt;p&gt;Cena do cookbook. Não é o meu CRM. No &lt;a href="https://developers.hubspot.com/changelog/take-action-with-chatgpt-update-crm-records-access-more-objects-and-engagements" rel="noopener noreferrer"&gt;changelog do HubSpot&lt;/a&gt;, de 26 de fevereiro de 2026, o pedido oficial é: vira o deal "Enterprise Package Q4" para Closed Won (ganho). O vendedor não abre o console. O ChatGPT mostra o que vai mudar e pede um sim. Só então o deal vira ganho. O histórico grava a pessoa e o app do ChatGPT.&lt;/p&gt;

&lt;p&gt;Isso é SaS na prática: a empresa pagou o fechamento do deal, não o clique no funil.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Headless&lt;/strong&gt; é o nome que o mercado usa para o como. A &lt;a href="https://help.salesforce.com/s/articleView?id=005360285&amp;amp;language=en_US&amp;amp;type=1" rel="noopener noreferrer"&gt;ajuda do Salesforce&lt;/a&gt; é direta: a tela &lt;strong&gt;não some&lt;/strong&gt;. O que muda é que a ação deixa de depender dela. O agente registra a ligação, cria o usuário, fecha o deal sem abrir o navegador. Tem gente que prefere &lt;strong&gt;agent-ready&lt;/strong&gt;: o produto aceita o agente como usuário, não só o humano. Sem isso, você só colou um chat na tela antiga e cobrou o mesmo assento.&lt;/p&gt;

&lt;p&gt;Dois jeitos que mudam a fatura, no recorte da &lt;a href="https://www.cxtoday.com/crm/headless-enterprise-strategy-2026/" rel="noopener noreferrer"&gt;CX Today&lt;/a&gt;:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Jeito&lt;/th&gt;
&lt;th&gt;Segunda-feira&lt;/th&gt;
&lt;th&gt;Exemplo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Produto headless&lt;/td&gt;
&lt;td&gt;O CRM ou o marketing que você já paga, o agente usa sem abrir o site&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://www.salesforce.com/news/stories/salesforce-headless-360-announcement/" rel="noopener noreferrer"&gt;Salesforce Headless 360&lt;/a&gt;, &lt;a href="https://news.adobe.com/news/2026/04/adobe-redefines-custome-experience" rel="noopener noreferrer"&gt;Adobe CX Enterprise&lt;/a&gt;, &lt;a href="https://knowledge.hubspot.com/integrations/connect-your-hubspot-account-to-chatgpt" rel="noopener noreferrer"&gt;HubSpot no ChatGPT&lt;/a&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;API que já nasceu assim&lt;/td&gt;
&lt;td&gt;Cobrar, identificar, mandar mensagem. O humano nunca foi o usuário principal&lt;/td&gt;
&lt;td&gt;Stripe, Twilio, Plaid&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;No &lt;a href="https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/headless-360-mcp.html" rel="noopener noreferrer"&gt;Salesforce headless&lt;/a&gt;, em beta desde julho de 2026, o agente não ganha milhares de botões. Ganha quatro passos: perguntar o que dá para fazer, ler o que a ação pede, executar, ou só consultar. A docs dá o pedido: "registra a ligação no Salesforce." Outro: "cria o usuário do vendedor novo e põe a permissão de Sales."&lt;/p&gt;

&lt;p&gt;Se a sua empresa só colou um chat na tela antiga, isso ainda é console com balconista.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Dois compradores: agente pessoal e agente de sessão
&lt;/h2&gt;

&lt;p&gt;Tem dois. O &lt;a href="https://developer.salesforce.com/blogs/2026/05/headless-360-what-it-means-for-developers" rel="noopener noreferrer"&gt;blog da Salesforce&lt;/a&gt; já separa agente de negócio e agente de código. Eu uso os nomes do dia a dia.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agente pessoal&lt;/strong&gt; vive fora do editor. &lt;a href="https://learn.chatgpt.com/docs/dots" rel="noopener noreferrer"&gt;Dots&lt;/a&gt;, &lt;a href="https://x.ai/news/introducing-grok-bot" rel="noopener noreferrer"&gt;Grok Bot&lt;/a&gt; e &lt;a href="https://about.fb.com/news/2026/09/introducing-muse-personal-ai-agent/" rel="noopener noreferrer"&gt;Muse&lt;/a&gt;. Os três vendem um computador na nuvem, não um balcão de chat. A docs do Dots diz: o trabalho segue com o seu PC desligado. A Muse fala no WhatsApp.&lt;/p&gt;

&lt;p&gt;O &lt;a href="https://x.ai/news/introducing-grok-bot" rel="noopener noreferrer"&gt;anúncio do Grok Bot&lt;/a&gt; descreve a segunda-feira deles, por dentro da empresa: um Bot de vendas cola a ata da ligação no CRM e rascunha o follow-up; um de ops senta o contratado novo e processa a nota que caiu no Gmail; um de engenharia reproduz o bug na tela, abre o ticket e passa o conserto. Só volta quando precisa de aprovação. A &lt;a href="https://docs.x.ai/grok-bot/overview" rel="noopener noreferrer"&gt;docs&lt;/a&gt; até sugere o primeiro handoff: puxar o pipeline da semana no CRM, pular quem já está em sequência, pesquisar as cinco contas, rascunhar o outreach e deixar o rascunho para você aprovar até de manhã. Isso é cookbook do vendor. Eu não girei esse Bot no meu CRM.&lt;/p&gt;

&lt;p&gt;Esse computador também abre o site. O mesmo anúncio diz que o Bot entra em página sem uma porta oficial. Isso é colega clicando por você. Headless de verdade é quando ele pede a ação no sistema: fecha o deal, registra a ligação, sem fingir que é um humano na tela.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Agente de sessão&lt;/strong&gt; vive no loop de quem escreve software. Cursor, Claude Code, Codex, Windsurf. A Salesforce anunciou skills para esses quatro. No &lt;a href="https://developer.salesforce.com/blogs/2026/05/headless-360-what-it-means-for-developers" rel="noopener noreferrer"&gt;mesmo blog&lt;/a&gt;, a sessão típica é: o agente entra no ambiente de teste, lê o que o CRM já tem, escreve o código com teste e sobe pelo mesmo processo de review. O processo não pergunta quem digitou. Pergunta se a regra passou. Ele também não quer a tela. Quer a mesma ação, com o seu crachá.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Agente pessoal&lt;/th&gt;
&lt;th&gt;Agente de sessão&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Segunda-feira&lt;/td&gt;
&lt;td&gt;"Fecha o deal Q4" no celular. Grok: ata da ligação vira update no CRM&lt;/td&gt;
&lt;td&gt;"Sobe o código e abre o PR" no editor. Salesforce: teste, review, mesmo portão&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Quem paga o erro&lt;/td&gt;
&lt;td&gt;Cliente, seller, marca&lt;/td&gt;
&lt;td&gt;Código em produção, fatura do modelo&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Eu opero o da direita todo dia. O da esquerda eu conheci no Hermes, na VPS. Por isso a seção 3 separa cookbook de runtime.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Quatro gavetas do que já existe
&lt;/h2&gt;

&lt;p&gt;Não misture numa lista só. Em cada uma, o que a pessoa faz na segunda-feira, com o prompt ou a cena que a fonte realmente publicou.&lt;/p&gt;

&lt;h3&gt;
  
  
  Lab / runtime documentado
&lt;/h3&gt;

&lt;p&gt;O &lt;a href="https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/headless-360-mcp.html" rel="noopener noreferrer"&gt;Salesforce headless&lt;/a&gt; está em beta desde julho de 2026. A docs lista o que o agente já pode pedir, com o login da pessoa. Traduzindo para a segunda-feira:&lt;/p&gt;

&lt;p&gt;O vendedor desliga o Zoom e manda: registra a ligação no Salesforce. Não abre o console. O agente acha a ação, lê o que ela pede e executa.&lt;/p&gt;

&lt;p&gt;O RH manda o vendedor novo. Alguém pede: cria o usuário e põe a permissão de Sales. Sem tela de cadastro.&lt;/p&gt;

&lt;p&gt;Na daily de pipeline: quais oportunidades eu olho hoje? Só consulta. Não escreve deal.&lt;/p&gt;

&lt;p&gt;Na sexta de desligamento: desativa a conta de quem saiu. O crachá some no sistema, não num formulário.&lt;/p&gt;

&lt;p&gt;Tem também pedido da loja (Commerce Cloud), acesso ao estoque externo e aviso quando a conta do cliente muda. A docs deixa claro que, no lançamento do beta, a maior parte ainda é tarefa de admin. A lista cresce. O agente pergunta o que existe na hora.&lt;/p&gt;

&lt;p&gt;A regra que um PM cobraria no review está na mesma página: se a pessoa não pode fazer a ação no Salesforce, o agente dela também não pode. O histórico grava o nome dela. Isso é lab oficial. Eu não liguei essa conta.&lt;/p&gt;

&lt;h3&gt;
  
  
  Receita oficial
&lt;/h3&gt;

&lt;p&gt;Três vendors, três segundas-feiras. Nenhuma delas é o meu runtime.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.salesforce.com/news/stories/salesforce-headless-360-announcement/" rel="noopener noreferrer"&gt;Salesforce, 15 de abril de 2026&lt;/a&gt;. Parker Harris pergunta, no anúncio: por que você ainda faria login no Salesforce? A segunda-feira antiga que eles mesmos descrevem: o analista de atendimento abre o console, clica no caso, muda o status. A nova, no &lt;a href="https://developer.salesforce.com/blogs/2026/05/headless-360-what-it-means-for-developers" rel="noopener noreferrer"&gt;blog de developers&lt;/a&gt;: o vendedor pede o resumo do cliente no Slack; o suporte resolve o caso no Teams; o agente de código sobe a mudança no Cursor. A conversa sai no Slack, no ChatGPT ou no Teams. "12 dias" e "+300% de agentes" aparecem no anúncio, na boca do vendor. Não uso como prova.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://news.adobe.com/news/2026/04/adobe-redefines-custome-experience" rel="noopener noreferrer"&gt;Adobe, 20 de abril de 2026&lt;/a&gt;. O Marketing Agent roda no Claude Enterprise, no ChatGPT Enterprise, no Gemini e no Copilot. A segunda-feira do press é montar campanha, imagem e segmento sem abrir o Experience Cloud. O exemplo que a Adobe escreveu: o time quer subir 3% de cross-sell; o Coworker junta segmento, criativo e insight, monta o plano e, depois da aprovação, executa a campanha. A &lt;a href="https://experienceleague.adobe.com/en/docs/experience-cloud-ai/experience-cloud-ai/mcp/mcp-get-started/install" rel="noopener noreferrer"&gt;docs&lt;/a&gt; mostra como ligar isso no Claude ou no ChatGPT. Cookbook do press. Eu não medi se a campanha vendeu.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://knowledge.hubspot.com/integrations/connect-your-hubspot-account-to-chatgpt" rel="noopener noreferrer"&gt;HubSpot no ChatGPT&lt;/a&gt;, escrita em &lt;a href="https://developers.hubspot.com/changelog/take-action-with-chatgpt-update-crm-records-access-more-objects-and-engagements" rel="noopener noreferrer"&gt;26 de fevereiro de 2026&lt;/a&gt;. A segunda-feira do cookbook oficial cabe numa conversa só:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Cria o contato da pessoa X com este e-mail&lt;/li&gt;
&lt;li&gt;Vira o deal "Enterprise Package Q4" para Closed Won (ganho)&lt;/li&gt;
&lt;li&gt;Registra no ticket uma nota com o resumo da resolução&lt;/li&gt;
&lt;li&gt;Cria uma tarefa para terça: follow-up da renovação do contrato&lt;/li&gt;
&lt;li&gt;Vendas: resume o mês de e-mail com o cliente e lista o que trava o fechamento&lt;/li&gt;
&lt;li&gt;Marketing: cria tarefas de follow-up a partir dos e-mails abertos&lt;/li&gt;
&lt;li&gt;Suporte: lista as tarefas abertas da semana, por prioridade&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Vale em todos os planos do HubSpot, com conta OpenAI. Sem permissão de escrita, volta a ser chat com leitura. No máximo 10 registros por vez. Um admin conecta primeiro e escolhe o que o app enxerga. O ChatGPT mostra a mudança e pede sim. O histórico grava a pessoa e o app. A &lt;a href="https://knowledge.hubspot.com/integrations/connect-your-hubspot-account-to-chatgpt" rel="noopener noreferrer"&gt;KB&lt;/a&gt; avisa uma coisa que muda a fatura na prática: a regra extra do funil &lt;strong&gt;não roda&lt;/strong&gt; por esse app. Closed Won pelo chat pode passar por um portão que a tela teria fechado.&lt;/p&gt;

&lt;h3&gt;
  
  
  Repo da comunidade
&lt;/h3&gt;

&lt;p&gt;&lt;a href="https://timeundertension.substack.com/p/the-headless-horseman-of-the-saaspocalypse" rel="noopener noreferrer"&gt;Tim O'Neill&lt;/a&gt;, founder da &lt;a href="https://www.peakapp.ai/" rel="noopener noreferrer"&gt;Peak&lt;/a&gt;, descreveu a segunda-feira dele, não um press. Ele cola o fio de e-mail no Codex. O agente liga no HubSpot e cria deal, contato e empresa, pesquisa a empresa e amarra os três. Antes, 10 minutos no site do HubSpot. Agora, 10 segundos. Ele escreve que já usava o app do HubSpot no Codex todo dia.&lt;/p&gt;

&lt;p&gt;A Peak que ele vende faz o mesmo caminho: Skills no Codex ou no Claude Cowork, sem login no site. No Cowork, o app da Peak gera imagem no meio do workflow. O Cowork, sozinho, não gera imagem. Relato de quem vende o produto.&lt;/p&gt;

&lt;p&gt;No mesmo texto ele desenha o pulo que eu ainda não vi rodando: Codex cria o segmento no Salesforce, monta a campanha no Adobe e publica no ads da Meta, sem sair do editor. Isso é o founder descrevendo o destino. Não é case que eu abri.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://github.com/coreyhaines31/marketingskills" rel="noopener noreferrer"&gt;marketingskills&lt;/a&gt; é o outro lado. O agente de sessão faz CRO, SEO e copy sem abrir a ferramenta de marketing. Não é SaS. É um pacote de instruções tentando viver sem o produto.&lt;/p&gt;

&lt;h3&gt;
  
  
  Não achei em produção
&lt;/h3&gt;

&lt;p&gt;Não achei, em 2 de outubro de 2026, um SaaS brasileiro de checkout, marketplace ou atendimento vendendo o modo headless ou a skill como produto, com URL de loja.&lt;/p&gt;

&lt;p&gt;A segunda-feira que &lt;strong&gt;encaixaria&lt;/strong&gt;, se o agente pudesse agir no sistema sem abrir a tela:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"Cancela o pedido 4412 e estorna o PIX."&lt;/li&gt;
&lt;li&gt;"O motoboy atrasou. Avisa o cliente e registra o atraso."&lt;/li&gt;
&lt;li&gt;"O split do afiliado saiu errado. Recalcula e mostra quem recebeu o quê."&lt;/li&gt;
&lt;li&gt;"A fatura da assinatura recusou. Manda o link de recadastro de cartão sem abrir o ADM."&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Encaixe não é case. Sem URL, não sobe de gaveta. O canal já ser WhatsApp também não prova headless: conversa sem ação no sistema continua só tela.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Quem paga a conta
&lt;/h2&gt;

&lt;p&gt;A confusão começa no boleto. Antes, a empresa pagava o HubSpot porque 40 vendedores abriam a tela. Agora o vendedor manda "fecha o deal Q4" no celular e o ChatGPT escreve no CRM. A empresa continua pagando o HubSpot. Também paga o ChatGPT, o Grok Bot ou o Dots. E o trabalho aconteceu sem ninguém abrir o site. A pergunta desta seção é esta: &lt;strong&gt;quem é o cliente do SaaS quando quem trabalha é o agente?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;São três contas, no mesmo dia, e quase ninguém junta as três.&lt;/p&gt;

&lt;p&gt;A empresa paga o SaaS antigo para o agente poder usar o HubSpot sem abrir a tela. Sem assento ou sem permissão de escrita, o &lt;a href="https://knowledge.hubspot.com/integrations/connect-your-hubspot-account-to-chatgpt" rel="noopener noreferrer"&gt;HubSpot no ChatGPT&lt;/a&gt; volta a ser conversa com leitura. O vendedor paga o agente pessoal: Dots, Grok Bot, Muse. O founder da &lt;a href="https://www.peakapp.ai/" rel="noopener noreferrer"&gt;Peak&lt;/a&gt; ainda paga o Codex. Três boletos para um Closed Won.&lt;/p&gt;

&lt;p&gt;A segunda-feira muda por tipo de negócio. O padrão é o mesmo.&lt;/p&gt;

&lt;p&gt;No &lt;strong&gt;atendimento&lt;/strong&gt;, o prompt oficial do Salesforce é "Log a call in Salesforce." O da HubSpot é registrar a nota no ticket com o resumo da resolução. A empresa pagou o CRM. O agente escreveu o caso. Se ninguém consegue abrir depois e ver por que aquele caso fechou, a empresa pagou por um processo invisível. A &lt;a href="https://www.cxtoday.com/crm/headless-enterprise-strategy-2026/" rel="noopener noreferrer"&gt;CX Today&lt;/a&gt; já ouviu time dizendo que a visão é clara e a operação suja não está pronta. Visão sem trilha não é SaS. É chat com login.&lt;/p&gt;

&lt;p&gt;No &lt;strong&gt;CRM de vendas&lt;/strong&gt;, as três cenas que já existem: HubSpot vira o deal "Enterprise Package Q4" para Closed Won; o Grok Bot cola a ata da ligação no CRM e rascunha o follow-up; o Tim cola o e-mail no Codex e em 10 segundos nascem deal, contato e empresa. Quem pagou o HubSpot? A empresa. Quem pagou o agente? O vendedor ou o plano da Peak. O lote do HubSpot para em 10 registros. Sem escrita, é chat. E a regra extra do funil não roda: o Closed Won pelo chat pode passar por um portão que a tela teria fechado. A empresa pagou o CRM e perdeu o portão.&lt;/p&gt;

&lt;p&gt;No &lt;strong&gt;marketing&lt;/strong&gt;, a Adobe coloca o Marketing Agent no Claude, no ChatGPT, no Gemini e no Copilot. O time monta segmento, criativo e campanha sem abrir o Experience Cloud. A Peak gera a imagem no Cowork, sem abrir o site. Duas faturas: Adobe ou Peak, mais o Claude. Cookbook. Eu não medi se a campanha vendeu.&lt;/p&gt;

&lt;p&gt;Na &lt;strong&gt;loja e no marketplace&lt;/strong&gt;, o boleto que eu procuraria no Brasil ainda não existe. A segunda-feira que geraria a fatura: "cancela o pedido 4412 e estorna o PIX", "o split do afiliado saiu errado". Sem URL de loja vendendo isso como produto, não tem quem cobre. Encaixe não é case.&lt;/p&gt;

&lt;p&gt;No &lt;strong&gt;delivery&lt;/strong&gt;, o canal já é conversa. "O motoboy atrasou, avisa o cliente" cabe no WhatsApp sem o agente escrever no sistema. Isso não prova que o restaurante comprou SaS. Comprou um chat.&lt;/p&gt;

&lt;p&gt;A &lt;a href="https://www.deloitte.com/global/en/insights/industry/technology/technology-media-and-telecom-predictions/2026/saas-ai-agents.html" rel="noopener noreferrer"&gt;Deloitte&lt;/a&gt;, em novembro de 2025, acertou o desenho e o limite. O agente é headless, como API: ele não precisa da tela para trabalhar. Ainda assim a empresa precisa de um lugar para ver o que ele fez, reverter o Closed Won errado e auditar quem pediu. A tela não morre. Ela deixa de ser o lugar do trabalho e vira a sala de controle. Substituir o app enterprise inteiro por agente &lt;strong&gt;não é 2026&lt;/strong&gt;. A mesma Deloitte fala em cinco anos ou mais. Gartner, citado ali, projeta que até 2030 cerca de 35% das ferramentas SaaS pontuais sejam substituídas por agente ou absorvidas no ecossistema maior. Forecast. Não é a fatura da sua loja na segunda.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. O assento quebra. O crédito ainda não resolve
&lt;/h2&gt;

&lt;p&gt;Assento é o jeito antigo de cobrar: a empresa paga por pessoa que pode abrir a tela. Um login, um humano, o trabalho acontece no console. Esse desenho assume que, se o volume cresce, você contrata mais gente e compra mais assentos.&lt;/p&gt;

&lt;p&gt;SaS quebra a conta dos dois lados. Um humano autoriza. N agentes executam. O volume de Closed Won, nota e task pode ficar igual, ou subir, com menos gente abrindo o site. O CFO olha a fatura e vê assento ocioso. O vendor olha a mesma fatura e vê receita de login sumindo.&lt;/p&gt;

&lt;p&gt;O &lt;a href="https://share.pricingsaas.com/reports/ps_8KMfwWY/20260730_191924_cc337438/state-of-agent-monetization-q2-2026-deck.html" rel="noopener noreferrer"&gt;PricingSaaS, 2º trimestre de 2026&lt;/a&gt; mede o mercado nesse meio do caminho. Achou agente em 592 de 4.060 empresas: 14,6%. Dessas, 70% ainda metem o agente no plano, no mesmo assento. Entre as 46 que mostram uma unidade, 30 (65%) cobram em créditos. A maioria ainda vende cadeira. Quem já mede, mede um saldo de crédito, não o deal.&lt;/p&gt;

&lt;p&gt;Cena didática. Não é telemetria da minha empresa. Junho: 40 assentos HubSpot. O time inteiro abre o CRM. Julho: ligam o app do HubSpot no ChatGPT. Dez pessoas e três agentes pessoais (Dots, Grok Bot, Muse) fecham o mesmo volume: Closed Won no deal Q4, tarefa de renovação na terça, nota no ticket. O HubSpot grava a pessoa e o app. O CFO pergunta se cancela 20 assentos, porque 30 logins quase não abrem a tela. O vendor pergunta se cobra crédito por cada Closed Won, porque se o CFO cortar assento a receita cai. Ninguém consegue juntar as três coisas na mesma linha: quem pediu, qual ação rodou, qual deal mudou. E o HubSpot ainda limita o lote a 10 registros. A fatura discute cadeira e crédito. O trabalho foi o deal.&lt;/p&gt;

&lt;p&gt;Crédito não resolve porque é um saldo, não um resultado. Você queima crédito para o modelo escrever. Não sabe se o Closed Won era o certo, se a nota foi para o ticket certo, se o estorno deveria ter saído. Token é pior: a empresa paga por palavra. Palavra não é deal criado, caso fechado nem estorno aprovado.&lt;/p&gt;

&lt;p&gt;A unidade que fecha a conta tem nome de negócio, não de modelo. Deal criado. Caso fechado. Estorno aprovado. A &lt;a href="https://www.deloitte.com/global/en/insights/industry/technology/technology-media-and-telecom-predictions/2026/saas-ai-agents.html" rel="noopener noreferrer"&gt;Deloitte&lt;/a&gt; cita a Maxio: 83% das SaaS AI-native já cobram por uso. Elas nasceram sem depender da cadeira. Quem já vende o produto antigo ainda cobra o assento e tenta colar crédito em cima. Por isso a fatura fica torta: um lado corta login, o outro vende saldo, e o Closed Won não aparece em nenhum dos dois boletos.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. O que some quando ninguém abre a tela
&lt;/h2&gt;

&lt;p&gt;A tela não era só bonita. Ela era o controle. Você via o nome da Maria no canto. O botão de Closed Won só aparecia se o deal tivesse o campo obrigatório. O gerente abria o histórico e via quem clicou, às 14h32. Quando o agente passa a executar sem abrir o site, esses três controles não viajam sozinhos. Se ninguém os reconstruir, o trabalho some no escuro.&lt;/p&gt;

&lt;p&gt;Eu já escrevi o par no &lt;a href="https://dev.to/tiagovilasboas/claude-code-copilot-e-cursor-na-empresa-um-padrao-por-fluxo-571i"&gt;coding agent&lt;/a&gt;: regra antes, prova depois. Aqui é o software de negócio, não o editor.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Quem é.&lt;/strong&gt; Na tela, a Maria está logada. Quando o agente age, precisa usar o crachá dela, não um usuário genérico chamado "bot". O &lt;a href="https://knowledge.hubspot.com/integrations/connect-your-hubspot-account-to-chatgpt" rel="noopener noreferrer"&gt;HubSpot&lt;/a&gt; já faz a parte fácil: o histórico grava a Maria e o app do ChatGPT. O &lt;a href="https://developer.salesforce.com/docs/platform/hosted-mcp-servers/guide/headless-360-mcp.html" rel="noopener noreferrer"&gt;Salesforce&lt;/a&gt; escreve a mesma regra: se a Maria não pode fazer a ação no CRM, o agente dela também não pode. A &lt;a href="https://docs.x.ai/grok-bot/overview" rel="noopener noreferrer"&gt;docs do Grok Bot&lt;/a&gt; mostra o furo. Os Bots da mesma pessoa compartilham computador, login e sessão. Se a Maria do financeiro e o Bot de vendas dela usam a mesma máquina na nuvem, o crachá do diretor que ficou aberto no browser escreve o CRM inteiro. A tela escondia isso. O caminho sem tela não esconde.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;O que pode.&lt;/strong&gt; Na tela, o catálogo é o que os botões mostram. Poucas ações. Sem a tela, o agente pergunta o que dá para fazer e executa. Precisa de um catálogo pequeno e de um log com duas linhas: o que a Maria pediu e o que de fato rodou. Sem as duas, ninguém sabe se "fecha o Q4" virou o deal certo. O HubSpot ainda tem um buraco documentado: a regra extra do funil &lt;strong&gt;não corre&lt;/strong&gt; pelo app do ChatGPT. Na tela, o Closed Won pedia um campo. No chat, o campo some e o deal fecha. A empresa pagou o CRM e perdeu o portão que a tela carregava.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Como cobra, e como desfaz.&lt;/strong&gt; Na tela, o gerente rebobina: Maria, Closed Won, 14h32. Quando o agente age, a fatura e o histórico precisam do mesmo filme: quem pediu, qual ação, qual resultado. Sem isso, o CFO da seção 5 não distingue deal criado de crédito queimado. E a &lt;a href="https://www.deloitte.com/global/en/insights/industry/technology/technology-media-and-telecom-predictions/2026/saas-ai-agents.html" rel="noopener noreferrer"&gt;Deloitte&lt;/a&gt; insiste no óbvio que o anúncio esquece: precisa existir um lugar para ver, reverter e auditar. Se o agente virar o Q4 para Closed Won por engano, alguém tem que abrir a sala de controle e desfazer. Apagar a tela antes desse lugar existir é apagar o filme.&lt;/p&gt;

&lt;p&gt;Os três, juntos, são o que some quando você só cola um chat na home. Identidade no mesmo nome. Catálogo pequeno com log das duas pontas. Fatura e replay no resultado de negócio. Sem isso, o agente trabalha. A empresa não sabe para quem, o quê, nem quanto custou.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Oportunidades, e o que não é
&lt;/h2&gt;

&lt;p&gt;Duas frentes que o mercado ainda está barato. Eu quase deixei de fora.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Skill para o agente pessoal.&lt;/strong&gt; O produto não é uma tela nova. É o workflow que o Dots, o Grok Bot ou a Muse já corre no computador da nuvem. A &lt;a href="https://www.peakapp.ai/" rel="noopener noreferrer"&gt;Peak&lt;/a&gt; vende isso de frente: 40+ Skills prontas (Virtual CMO, campanha, imagem, SEO) e o Cliff monta skill nova em linguagem natural, sem ticket de TI. A segunda-feira do founder: cola o e-mail no Codex e o HubSpot ganha deal, contato e empresa. A &lt;a href="https://docs.x.ai/grok-bot/overview" rel="noopener noreferrer"&gt;docs do Grok Bot&lt;/a&gt; descreve o mesmo caminho sem vendor de marketing: você faz o job uma vez, o Bot grava como skill e roda de novo. A &lt;a href="https://news.adobe.com/news/2026/04/adobe-redefines-custome-experience" rel="noopener noreferrer"&gt;Adobe&lt;/a&gt; anunciou catálogo: skill que lê métrica e monta conteúdo ou jornada. &lt;a href="https://github.com/coreyhaines31/marketingskills" rel="noopener noreferrer"&gt;marketingskills&lt;/a&gt; é o lado grátis, pack de CRO, SEO e copy. Pack grátis não é o negócio. O negócio é a skill com crachá, audit e fatura.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;SaaS IA-native.&lt;/strong&gt; Nasce headless. Não cola chat na tela e chama de agente. A &lt;a href="https://www.deloitte.com/global/en/insights/industry/technology/technology-media-and-telecom-predictions/2026/saas-ai-agents.html" rel="noopener noreferrer"&gt;Deloitte&lt;/a&gt; já separa o incumbente que "agentifica" o produto antigo da empresa AI-first que compete no serviço feito. A Maxio, no mesmo texto, achou cobrança por uso em 83% das SaaS AI-native. A Peak não pediu para o time abrir o site: vendeu a Skill onde o agente já mora. O &lt;a href="https://share.pricingsaas.com/reports/ps_8KMfwWY/20260730_191924_cc337438/state-of-agent-monetization-q2-2026-deck.html" rel="noopener noreferrer"&gt;PricingSaaS&lt;/a&gt; mostra o outro lado: 70% de quem já tem agente ainda empacota no plano. Quem nasce IA-native cobra o deal criado, não o assento.&lt;/p&gt;

&lt;p&gt;Se você &lt;strong&gt;já tem um SaaS&lt;/strong&gt; (CRM, checkout, atendimento, marketing), o dinheiro não está em colar um chat na home. Está em três produtos que o time de produto já sabe nomear.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Produto headless.&lt;/strong&gt; O seu produto já faz o trabalho na tela. Closed Won, log de ligação, estorno, cancelar pedido. A oportunidade é deixar o Dots, o Grok Bot ou o ChatGPT fazer a &lt;strong&gt;mesma ação&lt;/strong&gt; sem abrir o seu site. O mercado também chama isso de agent-ready: o agente é um usuário do produto, não um visitante do chat. O Salesforce descreve em quatro passos que qualquer PM entende: o agente pergunta o que dá para fazer, lê o que a ação pede, executa, ou só consulta. A empresa já te paga. Você passa a vender a ação, não o clique. Segunda-feira: o vendedor manda "fecha o deal Q4" e o deal muda. Sem tela nova.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Sala de controle.&lt;/strong&gt; Quando o agente trabalha, o gerente perdeu o filme da tela: quem clicou, quando, o que mudou. Alguém precisa de uma tela para ver quem pediu, o que rodou, quanto custou e &lt;strong&gt;desfazer&lt;/strong&gt; o Closed Won errado. O &lt;a href="https://knowledge.hubspot.com/integrations/connect-your-hubspot-account-to-chatgpt" rel="noopener noreferrer"&gt;HubSpot&lt;/a&gt; já grava o começo: a Maria e o app do ChatGPT. Isso não é a sala. É o log. O produto que falta é a tela do gerente, não a do vendedor. A &lt;a href="https://www.deloitte.com/global/en/insights/industry/technology/technology-media-and-telecom-predictions/2026/saas-ai-agents.html" rel="noopener noreferrer"&gt;Deloitte&lt;/a&gt; chama isso de lugar para ver, reverter e auditar.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Conector com trava.&lt;/strong&gt; Não liberar escrita no primeiro dia. O caminho que o HubSpot documentou é o playbook de produto: primeiro o agente só lê; depois escreve; no máximo 10 registros por vez; a permissão tem que ser explícita; o ChatGPT mostra a mudança e pede um sim. Segunda-feira segura: o agente resume o mês de e-mail. O vendedor confirma. Só então o deal vira Closed Won. Quem libera tudo de uma vez herda o furo da mesma KB: a validação da tela &lt;strong&gt;não corre&lt;/strong&gt; no chat.&lt;/p&gt;

&lt;p&gt;Três coisas que &lt;strong&gt;parecem&lt;/strong&gt; oportunidade e não pagam.&lt;/p&gt;

&lt;p&gt;O agente que &lt;strong&gt;clica no seu site&lt;/strong&gt; como se fosse um estagiário. O &lt;a href="https://x.ai/news/introducing-grok-bot" rel="noopener noreferrer"&gt;Grok Bot&lt;/a&gt; entra em página sem uma porta oficial. Na terça o designer muda um botão e o fluxo quebra. Isso não é produto headless. É automação frágil com notebook alugado.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Apagar a tela&lt;/strong&gt; antes de existir o desfazer. Se o agente virar o Q4 para ganho por engano, o PM precisa de um lugar para reverter. Sem essa tela, você não lançou SaS. Apagou o filme.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Chamar o WhatsApp de case.&lt;/strong&gt; "O motoboy atrasou, avisa o cliente" já cabe num chat. Se o pedido, o estorno e o split não mudam no sistema, você vendeu conversa. Não vendeu a ação.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[ ] A ação existe sem a tela? (cancelar, estornar, fechar deal)
[ ] O agente acha a ação sozinho, ou alguém colou um endereço escondido?
[ ] A permissão é a da Maria, com o nome dela no histórico?
[ ] Dá para só ler, e pedir sim, antes de escrever?
[ ] A fatura aponta a ação + quem pediu + o que mudou?
[ ] A skill roda no Dots, no Grok Bot ou na Muse, ou só no seu site?
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O que eu meço no dia a dia é agente de sessão, o &lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;Downshift&lt;/a&gt;. CRM headless, para mim, ainda é receita de vendor. Isso só vira SaS quando a fatura cobra o trabalho, não a cadeira.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Para debater.&lt;/strong&gt; Pensa no SaaS que você constrói ou que a sua empresa paga. Na segunda-feira, qual frase é verdadeira?&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A)&lt;/strong&gt; A gente escolheu &lt;strong&gt;uma&lt;/strong&gt; ação de verdade (fechar deal, registrar ligação, estornar o PIX) e consegue ver &lt;strong&gt;quem&lt;/strong&gt; pediu. Ainda não é o produto inteiro. É a primeira ação que o agente faz sem abrir o nosso site.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;B)&lt;/strong&gt; O HubSpot, o Salesforce ou o Adobe estão ligados &lt;strong&gt;só para ler&lt;/strong&gt;. O agente resume e sugere. Uma pessoa diz sim. Ninguém escreve sozinho.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;C)&lt;/strong&gt; O produto ainda é a tela. O "agente" é o chat da home. O vendedor continua clicando no console.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;D)&lt;/strong&gt; A gente empacotou um workflow (e-mail vira deal, ata vira follow-up) e cobra isso no Dots, no Grok Bot ou na Muse. Não cobramos mais um assento para abrir o site.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Responde a letra e a primeira ação. Fechar deal, registrar ligação, estornar, montar campanha ou uma skill de follow-up.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>saas</category>
      <category>architecture</category>
      <category>braziliandevs</category>
    </item>
    <item>
      <title>Jev e Laya além do hype: o que modelos de decisão fazem que o LLM não faz</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Thu, 01 Oct 2026 23:59:14 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/jev-e-laya-alem-do-hype-o-que-modelos-de-decisao-fazem-que-o-llm-nao-faz-5f1j</link>
      <guid>https://dev.to/tiagovilasboas/jev-e-laya-alem-do-hype-o-que-modelos-de-decisao-fazem-que-o-llm-nao-faz-5f1j</guid>
      <description>&lt;p&gt;Enquanto eu estudava o &lt;a href="https://openrouter.ai/docs/guides/community/jev" rel="noopener noreferrer"&gt;Jev&lt;/a&gt; e a &lt;a href="https://laya.studio/compare/laya-vs-jev" rel="noopener noreferrer"&gt;Laya&lt;/a&gt;, o feed vendia os dois como o próximo LLM pequeno. Mini-ChatGPT, tweet de lançamento. Esse é o hype. Além dele, o que eles fazem é escolher uma porta, não escrever um parágrafo.&lt;/p&gt;

&lt;p&gt;A porta serve delivery no WhatsApp, central de atendimento, marketplace, loja que vive de pedido e estorno. "Cadê o pedido?", "cancela", "quero estorno". O reflexo é chamar um LLM: ele escreve um texto e você ainda extrai a etiqueta. O Jev devolve a escolha em 0,17 s de P50 no &lt;a href="https://openrouter.ai/typesafe/jev-1.13" rel="noopener noreferrer"&gt;OpenRouter&lt;/a&gt;. Time pequeno resolve com a API, ou com a Laya no localhost. A &lt;a href="https://huggingface.co/SupersonicLabs/Julia-1" rel="noopener noreferrer"&gt;Julia-1&lt;/a&gt; entra na mesma família, de passagem.&lt;/p&gt;

&lt;p&gt;Eu cheguei nisso pelo &lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;Downshift&lt;/a&gt;. Cada subagente acordava no topo do SWE-bench. Jev e Laya são classificadores. Estudar eles me deu a ideia de adotar um no Downshift também. O MiniLM local foi essa adoção. Com Jev e Laya eu só fiz POCs. Os exemplos da seção 8 saem do &lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;Downshift&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Índice
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;1. LLM adivinha a próxima palavra, Jev escolhe uma porta&lt;/li&gt;
&lt;li&gt;2. Jev na prática: saída finita, confiança e log&lt;/li&gt;
&lt;li&gt;2b. Preço, latência e o que o pessoal já fez&lt;/li&gt;
&lt;li&gt;3. Quando texto livre vence: o LLM entra depois da decisão&lt;/li&gt;
&lt;li&gt;4. A dupla que economiza token: Jev filtra, LLM só entra quando precisa&lt;/li&gt;
&lt;li&gt;5. Trade-offs honestos de modelo de decisão contra LLM&lt;/li&gt;
&lt;li&gt;6. Antes de mandar pro Opus, decida se ele entra na rota&lt;/li&gt;
&lt;li&gt;7. Evidência: o que a pesquisa sustenta&lt;/li&gt;
&lt;li&gt;8. Jev e Laya no seu harness pessoal&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  1. LLM adivinha a próxima palavra, Jev escolhe uma porta
&lt;/h2&gt;

&lt;p&gt;LLM é um modelo generativo. Ele prevê a próxima palavra dada a sequência anterior. Por isso ele escreve, resume, traduz e explica bem. E por isso a mesma pergunta pode gerar três respostas diferentes, com temperatura, ordem e contexto mudando o resultado.&lt;/p&gt;

&lt;p&gt;Jev é o oposto: um modelo classificador e de decisão. Ele é produto real, o System One decision model da TypeSafe, disponível como &lt;a href="https://openrouter.ai/typesafe/jev-1.13" rel="noopener noreferrer"&gt;&lt;code&gt;typesafe/jev-1.13&lt;/code&gt;&lt;/a&gt; no OpenRouter. Ele recebe um estado e devolve uma entre N classes que você definiu antes, com probabilidade calibrada e tipos nativos como &lt;code&gt;noul&lt;/code&gt;, &lt;code&gt;choice&lt;/code&gt; e &lt;code&gt;score&lt;/code&gt;. Cena didática, para o mecanismo ficar visível. Não é telemetria da minha loja:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;entrada: "minha fatura veio dobrada, quero estorno"
Jev -&amp;gt; { label: "reembolso", confidence: 0.94 }
entrada: "onde acompanho minha entrega?"
Jev -&amp;gt; { label: "rastreio", confidence: 0.91 }
entrada: "quero falar do plano anual para 40 pessoas"
Jev -&amp;gt; { label: "comercial", confidence: 0.88 }
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Nada de parágrafo. Só etiqueta mais confiança. O número que não é cena está no &lt;a href="https://openrouter.ai/labs/jev/triage" rel="noopener noreferrer"&gt;Jev Lab de triage&lt;/a&gt;: 95 mensagens, cinco perguntas sim ou não, 475 respostas em 1,2 s, $0,0014 a rodada. E Laya também não é apelido: é um engine System One open-source que expõe o mesmo protocolo &lt;code&gt;/v1/systemone&lt;/code&gt; do Jev, com modelos &lt;code&gt;english&lt;/code&gt;, &lt;code&gt;multilingual&lt;/code&gt; e &lt;code&gt;typed-decisions&lt;/code&gt; (ver &lt;a href="https://spring-ai-community.github.io/spring-ai-typesafe/latest/client/Laya/" rel="noopener noreferrer"&gt;guia de uso&lt;/a&gt;), para decidir local sem API key. Quem redige a resposta final para o cliente é um LLM comum, que entra depois que a rota já foi decidida.&lt;/p&gt;

&lt;p&gt;A diferença que importa para um mid-level recontar em uma frase: LLM escreve texto aberto e varia; Jev aponta uma porta entre poucas portas e repete.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Jev na prática: saída finita, confiança e log
&lt;/h2&gt;

&lt;p&gt;O mecanismo, sem chamar a API do Jev. Um classificador simples resolve sem GPU, sem prompt de 2 mil tokens, sem retry criativo. Qualquer dev roda local:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight python"&gt;&lt;code&gt;&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;sklearn.feature_extraction.text&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;TfidfVectorizer&lt;/span&gt;
&lt;span class="kn"&gt;from&lt;/span&gt; &lt;span class="n"&gt;sklearn.linear_model&lt;/span&gt; &lt;span class="kn"&gt;import&lt;/span&gt; &lt;span class="n"&gt;LogisticRegression&lt;/span&gt;

&lt;span class="n"&gt;texts&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;
  &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;quero reembolso da fatura&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;cobrança duplicada no cartão&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;onde está minha entrega&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;rastrear meu pedido&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;orçamento para empresa&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;plano anual para time&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
&lt;span class="p"&gt;]&lt;/span&gt;
&lt;span class="n"&gt;labels&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;reembolso&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;reembolso&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;rastreio&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;rastreio&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;comercial&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;comercial&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;

&lt;span class="n"&gt;vec&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;TfidfVectorizer&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
&lt;span class="n"&gt;X&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;vec&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;fit_transform&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;texts&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;
&lt;span class="n"&gt;decisor&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nc"&gt;LogisticRegression&lt;/span&gt;&lt;span class="p"&gt;().&lt;/span&gt;&lt;span class="nf"&gt;fit&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;X&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="n"&gt;labels&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt;

&lt;span class="k"&gt;def&lt;/span&gt; &lt;span class="nf"&gt;decidir&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;frase&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nb"&gt;str&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="o"&gt;-&amp;gt;&lt;/span&gt; &lt;span class="nb"&gt;dict&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt;
    &lt;span class="n"&gt;proba&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;decisor&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;predict_proba&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;vec&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;transform&lt;/span&gt;&lt;span class="p"&gt;([&lt;/span&gt;&lt;span class="n"&gt;frase&lt;/span&gt;&lt;span class="p"&gt;]))[&lt;/span&gt;&lt;span class="mi"&gt;0&lt;/span&gt;&lt;span class="p"&gt;]&lt;/span&gt;
    &lt;span class="n"&gt;idx&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="n"&gt;proba&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;argmax&lt;/span&gt;&lt;span class="p"&gt;()&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;label&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="n"&gt;decisor&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="n"&gt;classes_&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;idx&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt; &lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;confidence&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nf"&gt;round&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;float&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="n"&gt;proba&lt;/span&gt;&lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="n"&gt;idx&lt;/span&gt;&lt;span class="p"&gt;]),&lt;/span&gt; &lt;span class="mi"&gt;2&lt;/span&gt;&lt;span class="p"&gt;)}&lt;/span&gt;

&lt;span class="nf"&gt;print&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nf"&gt;decidir&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="s"&gt;fui cobrado duas vezes&lt;/span&gt;&lt;span class="sh"&gt;"&lt;/span&gt;&lt;span class="p"&gt;))&lt;/span&gt;
&lt;span class="c1"&gt;# -&amp;gt; {"label": "reembolso", "confidence": 0.81}
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Três propriedades que o LLM não te dá de graça:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Saída finita:&lt;/strong&gt; só existem &lt;code&gt;reembolso&lt;/code&gt;, &lt;code&gt;rastreio&lt;/code&gt;, &lt;code&gt;comercial&lt;/code&gt;. Dá para validar com &lt;code&gt;enum&lt;/code&gt;, testar com tabela, auditar no Grafana.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Confiança calibrável:&lt;/strong&gt; abaixo de 0.70 você manda para revisão humana ou para o LLM com contexto extra. Acima, segue o fluxo automático.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Determinismo:&lt;/strong&gt; mesma entrada, mesma saída. Sem temperatura para tunar, sem prompt que quebra porque alguém mudou uma vírgula.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;É por isso que time de suporte e pagamento gosta de decisor: dá para escrever teste unitário em cima. Com LLM puro, cada teste vira aproximação semântica.&lt;/p&gt;

&lt;p&gt;Isso não é opinião. Em intenção com rótulo fixo, pequeno fine-tuned ainda vence grande generativo: em Banking-77 e CLINC-150, DistilBERT superou Phi-2 e Llama-3-8B com PEFT, com F1 em torno de 0.92 contra 0.88 e 0.83, treinando e inferindo mais rápido. Em CLINC-150 com 151 intenções, DistilBERT marcou 0.889 de acurácia com 5.3ms contra 0.888 da RoBERTa. Para tabular, CatBoost, LightGBM e XGBoost seguem no topo do benchmark amplo com 20 modelos, à frente de MLP e ResNet na maioria dos datasets.&lt;/p&gt;

&lt;h2&gt;
  
  
  2b. Preço, latência e o que o pessoal já fez
&lt;/h2&gt;

&lt;p&gt;Números do OpenRouter no dia em que eu conferi. A latência do LLM é o começo da resposta: depois ele escreve e você paga a saída. A do Jev é a decisão inteira.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Modelo&lt;/th&gt;
&lt;th&gt;Entrada / 1M&lt;/th&gt;
&lt;th&gt;Saída / 1M&lt;/th&gt;
&lt;th&gt;Latência P50&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://openrouter.ai/typesafe/jev-1.13" rel="noopener noreferrer"&gt;Jev 1.13&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;$0.042&lt;/td&gt;
&lt;td&gt;$0&lt;/td&gt;
&lt;td&gt;0,17 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://openrouter.ai/google/gemini-2.5-flash-lite" rel="noopener noreferrer"&gt;Gemini 2.5 Flash Lite&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;$0.10&lt;/td&gt;
&lt;td&gt;$0.40&lt;/td&gt;
&lt;td&gt;0,47 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://openrouter.ai/deepseek/deepseek-chat" rel="noopener noreferrer"&gt;DeepSeek V3&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;$0.2574&lt;/td&gt;
&lt;td&gt;$1.029&lt;/td&gt;
&lt;td&gt;0,58 s&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://openrouter.ai/deepseek/deepseek-v3.2" rel="noopener noreferrer"&gt;DeepSeek V3.2&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;$0.2088&lt;/td&gt;
&lt;td&gt;$0.3096&lt;/td&gt;
&lt;td&gt;0,27 s no melhor provider&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://openrouter.ai/deepseek/deepseek-r1" rel="noopener noreferrer"&gt;DeepSeek R1&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;$0.70&lt;/td&gt;
&lt;td&gt;$2.50&lt;/td&gt;
&lt;td&gt;1,17 s&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;O V3.2 barato no papel ($0.2088) aparece com 1,32 s em um provider. O R1 é o extremo: entrada 16x a do Jev, saída cara, mais de um segundo antes de começar. Para classificar antifraude ou liberar um request, o DeepSeek é o modelo errado. Para escrever o parecer depois da etiqueta, aí sim.&lt;/p&gt;

&lt;p&gt;O que já existe, com URL. Não achei delivery no WhatsApp em produção com número de negócio. O encaixe da intro é analogia. O que tem nome é isto.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Lab, ao vivo no browser&lt;/strong&gt; (&lt;a href="https://openrouter.ai/labs/jev" rel="noopener noreferrer"&gt;Jev Lab&lt;/a&gt;):&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://openrouter.ai/labs/jev/triage" rel="noopener noreferrer"&gt;Triage de atendimento&lt;/a&gt;: 95 mensagens, 475 respostas em 1,2 s, $0,0014 a rodada.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://openrouter.ai/labs/jev/notice" rel="noopener noreferrer"&gt;Checkout que reage ao clique&lt;/a&gt;: 8 respostas em 300 ms, $0,0001 por checagem.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://openrouter.ai/labs/jev/feed" rel="noopener noreferrer"&gt;Filtro de feed&lt;/a&gt;: 40 posts em 0,5 s, $0,0003 a rodada.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Receita oficial&lt;/strong&gt; (&lt;a href="https://openrouter.ai/docs/guides/community/jev" rel="noopener noreferrer"&gt;hub do Jev&lt;/a&gt;):&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://openrouter.ai/docs/cookbook/coding-agents/auto-approve-permission-prompts-with-jev" rel="noopener noreferrer"&gt;Permissão de coding agent&lt;/a&gt;: libera &lt;code&gt;git diff&lt;/code&gt; e &lt;code&gt;bun test&lt;/code&gt;, segura &lt;code&gt;git push --force&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://openrouter.ai/docs/cookbook/evaluate-and-optimize/jev-classification" rel="noopener noreferrer"&gt;Classificar e taguear em lote&lt;/a&gt;: ticket, post, review. $0,014 em 550 tweets no exemplo publicado.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://openrouter.ai/blog/tutorials/how-to-use-jev/" rel="noopener noreferrer"&gt;Moderação de marketplace&lt;/a&gt;: categoria errada, preço estranho, PIX por fora.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://openrouter.ai/docs/cookbook/evaluate-and-optimize/jev-verified-cascade" rel="noopener noreferrer"&gt;Cascata barata com verificação&lt;/a&gt;: o frontier só entra se o Jev recusar o rascunho.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;Repo da comunidade:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://github.com/Ayush0054/metis" rel="noopener noreferrer"&gt;metis-triage&lt;/a&gt;: issue vira label. O comentário continua template.&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://github.com/jkudish/jev-mcp" rel="noopener noreferrer"&gt;jev-mcp&lt;/a&gt; e &lt;a href="https://github.com/devagrawal09/jev-review" rel="noopener noreferrer"&gt;jev-review&lt;/a&gt;: julgamento no MCP e review de diff.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  3. Quando texto livre vence: o LLM entra depois da decisão
&lt;/h2&gt;

&lt;p&gt;Seria desonesto dizer que Jev resolve tudo. Quando a resposta precisa de nuance, contexto longo ou empatia, texto livre vence.&lt;/p&gt;

&lt;p&gt;Cena que o classificador não resolve sozinho:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;cliente: "assinei o anual ontem, mas meu sócio saiu hoje
e vamos reduzir de 40 para 6 pessoas. Consigo ajustar
sem multa? Estou preocupado com o orçamento."

Jev -&amp;gt; { label: "comercial", confidence: 0.83 }
LLM -&amp;gt; redige proposta com 2 opções, cita cláusula
de redução, sugere data de vigência e pergunta qual prefere.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O Jev acertou a rota em milissegundos. Mas só o modelo generativo monta a resposta com tom, condição e alternativa. Tentar fazer isso com regra e template vira um ninho de &lt;code&gt;if&lt;/code&gt; que ninguém mantém depois de três meses.&lt;/p&gt;

&lt;p&gt;Regra prática que uso: Jev e Laya decidem &lt;strong&gt;o quê&lt;/strong&gt; fazer; o LLM decide &lt;strong&gt;como dizer&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. A dupla que economiza token: Jev filtra, LLM só entra quando precisa
&lt;/h2&gt;

&lt;p&gt;O ganho de token não vem de mágica. Vem de não chamar o modelo caro para o trabalho barato. Em uma frase: o roteador tira do LLM a triagem, a classificação e o gate de confiança, e deixa para ele só a redação final. O resto desta seção mostra como isso fica em código.&lt;/p&gt;

&lt;p&gt;Padrão que tenho aplicado, roteador antes do gerador:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="kd"&gt;type&lt;/span&gt; &lt;span class="nx"&gt;Rota&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;reembolso&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;rastreio&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;comercial&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt; &lt;span class="o"&gt;|&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;revisao_humana&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt;

&lt;span class="k"&gt;async&lt;/span&gt; &lt;span class="kd"&gt;function&lt;/span&gt; &lt;span class="nf"&gt;atender&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;ticket&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kr"&gt;string&lt;/span&gt;&lt;span class="p"&gt;):&lt;/span&gt; &lt;span class="nb"&gt;Promise&lt;/span&gt;&lt;span class="o"&gt;&amp;lt;&lt;/span&gt;&lt;span class="kr"&gt;string&lt;/span&gt;&lt;span class="o"&gt;&amp;gt;&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;decisao&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;jevDecide&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;ticket&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// Jev via API ou Laya local: milissegundos, custo quase zero&lt;/span&gt;

  &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;decisao&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;confidence&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="mf"&gt;0.7&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;filaRevisao&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;ticket&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;decisao&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// humano decide, sem gastar LLM&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;

  &lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;decisao&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;label&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;rastreio&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;respostaTemplateRastreio&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;ticket&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt; &lt;span class="c1"&gt;// nem chama LLM&lt;/span&gt;
  &lt;span class="p"&gt;}&lt;/span&gt;

  &lt;span class="c1"&gt;// só aqui o LLM entra, já com rota e contexto enxuto&lt;/span&gt;
  &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;llmResponder&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;ticket&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;decisao&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;label&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Por que isso corta custo de verdade:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ticket de rastreio nunca acorda o LLM: lookup mais template.&lt;/li&gt;
&lt;li&gt;Ticket ambíguo vai para humano antes de gastar retries; quando o LLM entra, o prompt já vem curto e com a intenção resolvida.&lt;/li&gt;
&lt;li&gt;Sem chave de API ou offline, a Laya decide local no mesmo protocolo, sem mudar o request.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Laya no seu dia a dia: o mesmo request, sem API key. Suba o &lt;code&gt;laya-serve&lt;/code&gt; local e aponte o cliente para ele. O protocolo é o mesmo do Jev, então o código que você testa na máquina é o que falaria com o gerenciado:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="c1"&gt;// TYPESAFE_BASE_URL=http://localhost:8002 TYPESAFE_API_KEY=local-test (Laya local)&lt;/span&gt;
&lt;span class="c1"&gt;// TYPESAFE_BASE_URL=https://api.typesafe.ai (Jev gerenciado)&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;res&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nf"&gt;fetch&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="s2"&gt;`&lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;env&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;TYPESAFE_BASE_URL&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;/v1/systemone`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="na"&gt;method&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;POST&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="na"&gt;headers&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
    &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Authorization&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;`Bearer &lt;/span&gt;&lt;span class="p"&gt;${&lt;/span&gt;&lt;span class="nx"&gt;process&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;env&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;TYPESAFE_API_KEY&lt;/span&gt;&lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="s2"&gt;`&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
    &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Content-Type&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;application/json&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="p"&gt;},&lt;/span&gt;
  &lt;span class="na"&gt;body&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="nx"&gt;JSON&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;stringify&lt;/span&gt;&lt;span class="p"&gt;({&lt;/span&gt;
    &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;typed-decisions&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="c1"&gt;// na Laya: english, multilingual ou typed-decisions&lt;/span&gt;
    &lt;span class="na"&gt;state&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="na"&gt;ticket&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;fui cobrado duas vezes na fatura&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt; &lt;span class="p"&gt;},&lt;/span&gt;
    &lt;span class="na"&gt;questions&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
      &lt;span class="na"&gt;rota&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;choice&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="na"&gt;instructions&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Para qual fila vai este ticket?&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="na"&gt;labels&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;[&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;reembolso&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;rastreio&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;comercial&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;],&lt;/span&gt;
      &lt;span class="p"&gt;},&lt;/span&gt;
      &lt;span class="na"&gt;confianca_baixa&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt;
        &lt;span class="na"&gt;type&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;noul&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="na"&gt;instructions&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;O pedido está ambíguo ou fora do escopo das filas?&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
        &lt;span class="na"&gt;labels&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="na"&gt;yes&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Ambíguo&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="na"&gt;no&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;Claro&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt; &lt;span class="p"&gt;},&lt;/span&gt;
      &lt;span class="p"&gt;},&lt;/span&gt;
    &lt;span class="p"&gt;},&lt;/span&gt;
  &lt;span class="p"&gt;}),&lt;/span&gt;
&lt;span class="p"&gt;});&lt;/span&gt;
&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nx"&gt;answers&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="k"&gt;await&lt;/span&gt; &lt;span class="nx"&gt;res&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nf"&gt;json&lt;/span&gt;&lt;span class="p"&gt;();&lt;/span&gt; &lt;span class="c1"&gt;// tipado, com probabilidade: sem parsing de texto&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Três usos que a POC me pagou:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Dev local sem key:&lt;/strong&gt; testo o roteador no &lt;code&gt;localhost&lt;/code&gt; antes de gastar um token sequer.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CI:&lt;/strong&gt; o teste do roteador vira assert em cima de &lt;code&gt;answers.rota&lt;/code&gt;, igual teste de &lt;code&gt;enum&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fallback:&lt;/strong&gt; sem rede ou sem verba de API, a Laya decide local; com chave, o mesmo código fala com o Jev.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Esquema completo de campos no &lt;a href="https://laya.studio/compare/laya-vs-jev" rel="noopener noreferrer"&gt;comparativo Laya vs Jev&lt;/a&gt;. E re-tune não é conselho vago, é número: para a distribuição &lt;code&gt;{0.91, 0.04, 0.03, 0.02}&lt;/code&gt;, a Laya reporta confiança ~0.71, onde a fórmula de probabilidade máxima daria ~0.88. Mesmo request, gate diferente. Calibre o corte por fonte:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight typescript"&gt;&lt;code&gt;&lt;span class="kd"&gt;const&lt;/span&gt; &lt;span class="nx"&gt;corte&lt;/span&gt; &lt;span class="o"&gt;=&lt;/span&gt; &lt;span class="nx"&gt;fonte&lt;/span&gt; &lt;span class="o"&gt;===&lt;/span&gt; &lt;span class="dl"&gt;"&lt;/span&gt;&lt;span class="s2"&gt;laya&lt;/span&gt;&lt;span class="dl"&gt;"&lt;/span&gt; &lt;span class="p"&gt;?&lt;/span&gt; &lt;span class="mf"&gt;0.6&lt;/span&gt; &lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="mf"&gt;0.7&lt;/span&gt;&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="c1"&gt;// Laya e Jev não compartilham threshold&lt;/span&gt;
&lt;span class="k"&gt;if &lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;decisao&lt;/span&gt;&lt;span class="p"&gt;.&lt;/span&gt;&lt;span class="nx"&gt;confidence&lt;/span&gt; &lt;span class="o"&gt;&amp;lt;&lt;/span&gt; &lt;span class="nx"&gt;corte&lt;/span&gt;&lt;span class="p"&gt;)&lt;/span&gt; &lt;span class="k"&gt;return&lt;/span&gt; &lt;span class="nf"&gt;filaRevisao&lt;/span&gt;&lt;span class="p"&gt;(&lt;/span&gt;&lt;span class="nx"&gt;ticket&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt; &lt;span class="nx"&gt;decisao&lt;/span&gt;&lt;span class="p"&gt;);&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Em termos de harness: Jev é guia computacional antes da geração. Ele é barato, testável e roda no PR e CI como qualquer código. O LLM fica como passo inferencial depois do gate, com trilha de auditoria do que o decisor escolheu. Se um dia o decisor errar, você tem label, confiança e entrada no log, não um prompt gigante para adivinhar o que aconteceu.&lt;/p&gt;

&lt;p&gt;Quanto custa decidir, em números verificados:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Jev gerenciado:&lt;/strong&gt; $0.042 por milhão de tokens de entrada, saída grátis (&lt;a href="https://openrouter.ai/typesafe/jev-1.13" rel="noopener noreferrer"&gt;preço do Jev 1.13&lt;/a&gt;). Cada resposta traz &lt;code&gt;usage.cost&lt;/code&gt; em dólar: dá para logar custo por rota junto com label e confiança.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Laya local:&lt;/strong&gt; custo marginal perto de zero. Você paga a máquina que já tem mais o download do modelo, e decide offline quantas vezes quiser.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Ordem de grandeza (estimativa da minha POC, não benchmark):&lt;/strong&gt; avaliação via decisor sai cerca de 50 a 100x mais barata que a mesma avaliação via GPT-4, que custa por token de entrada e de saída a cada retry.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Por isso a conta fecha: o roteador tira do LLM as chamadas baratas e repetidas (triagem, classificação, gate de confiança) e deixa para ele só a redação final. Cada ticket de rastreio que nunca acorda o LLM é token que não aparece na fatura.&lt;/p&gt;

&lt;p&gt;O número que sustenta esse desenho vem de roteamento entre modelos: RouteLLM economizou até 3.66x no MT-Bench mantendo 95% da qualidade do GPT-4, e FrugalGPT em cascata economizou de 50% a 98% mantendo a acurácia do melhor modelo isolado. A lógica é a mesma do Jev: não acordar o modelo caro para o trabalho barato.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Trade-offs honestos de modelo de decisão contra LLM
&lt;/h2&gt;

&lt;p&gt;Visão Staff, sem hype de mercado. Cada linha abaixo já me mordeu ao menos uma vez.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Dimensão&lt;/th&gt;
&lt;th&gt;Jev (decisão)&lt;/th&gt;
&lt;th&gt;LLM generativo&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Determinismo&lt;/td&gt;
&lt;td&gt;Alto, mesma entrada repete&lt;/td&gt;
&lt;td&gt;Baixo, varia por temperatura e contexto&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Custo por chamada&lt;/td&gt;
&lt;td&gt;Centavos por milhão de tokens no Jev; quase zero na Laya local&lt;/td&gt;
&lt;td&gt;Pago por token, cada retry conta&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Latência&lt;/td&gt;
&lt;td&gt;Dezenas a centenas de ms (0,17 s de P50 no Jev)&lt;/td&gt;
&lt;td&gt;Centenas de ms a segundos, antes de escrever&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Dados para começar&lt;/td&gt;
&lt;td&gt;Jev/Laya: labels + instrução, sem treino; classificador próprio (sklearn): exemplos rotulados&lt;/td&gt;
&lt;td&gt;Funciona com zero ou poucos exemplos&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Mudança de escopo&lt;/td&gt;
&lt;td&gt;Jev/Laya: muda a lista de labels; classificador próprio: retreino&lt;/td&gt;
&lt;td&gt;Muda com prompt, sem retreino&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Texto aberto&lt;/td&gt;
&lt;td&gt;Não faz&lt;/td&gt;
&lt;td&gt;Faz bem&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Falha típica&lt;/td&gt;
&lt;td&gt;Erra calado fora da distribuição&lt;/td&gt;
&lt;td&gt;Inventa com confiança&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Três cuidados que o hype esconde:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Decisor apodrece em silêncio.&lt;/strong&gt; Se surge um produto novo ou um golpe novo, o Jev continua classificando com confiança alta no vocabulário velho. Sem monitoramento de distribuição e re-rotulagem periódica, vira débito técnico.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Rótulo custa gente.&lt;/strong&gt; LLM aceita 5 exemplos no prompt. Um classificador próprio pede centenas de exemplos revisados para ficar estável. Com Jev ou Laya você não treina, mas ainda precisa de um conjunto rotulado para medir acerto e calibrar o corte. Esse custo aparece no planejamento, não na demo.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;LLM cobre o buraco do decisor.&lt;/strong&gt; Classe nova, idioma novo, caso raro: o LLM atende no improviso enquanto você coleta dados para treinar o Jev. Arquitetura boa usa os dois, não elege um vencedor.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Deixar claro, porque já vi confusão em review: Jev e Laya não são mini ChatGPTs. Eles não conversam, não resumem, não escrevem. Laya cai na mesma coluna do Jev, com duas diferenças práticas: roda local e open-source, e os thresholds precisam ser re-tunados porque a confiança é calculada de outro jeito. Se você pedir texto para eles, vai receber etiqueta. Se pedir decisão auditável para o LLM puro, vai receber parágrafo bonito que muda amanhã. Sem texto livre não significa sem erro: o modelo pode devolver exatamente o enum esperado e ainda escolher o enum errado.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Antes de mandar pro Opus, decida se ele entra na rota
&lt;/h2&gt;

&lt;p&gt;O Jev ou a Laya não corrigem o botão. Eles decidem quem deveria corrigir.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;"corrija o texto desse botão"
        ↓
decision / router
        ↓
mecânica + baixo risco → modelo pequeno
        ↓
lint / teste passou?
   sim → encerra
   não → sobe para Sonnet / Sol / Opus
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;"Menor" não é número de parâmetros. É custo por tarefa, latência e capacidade suficiente. O nome do modelo muda. A estratégia não: a menor capacidade que ainda passa no seu critério.&lt;/p&gt;

&lt;p&gt;Benchmark é ponto de partida, não política de routing. O que vence o leaderboard pode perder no seu repo, com o seu contexto, as suas tools e o seu orçamento. No harness, o que importa é: acerto, custo por tarefa que deu certo, latência, retries, taxa de escalada, tokens, resultado de teste ou lint.&lt;/p&gt;

&lt;p&gt;Para comparar sem feeling: &lt;a href="https://artificialanalysis.ai/leaderboards/models" rel="noopener noreferrer"&gt;Artificial Analysis&lt;/a&gt; (custo, velocidade, latência) e &lt;a href="https://www.swebench.com/" rel="noopener noreferrer"&gt;SWE-bench Verified&lt;/a&gt; (tarefa real de engenharia). O resto é instrumentar a sua operação.&lt;/p&gt;

&lt;p&gt;Não escolha pela marca. Escolha o menor que cumpre. Se falhar, escale. É a tese do &lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;Downshift&lt;/a&gt;: small-first, frontier sob demanda.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Evidência: o que a pesquisa sustenta
&lt;/h2&gt;

&lt;p&gt;Sem prometer número do seu ticket. Estes são os benchmarks nos datasets deles, que uso como limite do que dá para afirmar:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Tabular:&lt;/strong&gt; benchmark com 20 modelos coloca CatBoost, LightGBM e XGBoost no topo, à frente de deep learning na maioria dos datasets (&lt;a href="https://arxiv.org/pdf/2408.14817" rel="noopener noreferrer"&gt;completo&lt;/a&gt;, &lt;a href="https://www.bohrium.com/en/blog/tutorials/xgboost-vs-lightgbm/" rel="noopener noreferrer"&gt;XGBoost vs LightGBM&lt;/a&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Intenção:&lt;/strong&gt; DistilBERT fine-tuned vence Phi-2 e Llama-3-8B em Banking-77 e CLINC-150, com F1 0.92 contra 0.88 e 0.83 (&lt;a href="https://exa.ai/library/publication/zpf618k29c9" rel="noopener noreferrer"&gt;Intent Recognition using DistilBERT&lt;/a&gt;). Em CLINC-150, 0.889 de acurácia com 5.3ms de inferência (&lt;a href="https://ieeexplore.ieee.org/document/11118772" rel="noopener noreferrer"&gt;avaliação BERT, RoBERTa e DistilBERT&lt;/a&gt;). Híbrido encoder mais LLM mantém precisão com cerca de 50% menos latência (&lt;a href="https://aclanthology.org/2024.emnlp-industry.114.pdf" rel="noopener noreferrer"&gt;Intent Detection in the Age of LLMs&lt;/a&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Few-shot:&lt;/strong&gt; TabLLM vence com 8 exemplos ou menos, mas com ajuste de split o LightGBM melhora 290% e a vantagem cai 84.5%. A partir de 16 a 64 exemplos, GBDT empata por fração do tempo (&lt;a href="https://arxiv.org/pdf/2411.04324" rel="noopener noreferrer"&gt;GBDT and LLMs for few-shot&lt;/a&gt;). Fusão LLM mais GBDT vence no meio do caminho (&lt;a href="https://arxiv.org/html/2502.02672" rel="noopener noreferrer"&gt;LLM-Boost&lt;/a&gt;).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Roteamento:&lt;/strong&gt; &lt;a href="https://arxiv.org/abs/2406.18665v2" rel="noopener noreferrer"&gt;RouteLLM&lt;/a&gt; com 3.66x no MT-Bench, 1.41x no MMLU e 1.49x no GSM8K, ver também &lt;a href="https://www.lmsys.org/blog/2024-07-01-routellm/" rel="noopener noreferrer"&gt;blog LMSYS&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Jev real:&lt;/strong&gt; &lt;a href="https://openrouter.ai/docs/guides/community/jev" rel="noopener noreferrer"&gt;documentação no OpenRouter&lt;/a&gt;, &lt;a href="https://openrouter.ai/docs/guides/community/jev-tutorial" rel="noopener noreferrer"&gt;tutorial de primeira chamada&lt;/a&gt; e &lt;a href="https://openrouter.ai/typesafe/jev-1.13" rel="noopener noreferrer"&gt;preço e providers do Jev 1.13&lt;/a&gt; ($0.042/M tokens de entrada, saída grátis). Cases públicos na seção 2b.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Laya real:&lt;/strong&gt; &lt;a href="https://laya.studio/compare/laya-vs-jev" rel="noopener noreferrer"&gt;comparativo Laya vs Jev&lt;/a&gt; (mesmo protocolo, confiança com cálculo próprio, re-tunar thresholds) e &lt;a href="https://spring-ai-community.github.io/spring-ai-typesafe/latest/client/Laya/" rel="noopener noreferrer"&gt;guia de uso no Spring AI&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Cascata:&lt;/strong&gt; &lt;a href="https://ar5iv.labs.arxiv.org/html/2305.05176" rel="noopener noreferrer"&gt;FrugalGPT&lt;/a&gt; com 50% a 98% de economia, paper final em &lt;a href="https://lingjiaochen.com/papers/2024_FrugalGPT_TMLR.pdf" rel="noopener noreferrer"&gt;TMLR&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Onde tenho segurança para recomendar Jev: saída em enum, alto volume, precisa de auditoria e latência baixa. Onde não prometo número: economia exata no seu fluxo. Meça acerto, confiança e custo por rota por um mês antes de cravar.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Jev e Laya no seu harness pessoal
&lt;/h2&gt;

&lt;p&gt;Jev e Laya ensinaram o classificador. Eu adotei um no &lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;Downshift&lt;/a&gt;, projeto open-source meu. Eles foram POC. No Cursor, quem decide o spawn é o &lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;Downshift&lt;/a&gt;: typo no barato, gate de PRD no frontier. É o mesmo &lt;a href="https://dev.to/tiagovilasboas/model-routing-para-software-engineers-como-escolher-o-llm-certo-dentro-de-cada-harness-o5g"&gt;model routing&lt;/a&gt;, sem segundo LLM-judge e sem contexto gordo antes da skill.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;$ downshift try "fix a typo in the README"
→ TRIVIAL → claude-haiku-4-5

$ downshift try "rearchitect the payment flow across services"
→ COMPLEX → claude-opus-4-8
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Nenhum LLM na classificação. Default do binário: &lt;code&gt;hash-embed-v1&lt;/code&gt;. O MiniLM local é a adoção do classificador, só entra com &lt;code&gt;DOWNSHIFT_MINILM_EMBED&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Holdout &lt;code&gt;all-MiniLM-L6-v2&lt;/code&gt;, 300 prompts em inglês: 287 certos (95,7%). Com margem 0,02, 97,9%. P50 1,87 ms. Erra no MEDIUM (85,3%). Esse número é do MiniLM, não do hash. Português pede modelo multilingual. E MEDIUM é justamente a faixa onde a rota errada custa mais: mandar pro barato gera retry; mandar pro frontier, fatura.&lt;/p&gt;

&lt;p&gt;Decisor decide, gerador escreve, humano veta.&lt;/p&gt;




&lt;p&gt;&lt;strong&gt;Para debater:&lt;/strong&gt; na sua próxima tarefa de agente, o que você prefere?&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A)&lt;/strong&gt; Decisor determinístico (Jev/Laya/regra) escolhe a rota; o LLM só redige quando precisa.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;B)&lt;/strong&gt; LLM classifica e roteia tudo (mais simples de montar, mais caro e menos auditável).&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;C)&lt;/strong&gt; Ainda não separou as duas camadas.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Conta qual letra e o primeiro passo que você faria na segunda-feira.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>llm</category>
      <category>braziliandevs</category>
    </item>
    <item>
      <title>Claude Code, Copilot e Cursor na empresa: um padrão por fluxo</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Tue, 29 Sep 2026 15:33:19 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/claude-code-copilot-e-cursor-na-empresa-um-padrao-por-fluxo-571i</link>
      <guid>https://dev.to/tiagovilasboas/claude-code-copilot-e-cursor-na-empresa-um-padrao-por-fluxo-571i</guid>
      <description>&lt;p&gt;Em uma oficina mecânica profissional, existem diferentes ferramentas especializadas: o elevador hidráulico para suspensão, a chave de torque calibrada para o motor e o scanner eletrônico para a injeção. Ninguém tenta usar a chave de torque para levantar o carro inteiro, e ninguém tenta usar o elevador para apertar uma vela de ignição.&lt;/p&gt;

&lt;p&gt;Nas empresas de tecnologia, o debate sobre IA corporativa muitas vezes cai em uma armadilha ingênua:&lt;br&gt;&lt;br&gt;
&lt;em&gt;"Qual é o melhor agente? Cursor, Claude Code ou GitHub Copilot?"&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;A resposta de engenharia é simples: &lt;strong&gt;nenhuma ferramenta vence em todos os cenários.&lt;/strong&gt; &lt;/p&gt;

&lt;p&gt;A verdadeira maturidade corporativa não está em tentar escolher um único fornecedor exclusivo (criando vendor lock-in perigoso), nem em liberar o cartão de crédito para cada desenvolvedor assinar uma ferramenta diferente sem controle de segurança.&lt;/p&gt;

&lt;p&gt;Neste artigo, vamos analisar a estratégia recomendada para times maduros: &lt;strong&gt;um agente padrão por fluxo de trabalho, uma alternativa homologada e políticas e evals centralizados&lt;/strong&gt;.&lt;/p&gt;


&lt;h2&gt;
  
  
  1. Adoção Declarada Não é Sinônimo de Produtividade
&lt;/h2&gt;

&lt;p&gt;Pesquisas recentes de ecossistema indicam que mais de 85% dos desenvolvedores usam assistentes de IA com frequência. No entanto, relatórios de engenharia mostram que &lt;strong&gt;os gastos corporativos com tokens e licenças cresceram até dez vezes&lt;/strong&gt;, enquanto muitos times enfrentam um aumento silencioso de dívida técnica e retrabalho em Pull Requests.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[ A Ilusão da "IA Para Tudo" ]

Comprar 500 licenças sem governança
                 │
                 ▼
"O código foi gerado 40% mais rápido!"
                 │
                 ▼
Mas o Pull Request quebra contratos, não tem testes
e gasta 3 dias em revisões exaustivas...
                 │
                 ▼
Resultado: MAIS ATRITO E MAIOR DÍVIDA TÉCNICA!
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Como aponta o relatório anual da &lt;strong&gt;DORA (DevOps Research and Assessment)&lt;/strong&gt;, a IA atua como um poderoso amplificador do sistema existente:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Se a sua empresa tem boa arquitetura, testes automatizados e regras claras, a IA multiplica a velocidade de entrega;&lt;/li&gt;
&lt;li&gt;Se a sua empresa tem processos manuais e código frágil, a IA apenas acelera a velocidade com que bugs chegam a produção.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  2. A Estrutura Recomendada: Um Padrão por Fluxo de Trabalho
&lt;/h2&gt;

&lt;p&gt;Em vez de forçar uma ferramenta única em todos os computadores, desenhe a esteira separando o uso por contexto de execução:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;               ┌──────────────────────────────────────────────┐
               │         Política Central de Governança       │
               │        (Allowlist de MCPs e Regras Git)      │
               └──────────────────────┬───────────────────────┘
                                      │
         ┌────────────────────────────┼────────────────────────────┐
         ▼                            ▼                            ▼
  [ Fluxo 1: IDE / Edição ]    [ Fluxo 2: Terminal / Batch] [ Fluxo 3: Backoffice ]
  Cursor / Copilot             Claude Code / Codex CLI      Antigravity / Automação
  - Autocomplete interativo    - Tarefas multi-arquivo      - Triagem de bugs N3
  - Refatorações locais        - Worktrees em paralelo      - Validação de logs
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  A Matriz de Decisão:
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Fluxo de Trabalho&lt;/th&gt;
&lt;th&gt;Padrão Recomendado&lt;/th&gt;
&lt;th&gt;Alternativa Homologada&lt;/th&gt;
&lt;th&gt;Por que essa divisão?&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Edição e Pair Programming no Editor&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Cursor&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;GitHub Copilot&lt;/td&gt;
&lt;td&gt;Feedback instantâneo, inline diffs e controle de contexto local&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Tarefas Complexas no Terminal / CLI&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Claude Code&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Codex / Aider&lt;/td&gt;
&lt;td&gt;Isolamento físico via Git Worktrees e execução de suites de testes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Automação de Sustentação e CI/CD&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;Antigravity Operator&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Scripts Internos via MCP&lt;/td&gt;
&lt;td&gt;Leitura cirúrgica de logs no Sentry/Grafana e checagem de regras&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;




&lt;h2&gt;
  
  
  3. O Que Grandes Empresas Brasileiras Já Estão Fazendo
&lt;/h2&gt;

&lt;p&gt;Casos reais do mercado brasileiro comprovam que o segredo não é a ferramenta da moda, mas os &lt;strong&gt;sensores de engenharia&lt;/strong&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No iFood:&lt;/strong&gt; O time de Developer Experience implementou o &lt;strong&gt;Auto Approval&lt;/strong&gt; em Pull Requests. Mudanças pequenas e bem delimitadas passam por avaliação automatizada de risco, reduzindo em até 58% o tempo de espera em PRs enxutos. Além disso, criaram a &lt;strong&gt;GenPlat&lt;/strong&gt;, uma plataforma interna que gerencia mais de 150 modelos com fallback, mascaramento de PII e limites de gasto.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Na Tecban:&lt;/strong&gt; A adoção do Copilot veio amarrada a matrizes formais de risco, aprovação e validação técnica antes de qualquer código tocar ambientes de homologação.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Ambos os casos mostram que a IA só gera valor escalável quando está cercada de &lt;strong&gt;guard-rails computacionais&lt;/strong&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  4. Roteamento Inteligente de Modelos (Model Routing)
&lt;/h2&gt;

&lt;p&gt;Roteamento corporativo não significa mandar tudo para o modelo mais barato. Significa alocar a capacidade cognitiva proporcional ao risco da tarefa:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[ Pedido do Desenvolvedor ]
             │
             ▼
    [ Classificador Local ]  &amp;lt;-- Downshift em Go (Rápido, local e sem custo)
             │
             ├──&amp;gt; Tarefa Leve (Docs, Teste Unitário Simples, Tipagem)
             │    Rota: Modelos Rápidos (Gemini 3.8 Flash / Claude Haiku)
             │
             ├──&amp;gt; Tarefa Média (CRUD, Refactor de Módulo, Feature Delimitada)
             │    Rota: Modelos Frontier (Claude Sonnet 5.5 / Grok 4.6)
             │
             └──&amp;gt; Tarefa Crítica (Arquitetura, Fluxo Financeiro, Auth)
                  Rota: Raciocínio Profundo via OpenRouter + Revisão Humana Obrigatória!
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Utilizar ferramentas locais como o &lt;strong&gt;Downshift&lt;/strong&gt; (&lt;code&gt;harness-downshift&lt;/code&gt;) para analisar a árvore de arquivos e classificar o prompt antes de disparar requisições garante economia drástica de faturamento sem sacrificar a precisão da engenharia.&lt;/p&gt;




&lt;h2&gt;
  
  
  5. Os Três Sensores que Nenhuma Empresa Pode Dispensar
&lt;/h2&gt;

&lt;p&gt;Para manter a governança verificável em múltiplos agentes:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Permissões Granulares em MCPs:&lt;/strong&gt; Conectores de banco de dados devem operar em modo Read-Only por padrão; mutations em produção exigem token temporário e confirmação explícita.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mascaramento Automático de Dados (DLP / PII):&lt;/strong&gt; CPFs, chaves de API e tokens nunca devem trafegar para a nuvem em texto aberto.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sensores de CI Inegociáveis:&lt;/strong&gt; Linters, verificações de tipagem estrita e testes de integração rodam no pipeline remoto, e nenhum agente tem permissão de dar bypass nessas travas.&lt;/li&gt;
&lt;/ol&gt;




&lt;h2&gt;
  
  
  Referências Didáticas e Vídeos Recomendados
&lt;/h2&gt;

&lt;p&gt;Para aprofundar na governança e arquitetura corporativa com agentes de IA:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;📺 &lt;strong&gt;Vídeo (YouTube em Português):&lt;/strong&gt; &lt;a href="https://www.youtube.com/results?search_query=cursor+vs+copilot+vs+claude+code+portugues" rel="noopener noreferrer"&gt;Cursor vs Copilot vs Claude Code: Qual Escolher na Sua Empresa?&lt;/a&gt; - Comparativo técnico sobre forças e limitações de cada interface.&lt;/li&gt;
&lt;li&gt;📺 &lt;strong&gt;Vídeo (YouTube em Português):&lt;/strong&gt; &lt;a href="https://www.youtube.com/results?search_query=governanca+ia+empresas+seguranca+portugues" rel="noopener noreferrer"&gt;Como Empresas Usam IA com Segurança e Governança&lt;/a&gt; - Discussão sobre privacidade, FinOps e mitigação de riscos regulatórios.&lt;/li&gt;
&lt;li&gt;📖 &lt;strong&gt;Artigo de Referência:&lt;/strong&gt; &lt;a href="https://martinfowler.com/articles/harness-engineering.html" rel="noopener noreferrer"&gt;Harness Engineering for Coding Agent Users (Martin Fowler)&lt;/a&gt; - Como estabelecer contratos comuns de contexto entre múltiplos editores.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  O Resumo para Líderes Técnicos e Staff Engineers
&lt;/h2&gt;

&lt;p&gt;Se você lidera engenharia na sua empresa:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Não procure o "agente perfeito":&lt;/strong&gt; Homologue uma ferramenta padrão para o editor e outra para o terminal;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Centralize as regras no Git:&lt;/strong&gt; Use arquivos &lt;code&gt;SKILL.md&lt;/code&gt; e &lt;code&gt;AGENTS.md&lt;/code&gt; para que qualquer ferramenta consulte a mesma fonte de verdade;&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Monitore o custo por tarefa entregue:&lt;/strong&gt; Tokens gastos só fazem sentido se o tempo de entrega e a qualidade do software melhorarem comprovadamente em produção.&lt;/li&gt;
&lt;/ol&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>productivity</category>
      <category>braziliandevs</category>
    </item>
    <item>
      <title>Antigravity Operator: Helping AI Coding Agents Stay on Track</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Tue, 29 Sep 2026 08:19:14 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/antigravity-operator-helping-ai-coding-agents-stay-on-track-216n</link>
      <guid>https://dev.to/tiagovilasboas/antigravity-operator-helping-ai-coding-agents-stay-on-track-216n</guid>
      <description>&lt;p&gt;Two days ago, I started using Google Antigravity through Google's AI Pro student offer. As a cybersecurity student, I wanted to use an agent to organize my classes the way I already did with other harnesses.&lt;/p&gt;

&lt;p&gt;I quickly missed a reliable way to carry work from one session to the next: the goal, the decisions, and what was still unfinished.&lt;/p&gt;

&lt;p&gt;It felt like returning to a workbench with no notebook. Before I could continue, I had to reconstruct where I had left off. That frustration became &lt;strong&gt;&lt;a href="https://github.com/tiagovilasboas/antigravity-operator" rel="noopener noreferrer"&gt;Antigravity Operator (agyo)&lt;/a&gt;&lt;/strong&gt;, my first open-source project.&lt;/p&gt;

&lt;h2&gt;
  
  
  A session needs a notebook the agent can use
&lt;/h2&gt;

&lt;p&gt;A coding agent is the model plus the vendor's harness - its tools and orchestration - and the user harness around the repository. I wanted a small, inspectable place for the part of that setup I control: project context and session state.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;agyo init&lt;/strong&gt; creates Markdown files in the project:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;.agents/session/
├── state.md       # goal and current status
├── decisions.md   # decisions and trade-offs
└── todo.md        # active and pending tasks
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The agent can keep those files current. &lt;strong&gt;agyo session status&lt;/strong&gt; summarizes fields and checkboxes it recognizes; it cannot judge whether the recorded decisions are correct or complete. Markdown is easy to inspect and version, but it is still a record that needs human and agent discipline.&lt;/p&gt;

&lt;h2&gt;
  
  
  From session notes to a local dashboard
&lt;/h2&gt;

&lt;p&gt;The project has grown beyond session scaffolding. &lt;strong&gt;agyo session watch&lt;/strong&gt; follows the local Antigravity transcript and summarizes recent activity. With &lt;strong&gt;--tree&lt;/strong&gt;, it displays subagent launches and inter-agent messages that appear in that transcript. It observes those events; it does not orchestrate the agents.&lt;/p&gt;

&lt;p&gt;The visual piece is &lt;strong&gt;agyo dashboard&lt;/strong&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;agyo session watch &lt;span class="nt"&gt;--tree&lt;/span&gt;
agyo session &lt;span class="nb"&gt;export&lt;/span&gt; &lt;span class="nt"&gt;--format&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;html &lt;span class="nt"&gt;--out&lt;/span&gt;&lt;span class="o"&gt;=&lt;/span&gt;session-report.html
agyo dashboard
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The local dashboard refreshes every two seconds with session progress, host checks, tabs in the dedicated Chrome profile, and recent activity. The export command produces a Markdown or standalone HTML report. For direct browser operations, &lt;strong&gt;agyo browser&lt;/strong&gt; can list tabs, open or close one, evaluate JavaScript, and capture a screenshot through Chrome DevTools Protocol.&lt;/p&gt;

&lt;p&gt;That combination changed how I think about the tool. The session files preserve a working record; the watcher and dashboard make activity easier to see; the export gives the session a portable summary. My favorite addition is the dashboard because it makes the agent's work legible without asking the model to narrate every step.&lt;/p&gt;

&lt;h2&gt;
  
  
  Guides and sensors - and the limits of each
&lt;/h2&gt;

&lt;p&gt;I use the guide-and-sensor vocabulary from &lt;a href="https://martinfowler.com/articles/harness-engineering.html" rel="noopener noreferrer"&gt;Harness engineering for coding agent users&lt;/a&gt; (Birgitta Böckeler, published on martinfowler.com): a guide shapes work before it happens; a sensor checks what happened afterward.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Concern&lt;/th&gt;
&lt;th&gt;Guide (inferential)&lt;/th&gt;
&lt;th&gt;Sensor (computational)&lt;/th&gt;
&lt;th&gt;Axis and limit&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Session continuity&lt;/td&gt;
&lt;td&gt;Templates and Antigravity rules&lt;/td&gt;
&lt;td&gt;session status checks expected fields and tasks&lt;/td&gt;
&lt;td&gt;Behaviour; it cannot judge whether the state is meaningful&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Host readiness&lt;/td&gt;
&lt;td&gt;Repository setup instructions&lt;/td&gt;
&lt;td&gt;agyo doctor checks Git, Chrome, DevTools, and other prerequisites&lt;/td&gt;
&lt;td&gt;Maintainability; a passing check does not prove an agent workflow&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Browser isolation&lt;/td&gt;
&lt;td&gt;Rule to use the dedicated profile&lt;/td&gt;
&lt;td&gt;browser status checks the process and DevTools endpoint&lt;/td&gt;
&lt;td&gt;Behaviour; DevTools remains a privileged interface&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Changes to agyo&lt;/td&gt;
&lt;td&gt;AGENTS.md and contribution guidance&lt;/td&gt;
&lt;td&gt;CI is configured for go vet, race-enabled tests, builds, and cross-compilation&lt;/td&gt;
&lt;td&gt;Maintainability and architecture fitness; it checks agyo, not model behavior&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;There is also a Git pre-commit hook, but its current implementation prints the session status and exits successfully. Treat it as a reminder, not a blocking quality gate. A configured check is not automatically an enforcing sensor. These sensors run locally or in CI; the project does not claim continuous production monitoring.&lt;/p&gt;

&lt;h2&gt;
  
  
  A separate Chrome profile is not a sandbox
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;agyo browser start&lt;/strong&gt; launches Chrome with its own user-data directory and a local debugging port. That helps keep agent browsing separate from my personal Chrome profile. The DevTools endpoint is still privileged: a process that can reach it may control that browser session.&lt;/p&gt;

&lt;p&gt;The dashboard binds to &lt;strong&gt;127.0.0.1&lt;/strong&gt; and displays session details, browser tabs, and activity. I keep it local and avoid putting secrets or personal data in session files. On headless Linux, the operator may use Chrome's &lt;strong&gt;--no-sandbox&lt;/strong&gt; flag; that disables a browser protection and should be treated as an explicit environment trade-off. None of these features creates a complete sandbox for agent commands or web content.&lt;/p&gt;

&lt;p&gt;The CLI is written in Go and embeds its templates, so running it does not require a separate Python or Node runtime. Browser automation still requires Chrome or Chromium, and some MCP setups may require &lt;strong&gt;npx&lt;/strong&gt;. The repository is now at &lt;strong&gt;v0.4.1&lt;/strong&gt;, with CI configured for Ubuntu and macOS and a release workflow for five OS/architecture targets.&lt;/p&gt;

&lt;h2&gt;
  
  
  What I learned by building it
&lt;/h2&gt;

&lt;p&gt;I began with a personal study problem, not a plan to build a platform. The first useful step was making session state visible and easy to resume. From there, I added tools around the same workflow: inspect activity, see the isolated browser, and export a report.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;agyo&lt;/strong&gt; is a community project, not an official Google product. The student offer gave me a reason to try Antigravity; the missing session workflow gave me a reason to build. The README still talks bigger than the CLI: the useful product is the session notebook and the local dashboard. Phrases like autonomous OS or safe sandbox go past what the sensors actually enforce. I also shared the project in the &lt;a href="https://discuss.ai.google.dev/t/showcase-antigravity-operator-agyo-the-open-source-session-harness-in-go-built-100-inside-antigravity/185915" rel="noopener noreferrer"&gt;Google AI Developers Forum&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;If you use coding agents locally, what would help you most: persistent session state, a live activity view, visibility into subagents, or a separate browser profile?&lt;/p&gt;

</description>
      <category>ai</category>
      <category>go</category>
      <category>antigravity</category>
      <category>braziliandevs</category>
    </item>
    <item>
      <title>Claude Code: organize agentes em paralelo com Git Worktrees</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Mon, 28 Sep 2026 19:39:06 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/claude-code-organize-agentes-em-paralelo-com-git-worktrees-4738</link>
      <guid>https://dev.to/tiagovilasboas/claude-code-organize-agentes-em-paralelo-com-git-worktrees-4738</guid>
      <description>&lt;p&gt;Quando começamos a usar assistentes e agentes autônomos de código no dia a dia, um padrão comum acontece: você pede para o agente implementar uma feature complexa e, enquanto ele roda e testa os arquivos, surge um bug urgente em produção para você corrigir.&lt;/p&gt;

&lt;p&gt;Se você estiver em um fluxo tradicional com um único terminal e uma única pasta de projeto, você entra em um beco sem saída:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Ou você faz &lt;code&gt;git stash&lt;/code&gt; ou &lt;code&gt;git commit -m "wip"&lt;/code&gt; correndo o risco de quebrar o raciocínio do agente;&lt;/li&gt;
&lt;li&gt;Ou você espera o agente terminar para só depois abrir a branch de hotfix.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Pior ainda: se você rodar duas instâncias de agentes simultâneos na mesma pasta, um vai sobrescrever os arquivos e as variáveis que o outro acabou de salvar. É o caos da colisão de arquivos.&lt;/p&gt;

&lt;p&gt;Neste artigo, vamos entender como resolver esse problema de raiz usando uma ferramenta nativa do próprio Git que existe há anos, mas que virou o maior superpoder da engenharia moderna com agentes: o &lt;strong&gt;Git Worktrees&lt;/strong&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  A Analogia da Oficina Mecânica
&lt;/h2&gt;

&lt;p&gt;Pense no seu repositório como uma grande oficina mecânica:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[ Abordagem Tradicional: Apenas 1 Vaga ]
                      ┌──────────────────────┐
                      │    Única Vaga (Box)  │
                      │  (Mesma Pasta Local) │
                      └──────────┬───────────┘
                                 │
                 ┌───────────────┴───────────────┐
                 │                               │
                 ▼                               ▼
       [ Agente 1: Feature ]           [ Dev: Hotfix Urgente ]
       (Montando motor novo)           (Tentando trocar pneu)
                 │                               │
                 └───────────────┬───────────────┘
                                 ▼
                     CONFLITO / DESMANCHE TOTAL!
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Com o &lt;strong&gt;Git Worktree&lt;/strong&gt;, você não divide a mesma vaga. Você abre baias de trabalho totalmente independentes na mesma oficina, todas compartilhando o mesmo estoque de peças (o histórico do &lt;code&gt;.git&lt;/code&gt;), mas com carros separados:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[ Abordagem com Git Worktree: Múltiplas Vagas Independentes ]

                       ┌────────────────────────┐
                       │   Histórico Git Local  │
                       │   (.git compartilhado) │
                       └───────────┬────────────┘
                                   │
         ┌─────────────────────────┼─────────────────────────┐
         ▼                         ▼                         ▼
   [ Vaga 1: Main ]        [ Vaga 2: Feature ]       [ Vaga 3: Hotfix ]
   pasta: repo-main/       pasta: repo-feat/         pasta: repo-hotfix/
   branch: main            branch: feature/api       branch: bugfix/auth
         │                         │                         │
   (Código estável)       (Agente rodando testes)   (Dev alterando código)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Nenhum arquivo colide, nenhuma dependência é sobrescrita e nenhuma sessão precisa esperar a outra terminar.&lt;/p&gt;




&lt;h2&gt;
  
  
  O Que é Git Worktree na Prática?
&lt;/h2&gt;

&lt;p&gt;Em um fluxo Git comum, você clona um repositório e tem exatamente uma pasta de trabalho vinculada a uma branch ativa por vez.&lt;/p&gt;

&lt;p&gt;Com &lt;code&gt;git worktree&lt;/code&gt;, você pode fazer o checkout de múltiplas branches ao mesmo tempo em pastas físicas diferentes no seu disco rígido, sem precisar clonar o repositório inteiro novamente:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# Dentro do seu repositório principal&lt;/span&gt;
git worktree add ../projeto-feature-export feature/exportacao
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Esse comando cria uma pasta novinha em folha (&lt;code&gt;../projeto-feature-export&lt;/code&gt;), configurada na branch &lt;code&gt;feature/exportacao&lt;/code&gt;, pronta para receber uma sessão dedicada do seu agente de IA.&lt;/p&gt;

&lt;p&gt;Quando a tarefa termina e o Pull Request é aberto, você descarta a vaga com um único comando:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;git worktree remove ../projeto-feature-export
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h2&gt;
  
  
  A Integração com o Claude Code
&lt;/h2&gt;

&lt;p&gt;O mérito do &lt;a href="https://code.claude.com/docs/en/desktop" rel="noopener noreferrer"&gt;Claude Code Desktop&lt;/a&gt; e do CLI não foi inventar o Git Worktree, mas sim &lt;strong&gt;integrá-lo como recurso nativo de primeira classe&lt;/strong&gt; na experiência de desenvolvimento.&lt;/p&gt;

&lt;h3&gt;
  
  
  1. No CLI (Terminal)
&lt;/h3&gt;

&lt;p&gt;Você pode abrir uma sessão totalmente isolada em um worktree temporário diretamente da linha de comando:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;claude &lt;span class="nt"&gt;--worktree&lt;/span&gt; feature-checkout-auth
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O Claude Code cria a branch, monta o worktree isolado e garante que nenhuma alteração interfira no seu terminal principal.&lt;/p&gt;

&lt;h3&gt;
  
  
  2. No Claude Code Desktop
&lt;/h3&gt;

&lt;p&gt;Na interface gráfica, cada nova sessão na barra lateral pode ser associada a um worktree automático. Isso transforma a ferramenta em um verdadeiro painel de controle operacional:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Projeto: Voomp Core
├── Sessão 1: Refatoração de Checkout (Em andamento - Worktree isolado)
├── Sessão 2: Correção de Webhook Pagarme (Testes passando - PR aberto)
└── Sessão 3: Atualização de Dependências (Aguardando revisão humana)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Você visualiza o diff em tempo real, os testes locais rodando e a barra de CI sem que uma tarefa contamine o ambiente da outra.&lt;/p&gt;




&lt;h2&gt;
  
  
  O Ciclo Completo: Da Tarefa ao Pull Request
&lt;/h2&gt;

&lt;p&gt;Para que o trabalho paralelo funcione sem gerar dívida técnica, a unidade de trabalho precisa seguir um fluxo disciplinado:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Definição da Tarefa + Critérios de Aceite
                 │
                 ▼
Criação do Worktree Isolado (`git worktree add`)
                 │
                 ▼
Execução do Agente (Implementação + Testes Locais)
                 │
                 ▼
Verificação Automatizada (Linters, Testes Unitários)
                 │
                 ▼
Abertura do Pull Request (CI + Revisão Humana)
                 │
                 ▼
Merge e Limpeza do Worktree (`git worktree remove`)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  O Contrato da Tarefa
&lt;/h3&gt;

&lt;p&gt;Antes de deixar o agente alterar código no worktree, passe instruções claras de limites de escrita para evitar que ele altere arquivos fora do escopo:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;tarefa&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Adicionar exportação de relatórios em CSV&lt;/span&gt;
&lt;span class="na"&gt;pasta_permitida&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;src/reports/**&lt;/span&gt;
&lt;span class="na"&gt;nao_alterar&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;src/auth/**, database/migrations/**&lt;/span&gt;
&lt;span class="na"&gt;criterios_aceite&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;Preservar os filtros de data existentes&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s"&gt;Garantir cobertura de testes unitários para valores nulos&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;






&lt;h2&gt;
  
  
  Matriz de Decisão: Onde Worktrees Ajudam e Onde Não Resolvem
&lt;/h2&gt;

&lt;p&gt;Nem todo problema de engenharia se resolve isolando pastas. É fundamental saber a fronteira da técnica:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Cenário&lt;/th&gt;
&lt;th&gt;Worktrees Resolvem?&lt;/th&gt;
&lt;th&gt;Explicação Prática&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Dois agentes mexendo no mesmo repo ao mesmo tempo&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Sim&lt;/td&gt;
&lt;td&gt;Cada agente opera em sua pasta física isolada sem colisão de escrita&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Pausar feature para resolver bug urgente&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Sim&lt;/td&gt;
&lt;td&gt;Você abre o hotfix em outro worktree sem precisar fazer stash da feature&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Conflitos de merge em migrations de banco&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Não&lt;/td&gt;
&lt;td&gt;Se duas tarefas alteram a mesma tabela, o conflito vai acontecer no merge remoto&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Disputa por portas locais (ex: porta 3000)&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Atenção&lt;/td&gt;
&lt;td&gt;Ambos os worktrees vão tentar subir o servidor na mesma porta; configure portas dinâmicas&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Consumo excessivo de memória RAM&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Atenção&lt;/td&gt;
&lt;td&gt;Cada worktree com &lt;code&gt;node_modules&lt;/code&gt; ou compilações simultâneas consome memória da máquina&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Para acompanhar o uso de modelos e reduzir a saída de comandos durante o trabalho com agentes, você pode conhecer o &lt;a href="https://github.com/tiagovilasboas/downshift" rel="noopener noreferrer"&gt;Downshift que desenvolvo&lt;/a&gt;. Ele compacta saídas compatíveis e aplica a escolha de modelo do orquestrador dentro da política configurada. Os recursos e o comportamento observado variam conforme o ambiente; confira a documentação e as limitações antes de usar.&lt;/p&gt;




&lt;h2&gt;
  
  
  Referências Didáticas e Vídeos Recomendados
&lt;/h2&gt;

&lt;p&gt;Para quem quer dominar Git Worktrees e fluxos modernos com IA:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;📺 &lt;strong&gt;Vídeo (YouTube em Português):&lt;/strong&gt; &lt;a href="https://www.youtube.com/results?search_query=git+worktree+explicado+portugues" rel="noopener noreferrer"&gt;Git Worktree Explicado em 5 Minutos: Nunca Mais Use Git Stash&lt;/a&gt; - Demonstração visual de como criar e gerenciar worktrees no terminal.&lt;/li&gt;
&lt;li&gt;📺 &lt;strong&gt;Vídeo (YouTube em Português):&lt;/strong&gt; &lt;a href="https://www.youtube.com/results?search_query=claude+code+tutorial+portugues" rel="noopener noreferrer"&gt;Claude Code na Prática: Primeiros Passos e Dicas de Produtividade&lt;/a&gt; - Tour completo pelos recursos de terminal e orquestração do Claude Code.&lt;/li&gt;
&lt;li&gt;📖 &lt;strong&gt;Documentação Oficial:&lt;/strong&gt; &lt;a href="https://code.claude.com/docs/en/common-workflows#run-parallel-sessions-with-git-worktrees" rel="noopener noreferrer"&gt;Claude Code Documentation - Parallel Workflows&lt;/a&gt; - Guia passo a passo da Anthropic sobre isolamento de sessões com worktrees.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  Passo a Passo para Testar Hoje Mesmo
&lt;/h2&gt;

&lt;p&gt;Você não precisa esperar uma migração de ferramentas para começar. Teste agora com 3 comandos simples no seu terminal:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="c"&gt;# 1. Crie uma nova vaga de trabalho para uma branch de teste&lt;/span&gt;
git worktree add ../teste-paralelo &lt;span class="nt"&gt;-b&lt;/span&gt; minha-branch-teste

&lt;span class="c"&gt;# 2. Acesse a pasta isolada&lt;/span&gt;
&lt;span class="nb"&gt;cd&lt;/span&gt; ../teste-paralelo

&lt;span class="c"&gt;# 3. Abra o seu editor ou agente nesta pasta e trabalhe livremente!&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Quando terminar, volte para a pasta principal e desmonte a vaga:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight shell"&gt;&lt;code&gt;&lt;span class="nb"&gt;cd&lt;/span&gt; ../meu-projeto-original
git worktree remove ../teste-paralelo
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O isolamento com Git Worktrees transforma o paralelismo de agentes de um pesadelo de arquivos corrompidos em uma esteira de engenharia fluida, previsível e profissional.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>git</category>
      <category>productivity</category>
      <category>braziliandevs</category>
    </item>
    <item>
      <title>O effort da tarefa: quando pensar demais vira stage 3 na fatura do agente</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Sun, 27 Sep 2026 20:53:15 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/o-effort-da-tarefa-quando-pensar-demais-vira-stage-3-na-fatura-do-agente-1h3d</link>
      <guid>https://dev.to/tiagovilasboas/o-effort-da-tarefa-quando-pensar-demais-vira-stage-3-na-fatura-do-agente-1h3d</guid>
      <description>&lt;p&gt;Quando eu era mais novo, pedi ao mecânico para colocar minha &lt;strong&gt;Harley-Davidson Heritage 2010&lt;/strong&gt;, &lt;strong&gt;1600 cc&lt;/strong&gt;, em &lt;strong&gt;stage 3&lt;/strong&gt;: motor, módulo (ECM) e várias outras mudanças. Não era vitrine. Era potência de verdade.&lt;/p&gt;

&lt;p&gt;Na prática, o consumo caiu de &lt;strong&gt;23 km por litro&lt;/strong&gt; para &lt;strong&gt;12 km por litro&lt;/strong&gt;. Eu não precisava daquela potência o tempo todo: não rodava tanto e não corria com a moto.&lt;/p&gt;

&lt;p&gt;Mesmo assim, você paga o consumo de stage 3 &lt;strong&gt;em todo quilômetro&lt;/strong&gt;, mesmo quando o rolê não pede aquela força. No agente de código, &lt;strong&gt;stage 3&lt;/strong&gt; é reasoning effort no máximo em &lt;strong&gt;todo&lt;/strong&gt; spawn: capacidade de sobra na fatura, mesmo quando a tarefa só precisa chegar na esquina.&lt;/p&gt;

&lt;p&gt;No agente, a mesma conta: deixar &lt;strong&gt;reasoning effort no máximo&lt;/strong&gt; em tarefa trivial (renomear variável, listar arquivos, formatar import) é pagar stage 3 em trajeto que não pede. O modelo aguenta. A fatura vem em &lt;strong&gt;cada&lt;/strong&gt; spawn.&lt;/p&gt;

&lt;p&gt;No &lt;a href="https://dev.to/tiagovilasboas/model-routing-para-software-engineers-como-escolher-o-llm-certo-dentro-de-cada-harness-o5g"&gt;texto de model routing&lt;/a&gt; eu falei de &lt;strong&gt;qual LLM&lt;/strong&gt; entra em cada tarefa: cheap, balanced, frontier, política antes do spawn. Falta o segundo knob: &lt;strong&gt;effort&lt;/strong&gt; (quanto raciocínio aquele modelo pode gastar &lt;strong&gt;nesta&lt;/strong&gt; execução). Routing sem effort é manter stage 3 ligado quando a tarefa só precisa chegar na esquina.&lt;/p&gt;

&lt;h2&gt;
  
  
  Neste artigo
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;Effort não é “modelo mais inteligente”&lt;/li&gt;
&lt;li&gt;O que eu chamo de effort na prática&lt;/li&gt;
&lt;li&gt;Modelos, effort e benchmarks públicos&lt;/li&gt;
&lt;li&gt;Dois eixos: tier e effort&lt;/li&gt;
&lt;li&gt;Como eu escolho effort por classe de tarefa&lt;/li&gt;
&lt;li&gt;Fan-out: effort multiplica como modelo&lt;/li&gt;
&lt;li&gt;Effort como política de Staff&lt;/li&gt;
&lt;li&gt;Onde isso encaixa no harness&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  1. Effort não é “modelo mais inteligente”
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Model routing&lt;/strong&gt; responde: &lt;em&gt;quem&lt;/em&gt; executa (haiku-class, sonnet-class, opus-class, ou o equivalente no seu catálogo).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Effort&lt;/strong&gt; responde: &lt;em&gt;com quanta profundidade de raciocínio&lt;/em&gt; essa instância pode trabalhar &lt;strong&gt;agora&lt;/strong&gt;, dentro do modelo que você já escolheu.&lt;/p&gt;

&lt;p&gt;São decisões ortogonais. Você pode estar no tier certo e ainda pagar demais porque o harness deixou &lt;strong&gt;reasoning effort&lt;/strong&gt; alto para um prompt mecânico. Ou estar no tier barato com effort alto e queimar tempo em “pensar” onde grep e teste bastavam.&lt;/p&gt;

&lt;p&gt;A pergunta útil, depois do routing:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Para &lt;strong&gt;esta&lt;/strong&gt; tarefa, qual é o &lt;strong&gt;menor effort&lt;/strong&gt; que ainda entrega segurança e qualidade suficientes?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Espelha a pergunta do routing (“modelo mais barato que aguenta”), só que no eixo do &lt;strong&gt;orçamento de pensamento&lt;/strong&gt;, não do &lt;strong&gt;catálogo de modelos&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. O que eu chamo de effort na prática
&lt;/h2&gt;

&lt;p&gt;Effort é o que o provedor ou o harness expõe como &lt;strong&gt;orçamento de raciocínio&lt;/strong&gt; na chamada: nomes variam (&lt;code&gt;reasoning_effort&lt;/code&gt;, modo “thinking”, variantes High/Medium no Cursor, etc.). O mecanismo muda; a decisão de engenharia é a mesma.&lt;/p&gt;

&lt;p&gt;Três sinais que eu uso para classificar a tarefa &lt;strong&gt;antes&lt;/strong&gt; de ligar o effort alto:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Sinal&lt;/th&gt;
&lt;th&gt;Effort tende a ser baixo&lt;/th&gt;
&lt;th&gt;Effort tende a subir&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Verificação&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;critério objetivo (teste, diff, linter)&lt;/td&gt;
&lt;td&gt;julgamento subjetivo ou poucos testes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Ambiguidade&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;prompt fechado (“renomeie X em Y”)&lt;/td&gt;
&lt;td&gt;várias hipóteses válidas&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Risco&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;falha barata de reverter&lt;/td&gt;
&lt;td&gt;auth, dinheiro, concorrência, migração&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Não é ciência exata. É &lt;strong&gt;política&lt;/strong&gt;: igual ao classifier do routing, conservative quando o risco manda.&lt;/p&gt;

&lt;p&gt;No &lt;strong&gt;harness-downshift&lt;/strong&gt;, a classificação de complexidade que já existe para tier (&lt;code&gt;TRIVIAL&lt;/code&gt;, &lt;code&gt;SIMPLE&lt;/code&gt;, &lt;code&gt;MEDIUM&lt;/code&gt;, &lt;code&gt;COMPLEX&lt;/code&gt;) é o mesmo tipo de leitura de prompt que eu uso para calibrar effort: mecânico versus desenho versus rearchitect. O README do projeto não promete oráculo; promete heurística auditável. Effort entra na mesma filosofia.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Modelos, effort e benchmarks públicos
&lt;/h2&gt;

&lt;p&gt;Eu uso benchmarks públicos para montar &lt;strong&gt;shortlist de modelo&lt;/strong&gt; (&lt;a href="https://www.swebench.com/" rel="noopener noreferrer"&gt;SWE-bench&lt;/a&gt;, &lt;a href="https://livebench.ai/" rel="noopener noreferrer"&gt;LiveBench&lt;/a&gt; com &lt;strong&gt;Agentic Coding&lt;/strong&gt; e &lt;strong&gt;cost per successful task&lt;/strong&gt;, &lt;a href="https://artificialanalysis.ai/" rel="noopener noreferrer"&gt;Artificial Analysis&lt;/a&gt;, &lt;a href="https://arena.ai/leaderboard/text/coding" rel="noopener noreferrer"&gt;LMArena Coding&lt;/a&gt; e &lt;a href="https://arena.ai/leaderboard" rel="noopener noreferrer"&gt;LMArena Agent&lt;/a&gt;). &lt;strong&gt;Nenhum deles&lt;/strong&gt;, na forma pública que eu consulto, publica coluna separada por &lt;code&gt;reasoning_effort&lt;/code&gt; ou thinking level. Eles comparam &lt;strong&gt;modelo (e muitas vezes harness)&lt;/strong&gt;; o segundo knob eu calibro pela &lt;strong&gt;documentação do provedor&lt;/strong&gt; e pela telemetria do spawn.&lt;/p&gt;

&lt;p&gt;A tabela abaixo resume &lt;strong&gt;onde o effort é real&lt;/strong&gt; nos modelos que já entram no meu routing, e o que a documentação oficial diz que &lt;strong&gt;tende&lt;/strong&gt; a subir quando você aumenta o effort. Não são notas de benchmark inventadas.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Modelo / família&lt;/th&gt;
&lt;th&gt;Onde o effort existe&lt;/th&gt;
&lt;th&gt;O que tende a subir quando o effort sobe&lt;/th&gt;
&lt;th&gt;Fonte&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;OpenAI reasoning&lt;/strong&gt; (Codex: ex. família GPT-5.6 Sol / Luna no &lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;downshift&lt;/a&gt;)&lt;/td&gt;
&lt;td&gt;Parâmetro &lt;code&gt;reasoning.effort&lt;/code&gt; na Responses API; no Codex o hook pode injetar &lt;code&gt;reasoning_effort&lt;/code&gt; no spawn do subagente&lt;/td&gt;
&lt;td&gt;Mais &lt;strong&gt;reasoning tokens&lt;/strong&gt; antes da resposta; docs descrevem ganho em tarefas multi-step e agentic, com &lt;strong&gt;mais latência e custo&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;&lt;a href="https://platform.openai.com/docs/guides/reasoning" rel="noopener noreferrer"&gt;OpenAI  -  Reasoning&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;xAI Grok&lt;/strong&gt; (&lt;code&gt;grok-4.6&lt;/code&gt;, &lt;code&gt;grok-4.7&lt;/code&gt;; Grok Build / CLI)&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;reasoning_effort&lt;/code&gt;: &lt;code&gt;low&lt;/code&gt; / &lt;code&gt;medium&lt;/code&gt; / &lt;code&gt;high&lt;/code&gt; (e &lt;code&gt;xhigh&lt;/code&gt; onde suportado); default &lt;strong&gt;&lt;code&gt;high&lt;/code&gt;&lt;/strong&gt;; raciocínio &lt;strong&gt;não desliga&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;Mais &lt;strong&gt;&lt;code&gt;reasoning_tokens&lt;/code&gt;&lt;/strong&gt; faturados; docs ligam effort alto a mais profundidade e &lt;strong&gt;maior latência&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;
&lt;a href="https://docs.x.ai/docs/guides/reasoning" rel="noopener noreferrer"&gt;xAI  -  Reasoning&lt;/a&gt; · &lt;a href="https://github.com/tiagovilasboas/harness-downshift#grok-cli-config-not-hook" rel="noopener noreferrer"&gt;downshift  -  Grok CLI&lt;/a&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;Claude&lt;/strong&gt; (Opus / Sonnet no agente)&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;Extended thinking:&lt;/strong&gt; &lt;code&gt;budget_tokens&lt;/code&gt; (modo manual) ou &lt;strong&gt;adaptive thinking&lt;/strong&gt; com &lt;code&gt;output_config.effort&lt;/code&gt; em gerações mais novas (ver doc por modelo)&lt;/td&gt;
&lt;td&gt;Mais tokens de &lt;strong&gt;&lt;code&gt;thinking&lt;/code&gt;&lt;/strong&gt; na fatura; orçamento maior aumenta &lt;strong&gt;latência&lt;/strong&gt;; adaptive pode &lt;strong&gt;omitir&lt;/strong&gt; thinking em input fácil&lt;/td&gt;
&lt;td&gt;&lt;a href="https://docs.anthropic.com/en/docs/build-with-claude/extended-thinking" rel="noopener noreferrer"&gt;Anthropic  -  Extended thinking&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;
&lt;strong&gt;Gemini&lt;/strong&gt; (ex. 3.8 Flash no meu mix Cursor)&lt;/td&gt;
&lt;td&gt;Thinking em modelos 2.5+ / 3.x (&lt;code&gt;thinkingLevel&lt;/code&gt; / config de thinking na API)&lt;/td&gt;
&lt;td&gt;Raciocínio interno antes da resposta; mais profundidade implica &lt;strong&gt;mais tokens e tempo&lt;/strong&gt; (modelo decide quanto pensar dentro do nível)&lt;/td&gt;
&lt;td&gt;&lt;a href="https://ai.google.dev/gemini-api/docs/thinking" rel="noopener noreferrer"&gt;Google  -  Gemini thinking&lt;/a&gt;&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Cursor (UI multi-provedor)&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;Sem campo único de effort&lt;/strong&gt; no &lt;code&gt;Task&lt;/code&gt; no downshift; knob via &lt;strong&gt;SKU do modelo&lt;/strong&gt; (variantes com “thinking”, “High”, linha &lt;strong&gt;Fast&lt;/strong&gt; vs standard na lista de preços)&lt;/td&gt;
&lt;td&gt;Effort embarcado no nome/preço do modelo; na minha lista Cursor, &lt;strong&gt;Fast&lt;/strong&gt; do mesmo tier costuma ser &lt;strong&gt;2× preço&lt;/strong&gt; por velocidade (preço de lista, não telemetria)&lt;/td&gt;
&lt;td&gt;Preços na UI Cursor (&lt;a href="https://dev.to/tiagovilasboas/model-routing-para-software-engineers-como-escolher-o-llm-certo-dentro-de-cada-harness-o5g"&gt;artigo de model routing&lt;/a&gt;) + doc do provedor por modelo&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Como eu uso os benchmarks com honestidade:&lt;/strong&gt; &lt;a href="https://www.swebench.com/" rel="noopener noreferrer"&gt;SWE-bench&lt;/a&gt; para capacidade em issues reais; &lt;a href="https://livebench.ai/" rel="noopener noreferrer"&gt;LiveBench&lt;/a&gt; para separar &lt;strong&gt;Coding&lt;/strong&gt; vs &lt;strong&gt;Agentic Coding&lt;/strong&gt; e olhar &lt;strong&gt;cost per successful task&lt;/strong&gt; (métrica pública do site, não minha); &lt;a href="https://artificialanalysis.ai/" rel="noopener noreferrer"&gt;Artificial Analysis&lt;/a&gt; para qualidade × preço × latência; &lt;a href="https://arena.ai/leaderboard" rel="noopener noreferrer"&gt;LMArena&lt;/a&gt; para preferência humana e custo por tarefa em agentes. Números de leaderboard = &lt;strong&gt;benchmark público&lt;/strong&gt;. Consumo 23→12 km/L da Harley = &lt;strong&gt;minha experiência&lt;/strong&gt;, não bench.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Dois eixos: tier e effort
&lt;/h2&gt;

&lt;p&gt;Pense em uma matriz mental (não precisa de planilha no dia a dia):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;                    effort baixo          effort alto
tier barato           grep, format          (raro: só se tier errado)
tier médio            feature local         debug multi-arquivo
tier frontier         review superficial    incidente, race, security
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O erro clássico depois de ler sobre routing: descer o &lt;strong&gt;modelo&lt;/strong&gt; do subagente e deixar o &lt;strong&gt;effort&lt;/strong&gt; no máximo porque “já estamos economizando”. Você fez downshift de tier e manteve stage 3 ligado na ida até a esquina.&lt;/p&gt;

&lt;p&gt;Detalhe por provedor: §3. No &lt;strong&gt;Claude Code&lt;/strong&gt; e &lt;strong&gt;Cursor&lt;/strong&gt;, o downshift hoje reescreve sobretudo &lt;strong&gt;tier via modelo&lt;/strong&gt; no &lt;code&gt;Task&lt;/code&gt;; effort separado aparece onde a API expõe (Codex, Grok config). Não confunda “já roteei o filho” com “já calibrei quanto ele pensa”.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Como eu escolho effort por classe de tarefa
&lt;/h2&gt;

&lt;p&gt;Tabela operacional. Ajuste aos nomes que &lt;strong&gt;seu&lt;/strong&gt; harness expõe (&lt;code&gt;low&lt;/code&gt; / &lt;code&gt;medium&lt;/code&gt; / &lt;code&gt;high&lt;/code&gt;, ou equivalente). Não é receita universal; é ponto de partida para política de time.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Classe de tarefa&lt;/th&gt;
&lt;th&gt;Exemplos&lt;/th&gt;
&lt;th&gt;Tier (routing)&lt;/th&gt;
&lt;th&gt;Effort típico&lt;/th&gt;
&lt;th&gt;Por quê&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Mecânica&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;rename, typo, format, commit message, listar arquivos&lt;/td&gt;
&lt;td&gt;small / cheap&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;baixo&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;saída verificável; thinking longo só infla tokens&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Cirúrgica&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;bug em uma função, campo novo, teste seguindo padrão&lt;/td&gt;
&lt;td&gt;small → mid&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;baixo a médio&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;sobe effort só se o barato errar &lt;strong&gt;raciocínio&lt;/strong&gt;, não execução&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Integrada&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;feature em vários arquivos, refactor de módulo&lt;/td&gt;
&lt;td&gt;mid / balanced&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;médio&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;planejamento moderado; ainda com testes no loop&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Exploratória&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;“onde isso quebra?”, trace em codebase grande&lt;/td&gt;
&lt;td&gt;mid&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;médio a alto&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;busca ampla; cuidado para não deixar alto em &lt;strong&gt;cada&lt;/strong&gt; filho de exploração&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Crítica&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;auth, pagamento, migração, race, security review&lt;/td&gt;
&lt;td&gt;frontier&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;alto&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;custo de errar domina custo de pensar&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Regra que eu repito para mim:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Comece com o menor effort que a classe permite.

        ↓

Passou no critério (teste, review, diff)?

SIM → pare.

NÃO
 ↓

Faltou execução (contexto, arquivo, harness)?

Corrija harness antes de subir effort.

Faltou raciocínio?

Suba effort OU suba tier (routing).

        ↓

Ainda falhou em tarefa crítica?

Frontier + effort alto, com humano no loop.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Isso evita o espelho do routing article: subir modelo quando o problema era contexto. Aqui: subir effort quando o problema era &lt;strong&gt;profundidade de raciocínio&lt;/strong&gt;, não ferramenta.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Exemplo ilustrativo&lt;/strong&gt; (números redondos, &lt;strong&gt;não&lt;/strong&gt; telemetria de produção): dez subagentes de exploração com effort alto podem custar mais em tokens de “pensamento” do que um subagente frontier com effort alto que resolve a hipótese certa em uma passada. Fan-out barato com effort máximo é armadilha silenciosa.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Fan-out: effort multiplica como modelo
&lt;/h2&gt;

&lt;p&gt;Quando o harness deixa abrir &lt;strong&gt;subagentes&lt;/strong&gt;, a conta deixa de ser linear. Cada filho herda ou recebe modelo &lt;strong&gt;e&lt;/strong&gt; effort. Uma árvore de oito filhos “explore” com effort alto é o mesmo tipo de erro que oito filhos em opus para listar &lt;code&gt;.go&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;Orquestração &lt;strong&gt;antes&lt;/strong&gt; da run, de novo:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Pai&lt;/strong&gt; (sessão principal): modelo e effort que você escolheu para coordenar.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Filhos&lt;/strong&gt;: tier e effort &lt;strong&gt;por prompt do spawn&lt;/strong&gt;, não por padrão da sessão.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;No downshift, o ponto de controle documentado é o &lt;strong&gt;spawn do &lt;code&gt;Task&lt;/code&gt;&lt;/strong&gt; (Claude Code, Cursor) ou &lt;code&gt;spawn_agent&lt;/code&gt; (Codex): classificar, mapear tier, e no Codex ajustar &lt;code&gt;reasoning_effort&lt;/code&gt; antes do processo filho existir. Grok: pins por role no config.&lt;/p&gt;

&lt;p&gt;Capability Router v2 no repositório fala em &lt;strong&gt;piso de segurança&lt;/strong&gt; para tarefas de alto risco (auth, migração, race): frontier independente do score. Para effort, eu trato o simétrico: tarefa crítica não recebe effort baixo só para economizar; tarefa trivial não recebe effort alto só porque o pai está em “modo sério”.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Effort como política de Staff
&lt;/h2&gt;

&lt;p&gt;Em time, effort vira o mesmo tipo de artefato que routing em YAML:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;subagent_defaults&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="na"&gt;explore_files&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;tier&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;small&lt;/span&gt;
    &lt;span class="na"&gt;reasoning_effort&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;low&lt;/span&gt;

  &lt;span class="na"&gt;implement_feature&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;tier&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;mid&lt;/span&gt;
    &lt;span class="na"&gt;reasoning_effort&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;medium&lt;/span&gt;

  &lt;span class="na"&gt;security_review&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;tier&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;frontier&lt;/span&gt;
    &lt;span class="na"&gt;reasoning_effort&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;high&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Você deixa de perguntar “qual modelo o João deixou no dropdown?” e passa a perguntar &lt;strong&gt;“qual capacidade e qual profundidade esta delegação exige?”&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Telemetria que eu gostaria de ver por spawn (formato, não promessa de produto):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;tier escolhido
reasoning_effort (se aplicável)
complexidade classificada
retries
resultado (teste / review humano)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Só tokens por modelo não fecha a conta de effort. Dois spawns no mesmo tier com efforts diferentes podem divergir muito no total.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Onde isso encaixa no harness
&lt;/h2&gt;

&lt;p&gt;Model routing sem effort é metade da política. O complemento é decidir &lt;strong&gt;quanto pensar&lt;/strong&gt; naquela instância, principalmente em &lt;strong&gt;multitarefa&lt;/strong&gt; e &lt;strong&gt;subagentes&lt;/strong&gt;, onde o padrão do harness costuma ser “herda tudo do pai”.&lt;/p&gt;

&lt;p&gt;Estou evoluindo o &lt;strong&gt;&lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;harness-downshift&lt;/a&gt;&lt;/strong&gt; para isso: no spawn do subagente, &lt;strong&gt;tier de modelo&lt;/strong&gt; e, onde o harness expõe o campo (documentado hoje para &lt;strong&gt;Codex&lt;/strong&gt; com &lt;code&gt;reasoning_effort&lt;/code&gt;, e &lt;strong&gt;Grok&lt;/strong&gt; via config por role), &lt;strong&gt;effort&lt;/strong&gt; alinhados à classificação da tarefa. Classifier determinístico, sem LLM no loop do router, fail-open se algo der errado. Beta honesto: compatibilidade de plano e harness muda; leia a seção de plan compatibility no README antes de instalar.&lt;/p&gt;

&lt;p&gt;Leia o &lt;a href="https://dev.to/tiagovilasboas/model-routing-para-software-engineers-como-escolher-o-llm-certo-dentro-de-cada-harness-o5g"&gt;texto de model routing&lt;/a&gt; para a escada de tiers, mix e custo por tarefa bem-sucedida. Este texto é o par: &lt;strong&gt;tier certo no routing, effort certo no spawn&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Pergunta para você:&lt;/strong&gt; no seu fluxo com subagentes, qual tarefa ainda herda effort alto (ou “thinking” máximo) só porque a sessão pai está em modo frontier? Que regra você escreveria para o primeiro filho mecânico da árvore?&lt;/p&gt;

</description>
      <category>ai</category>
      <category>productivity</category>
      <category>harness</category>
      <category>braziliandevs</category>
    </item>
    <item>
      <title>Model Routing para Software Engineers: como escolher o LLM certo dentro de cada harness</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Sun, 27 Sep 2026 20:38:22 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/model-routing-para-software-engineers-como-escolher-o-llm-certo-dentro-de-cada-harness-o5g</link>
      <guid>https://dev.to/tiagovilasboas/model-routing-para-software-engineers-como-escolher-o-llm-certo-dentro-de-cada-harness-o5g</guid>
      <description>&lt;p&gt;Abri o Cursor para corrigir copy de botão. Ainda estava selecionado o &lt;strong&gt;Claude Opus 5&lt;/strong&gt; (Opus 5). Funciona. Também funciona pedir a um Staff Engineer para trocar esse texto: você pagou capacidade de um nível que a tarefa não pedia.&lt;/p&gt;

&lt;p&gt;O problema não é falta de inteligência. É &lt;strong&gt;alocação de capacidade&lt;/strong&gt;. E a hora de alocar certo não é quando a fatura chega.&lt;/p&gt;

&lt;p&gt;Se você programa no Brasil, muita assinatura de agente cobra em &lt;strong&gt;dólar&lt;/strong&gt;. A fatura vem em USD. No bolso, pesa em &lt;strong&gt;real&lt;/strong&gt;. Não vou inventar câmbio nem colar valor da minha conta: o ponto é que &lt;strong&gt;trocar de modelo depois que o agente já queimou tokens de frontier é tarde&lt;/strong&gt;. A decisão era &lt;strong&gt;antes&lt;/strong&gt; de rodar o plano ou a tarefa.&lt;/p&gt;

&lt;p&gt;Antes de executar, você precisa saber o que cada LLM sabe fazer, onde ele tropeça, e se o &lt;strong&gt;custo-benefício&lt;/strong&gt; fecha para &lt;strong&gt;aquele&lt;/strong&gt; trabalho. Capacidade, limitação e preço entram juntos. Model routing não é remorso no fim do mês. É escolha no primeiro prompt.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Quando a empresa banca o modelo&lt;/strong&gt; (assinatura, crédito, invoice corporativa), essa escolha deixa de ser gosto e vira &lt;strong&gt;linha numa conta compartilhada&lt;/strong&gt;. O painel de uso ou a fatura mostram &lt;strong&gt;quem gastou quanto em qual modelo&lt;/strong&gt;. Isso &lt;strong&gt;não prova sozinho&lt;/strong&gt; quem escolheu bem. Custo-benefício exige &lt;strong&gt;tipo de tarefa&lt;/strong&gt;, &lt;strong&gt;retries&lt;/strong&gt; e se a tarefa &lt;strong&gt;terminou certa&lt;/strong&gt;. Esses campos só existem se o harness &lt;strong&gt;registra&lt;/strong&gt;. Não afirmo que a maioria das empresas já ranqueia dev por escolha de LLM: não tenho pesquisa de mercado que prove isso. Com log completo e volume, dá para ver quem entrega tarefa bem-sucedida com menos desperdício. A telemetria &lt;strong&gt;habilita&lt;/strong&gt; essa leitura. Usar ou não para gestão de time fica com cada empresa.&lt;/p&gt;

&lt;p&gt;A conta fica &lt;strong&gt;bem&lt;/strong&gt; mais cara quando o harness &lt;strong&gt;deixa o agente abrir subagentes&lt;/strong&gt; e você não &lt;strong&gt;orquestrou o plano antes&lt;/strong&gt; de executar. Um agente solo em &lt;strong&gt;Opus 5&lt;/strong&gt; já dói quando a tarefa era copy de botão. Subagentes &lt;strong&gt;multiplicam&lt;/strong&gt;: cada filho pode herdar ou escolher modelo, abrir contexto, errar, retentar e chamar mais filhos. A conta deixa de ser um modelo e vira uma &lt;strong&gt;árvore&lt;/strong&gt;. Se você não definiu antes quais passos, qual camada de modelo e onde parar, você paga o fan-out sem política.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Orquestrar antes da run&lt;/strong&gt; é a mesma decisão que &lt;strong&gt;trocar de modelo antes da run&lt;/strong&gt;. Descer tier ou rotear subagentes só ajuda se a regra existia &lt;strong&gt;antes&lt;/strong&gt; do spawn da Task. Depois que a árvore disparou, você negocia com a fatura.&lt;/p&gt;

&lt;p&gt;Agora pense numa empresa inteira: processos, ferramentas, documentos, banco, regras, histórico, sistemas, pessoas. Isso se aproxima do que chamamos de &lt;strong&gt;sistema de IA&lt;/strong&gt;. O &lt;strong&gt;LLM&lt;/strong&gt; é uma parte. É o profissional absurdamente rápido que você contrata para uma atividade. Tem gente barata e rápida. Tem especialista. Tem quem lê mais contexto antes de decidir. E tem quem custa dez vezes mais para resolver quase igual.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;LLM ≠ sistema de IA.&lt;/strong&gt; Escolher o campeão de ranking no dropdown e deixar fixo é confundir contratação com operação.&lt;/p&gt;

&lt;p&gt;Na prática eu faço &lt;strong&gt;model routing&lt;/strong&gt;: o LLM certo para a tarefa, dentro do &lt;strong&gt;harness&lt;/strong&gt; (Cursor, Claude Code, Codex, Kiro), começando pelo mais barato que aguenta o trabalho e subindo só quando falta raciocínio ou quando errar custa caro. Abaixo: preços de lista na UI, mix 80/15/5, benchmarks públicos, escada de três camadas, política em YAML, custo por tarefa bem-sucedida e por que a fonte definitiva é a telemetria do seu fluxo.&lt;/p&gt;

&lt;h2&gt;
  
  
  Neste artigo
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;A pergunta útil e as tarefas A, B e C&lt;/li&gt;
&lt;li&gt;Preços na UI do Cursor e mix 80/15/5&lt;/li&gt;
&lt;li&gt;Motor, harness e carro&lt;/li&gt;
&lt;li&gt;Escada FAST / BALANCED / FRONTIER&lt;/li&gt;
&lt;li&gt;Quando fazer switch (e quando não subir modelo)&lt;/li&gt;
&lt;li&gt;Model routing como política de engenharia&lt;/li&gt;
&lt;li&gt;Cursor: mapa rápido (preços na §2)&lt;/li&gt;
&lt;li&gt;Routing por harness: Claude Code, Codex, Kiro&lt;/li&gt;
&lt;li&gt;Cost per successful task&lt;/li&gt;
&lt;li&gt;Hora do engenheiro versus centavos de token&lt;/li&gt;
&lt;li&gt;Router automático e Harness Engineering&lt;/li&gt;
&lt;li&gt;Minha regra hoje&lt;/li&gt;
&lt;li&gt;Benchmark sem hype&lt;/li&gt;
&lt;li&gt;Pareto, tabela de fontes e matriz&lt;/li&gt;
&lt;li&gt;Bookmarks que eu deixo abertos&lt;/li&gt;
&lt;li&gt;YouTube e comunidade: shortlist, não veredito&lt;/li&gt;
&lt;li&gt;Telemetria: fonte definitiva (exemplo ilustrativo)&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  1. A pergunta útil e as tarefas A, B e C
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Dev sênior não deveria escolher um único LLM.&lt;/strong&gt; Deveria saber &lt;strong&gt;quando trocar&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;Você não precisa do melhor LLM. Precisa do &lt;strong&gt;LLM certo para cada trabalho&lt;/strong&gt;. A armadilha é abrir Cursor, Claude Code, Codex ou Kiro, pegar o modelo mais forte e deixar ali para tudo. Typo? Opus. Teste unitário? Opus. Dez repositórios e uma race condition? Opus também. Funciona. Só que você está pagando raciocínio de frontier onde um modelo barato bastava.&lt;/p&gt;

&lt;p&gt;A pergunta errada é: &lt;strong&gt;qual é o melhor modelo?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A pergunta útil:&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;Qual é o modelo &lt;strong&gt;mais barato&lt;/strong&gt; que executa &lt;strong&gt;esta&lt;/strong&gt; tarefa com segurança e qualidade suficientes?&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;Três tarefas fixam a escala na cabeça.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Tarefa A:&lt;/strong&gt; criar testes de um componente seguindo o padrão existente. Contexto pequeno, critério objetivo. Provavelmente não precisa do mais caro.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Tarefa B:&lt;/strong&gt; feature com API, front, migrations e testes. Vários arquivos, decisões no meio. Vale subir um degrau.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Tarefa C:&lt;/strong&gt; fluxo que duplica cobrança sob concorrência. Investigação, vários serviços, hipóteses, impacto financeiro. Pagar por mais capacidade pode ser barato perto do custo de errar.&lt;/p&gt;

&lt;p&gt;Isso é &lt;strong&gt;model switching&lt;/strong&gt;. O resto do texto é como eu operacionalizo isso por harness e por preço.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Preços na UI do Cursor e mix 80/15/5
&lt;/h2&gt;

&lt;p&gt;A pergunta que me fez montar a política foi banal: &lt;strong&gt;qual modelo na lista do Cursor dá melhor custo-benefício para programação no dia a dia?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Preços de lista na UI do Cursor&lt;/strong&gt; (data em que anotei; não é fatura nem telemetria de time). Daqui para frente eu remeto a &lt;strong&gt;tabela de preços&lt;/strong&gt; em vez de repetir número.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Modelo (UI Cursor)&lt;/th&gt;
&lt;th&gt;Input / Output por 1M&lt;/th&gt;
&lt;th&gt;Papel&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Composer 2.5&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$0,50 / $2,50&lt;/td&gt;
&lt;td&gt;barato, agente Cursor&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Gemini 3.8 Flash High&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;&lt;strong&gt;$0,75 / $3,50&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;meu default&lt;/strong&gt; (contexto até 1M)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Muse Spark 1.3 High&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$1,25 / $4,25&lt;/td&gt;
&lt;td&gt;alternativa barata&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Grok 4.7 normal High&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$2 / $6&lt;/td&gt;
&lt;td&gt;balanced / tarefa difícil&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Grok 4.7 High Fast&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$4 / $12&lt;/td&gt;
&lt;td&gt;mesmo tier, &lt;strong&gt;2× preço&lt;/strong&gt; (velocidade)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;GPT-5.6 Sol Medium&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$4 / $20&lt;/td&gt;
&lt;td&gt;frontier / raciocínio&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Claude Opus 5.5 Medium&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$4 / $20&lt;/td&gt;
&lt;td&gt;frontier / agêntico&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Claude Fable 5.1 High&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$10 / $50&lt;/td&gt;
&lt;td&gt;extremo&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Mix que uso em repo real&lt;/strong&gt; (refactor, bug, testes, agent loop). Daqui para frente: &lt;strong&gt;mix da §2&lt;/strong&gt;.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Share&lt;/th&gt;
&lt;th&gt;Modelo&lt;/th&gt;
&lt;th&gt;Quando&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;80%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Gemini 3.8 Flash High&lt;/td&gt;
&lt;td&gt;CRUD, testes, refactor local, PR, doc, feature pequena&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;15%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Grok 4.7 High &lt;strong&gt;sem Fast&lt;/strong&gt;
&lt;/td&gt;
&lt;td&gt;vários arquivos, debug chato, arquitetura, migração, agent long-running&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;5%&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Opus 5.5 / GPT-5.6 Sol&lt;/td&gt;
&lt;td&gt;barato já deu 2 - 3 voltas e não resolve&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Benchmark &lt;strong&gt;público&lt;/strong&gt; (não medição minha): Google cita &lt;strong&gt;Gemini 3.8 Flash&lt;/strong&gt; com &lt;strong&gt;73,7% DeepSWE&lt;/strong&gt;, &lt;strong&gt;GPT-5.6 Sol&lt;/strong&gt; &lt;strong&gt;72,7%&lt;/strong&gt;, &lt;strong&gt;Claude Opus 5&lt;/strong&gt; &lt;strong&gt;74,0%&lt;/strong&gt;, com Flash bem mais barato na tabela.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Default único:&lt;/strong&gt; Gemini Flash + Grok (sem Fast) como segundo degrau. Objetivo: crédito dura mais sem queda proporcional de qualidade.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Motor, harness e carro
&lt;/h2&gt;

&lt;p&gt;O modelo é o &lt;strong&gt;motor de raciocínio&lt;/strong&gt;. O sistema ao redor define contexto, ferramentas, arquivos que pode alterar, comandos, regras, tempo, orçamento e como validar o trabalho.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Cursor, Claude Code, Codex e Kiro&lt;/strong&gt; não são só chat. São &lt;strong&gt;harnesses&lt;/strong&gt;: camadas que transformam capacidade bruta em &lt;strong&gt;trabalho de engenharia&lt;/strong&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;LLM
 ↓
Harness
 ├── contexto do repositório
 ├── busca de arquivos
 ├── terminal
 ├── Git
 ├── MCP
 ├── skills
 ├── regras
 ├── memória/estado
 ├── ferramentas
 ├── testes
 └── feedback da execução
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O mesmo LLM em dois harnesses pode divergir muito. Programação com agentes não depende só de inteligência do modelo. Depende de algo mais próximo de:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;resultado =
modelo
× contexto
× ferramentas
× orchestration
× feedback
× validação
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Por isso comparar modelos &lt;strong&gt;só&lt;/strong&gt; por benchmark genérico fica insuficiente. Mais adiante separo benchmark de &lt;strong&gt;motor&lt;/strong&gt; versus &lt;strong&gt;carro inteiro&lt;/strong&gt; (agent/harness).&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Escada FAST / BALANCED / FRONTIER
&lt;/h2&gt;

&lt;p&gt;Começo em &lt;strong&gt;cheap&lt;/strong&gt;, só subo com motivo. Preços e mix: &lt;strong&gt;§2&lt;/strong&gt;. Aqui é &lt;strong&gt;capacidade versus risco&lt;/strong&gt; (escalation policy).&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Camada&lt;/th&gt;
&lt;th&gt;Perfil&lt;/th&gt;
&lt;th&gt;Exemplos de tarefa&lt;/th&gt;
&lt;th&gt;Cursor (§2)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;FAST / cheap&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;localizada, verificável, baixo risco&lt;/td&gt;
&lt;td&gt;testes, mocks, lint, DTO, CRUD, migration simples&lt;/td&gt;
&lt;td&gt;Composer, Gemini Flash&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;BALANCED&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;vários arquivos, ambiguidade, debug, planning&lt;/td&gt;
&lt;td&gt;feature inteira, bug, refactor módulo, integração, migração API&lt;/td&gt;
&lt;td&gt;Grok 4.7 &lt;strong&gt;sem Fast&lt;/strong&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;FRONTIER&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;cognitivamente caro, alto risco&lt;/td&gt;
&lt;td&gt;race condition, distribuído, segurança, incidente, code review crítico&lt;/td&gt;
&lt;td&gt;Opus 5.5, GPT-5.6 Sol; Fable se extremo&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Agente que lê milhares de arquivos no mês multiplica qualquer linha da &lt;strong&gt;tabela de preços&lt;/strong&gt;. Frontier &lt;strong&gt;não&lt;/strong&gt; significa "cinco vezes melhor": o &lt;strong&gt;custo marginal&lt;/strong&gt; precisa fazer sentido para o problema.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. Quando fazer switch (e quando não subir modelo)
&lt;/h2&gt;

&lt;p&gt;O segredo não é escolher. É saber &lt;strong&gt;quando fazer o switch&lt;/strong&gt;.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Comece barato.

        ↓

O modelo resolveu?

SIM → valide e termine.

NÃO
 ↓

Ele está errando execução
ou errando raciocínio?

Execução → melhore contexto/tooling.
Raciocínio → aumente o modelo.

        ↓

Ainda falhou?

Suba novamente.
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Muita equipe faz &lt;code&gt;modelo falhou → modelo maior&lt;/code&gt; quando o problema era contexto: arquivo errado, regra de negócio fora do prompt, teste inacessível, harness que perdeu estado.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Nenhum modelo resolve contexto que nunca recebeu.&lt;/strong&gt; Antes de subir de camada, eu olho rules, indexação, testes disponíveis e se o code review humano está no loop certo.&lt;/p&gt;

&lt;h2&gt;
  
  
  6. Model routing como política de engenharia
&lt;/h2&gt;

&lt;p&gt;Em time maduro, routing vira política por tarefa, não gosto individual:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;tasks&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;

  &lt;span class="na"&gt;simple_change&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;cheap&lt;/span&gt;

  &lt;span class="na"&gt;unit_tests&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;cheap&lt;/span&gt;

  &lt;span class="na"&gt;feature&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;balanced&lt;/span&gt;

  &lt;span class="na"&gt;debugging&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;balanced&lt;/span&gt;

  &lt;span class="na"&gt;architecture&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;frontier&lt;/span&gt;

  &lt;span class="na"&gt;security_review&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;frontier&lt;/span&gt;

  &lt;span class="na"&gt;financial_rule_review&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
    &lt;span class="na"&gt;model&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;frontier&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Você deixa de perguntar "qual modelo o João gosta?" e passa a perguntar &lt;strong&gt;"qual capacidade esta tarefa exige?"&lt;/strong&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  7. Cursor: mapa rápido (preços na §2)
&lt;/h2&gt;

&lt;p&gt;Cursor expõe multi-provedor, modelos próprios e Auto; &lt;strong&gt;modelo muda o orçamento&lt;/strong&gt;. Não repito valores: &lt;strong&gt;tabela de preços&lt;/strong&gt; e &lt;strong&gt;mix 80/15/5&lt;/strong&gt; na §2; camadas na §4.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Situação no repo&lt;/th&gt;
&lt;th&gt;Camada (§4)&lt;/th&gt;
&lt;th&gt;Onde na §2&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;pequenas alterações&lt;/td&gt;
&lt;td&gt;cheap&lt;/td&gt;
&lt;td&gt;Composer / Gemini Flash&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;feature normal&lt;/td&gt;
&lt;td&gt;balanced&lt;/td&gt;
&lt;td&gt;Grok standard (&lt;strong&gt;sem&lt;/strong&gt; linha Fast)&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;problema complexo&lt;/td&gt;
&lt;td&gt;frontier&lt;/td&gt;
&lt;td&gt;GPT-5.6 Sol / Opus 5.5&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;extremo&lt;/td&gt;
&lt;td&gt;frontier+&lt;/td&gt;
&lt;td&gt;Fable ou reasoning maior&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Fast:&lt;/strong&gt; compare as duas linhas Grok na &lt;strong&gt;tabela de preços&lt;/strong&gt;. Velocidade também é decisão econômica.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Routing por harness: Claude Code, Codex, Kiro
&lt;/h2&gt;

&lt;p&gt;Mesma escada da §4; muda o catálogo. Nomes envelhecem em seis meses; o padrão cheap → balanced → frontier permanece.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Harness&lt;/th&gt;
&lt;th&gt;Cheap → balanced → frontier&lt;/th&gt;
&lt;th&gt;Notas&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Claude Code&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;eficiente → Sonnet → Opus&lt;/td&gt;
&lt;td&gt;ecossistema Claude; menos troca de fornecedor por prompt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Codex&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;eficiente → GPT-5.6 Sol (equilíbrio doc OpenAI) → frontier&lt;/td&gt;
&lt;td&gt;investigação difícil sobe tier&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Kiro&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;open-weight / barato → Sonnet → Opus&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;créditos:&lt;/strong&gt; Pro ~1.000/mês (lista), extra &lt;strong&gt;US$ 0,04&lt;/strong&gt;; Opus em tudo quebra franquia&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Não compre raciocínio que a tarefa não precisa.&lt;/strong&gt; Em empresa, isso vira política compartilhada, não gosto individual.&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  9. Cost per successful task
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Modelo barato ≠ execução barata.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Modelo A: &lt;strong&gt;$1&lt;/strong&gt;, oito tentativas. Modelo B: &lt;strong&gt;$5&lt;/strong&gt;, resolve de primeira. B pode ser mais barato no total.&lt;/p&gt;

&lt;p&gt;Em vez de só &lt;strong&gt;$/1M tokens&lt;/strong&gt;, meça:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Custo real =
tokens
+ número de tentativas
+ tempo do desenvolvedor
+ tempo de execução
+ retrabalho
+ risco
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Esse é o eixo &lt;strong&gt;cost per successful task&lt;/strong&gt; que LiveBench e benchmarks de agente expõem publicamente.&lt;/p&gt;

&lt;h2&gt;
  
  
  10. Hora do engenheiro versus centavos de token
&lt;/h2&gt;

&lt;p&gt;Exemplo de mesa: engenheiro a &lt;strong&gt;R$ 150/h&lt;/strong&gt;, &lt;strong&gt;30 minutos&lt;/strong&gt; empurrando modelo barato = &lt;strong&gt;R$ 75&lt;/strong&gt; de tempo humano. Economizar &lt;strong&gt;US$ 0,30&lt;/strong&gt; em tokens deixa de ser otimização.&lt;/p&gt;

&lt;p&gt;Escalar pelas &lt;strong&gt;camadas da §4&lt;/strong&gt; (Flash → Grok → Opus no Cursor) pode &lt;strong&gt;reduzir custo total da tarefa&lt;/strong&gt;, não aumentar.&lt;/p&gt;

&lt;h2&gt;
  
  
  11. Router automático e Harness Engineering
&lt;/h2&gt;

&lt;p&gt;Hoje:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;developer → escolhe modelo → harness
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Próximo estágio:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;developer → tarefa → router → cheap | balanced | frontier → agent
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;O router pode olhar complexidade, risco, contexto, latência, custo, tipo de alteração, histórico de sucesso.&lt;/p&gt;

&lt;p&gt;O &lt;strong&gt;Cursor Auto&lt;/strong&gt; já roteia buscando equilíbrio entre custo, inteligência e confiabilidade. O dev administra &lt;strong&gt;políticas de execução&lt;/strong&gt;, não só dropdown.&lt;/p&gt;

&lt;p&gt;Se o seu foco é contexto persistente para agentes, eu escrevi sobre isso em &lt;a href="https://dev.to/tiagovilasboas/harness-engineer-como-um-knowledge-base-rag-centralizado-pode-impactar-positivamente-sua-empresa-2ako"&gt;Harness Engineer: knowledge base RAG centralizado&lt;/a&gt;. Neste texto o foco é &lt;strong&gt;routing&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  12. Minha regra hoje
&lt;/h2&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Use o menor modelo capaz de resolver o problema.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Suba de modelo quando faltar raciocínio.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Melhore o harness quando faltar contexto.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Use o modelo mais caro apenas quando o custo de errar for maior que o custo de pensar.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;LLM deixa de ser "assinatura de IA" e vira &lt;strong&gt;infraestrutura de engenharia&lt;/strong&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  13. Benchmark sem hype
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;Não escolha modelo por hype: use benchmark, custo e contexto.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Cruzo três sinais: benchmark de coding; custo por token ou por tarefa; desempenho dentro de um &lt;strong&gt;harness real&lt;/strong&gt;. Um modelo pode brilhar em resposta curta e falhar com agente rodando minutos no repo.&lt;/p&gt;

&lt;h3&gt;
  
  
  SWE-bench
&lt;/h3&gt;

&lt;p&gt;Issues reais de GitHub; patch que resolve. Leaderboard mede &lt;strong&gt;% de instâncias resolvidas&lt;/strong&gt;. Pergunta: capacidade de engenharia perto do mundo real.&lt;/p&gt;

&lt;h3&gt;
  
  
  LMArena Coding
&lt;/h3&gt;

&lt;p&gt;Comparação humana entre respostas. Responde: "qual resposta de programação as pessoas preferiram?" Não responde sozinha: "qual agente alterou o repo corretamente por 20 minutos?"&lt;/p&gt;

&lt;h3&gt;
  
  
  Artificial Analysis
&lt;/h3&gt;

&lt;p&gt;Eixo &lt;strong&gt;qualidade × latência × throughput × preço&lt;/strong&gt;. Coding Index com frontiers próximos: pagar muito mais nem sempre dá ganho proporcional.&lt;/p&gt;

&lt;h3&gt;
  
  
  Harness e HarnessTax
&lt;/h3&gt;

&lt;p&gt;LMArena também avalia agentes com &lt;strong&gt;custo por tarefa&lt;/strong&gt; e discute &lt;strong&gt;HarnessTax&lt;/strong&gt;: quanto do resultado é modelo versus ambiente.&lt;/p&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Benchmark de modelo mede o motor. Benchmark de agente mede o carro inteiro.&lt;/strong&gt;&lt;br&gt;
&lt;/p&gt;
&lt;/blockquote&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Model Benchmark → "Esse modelo sabe programar?"
Agent/Harness Benchmark → "Esse modelo consegue trabalhar?"
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;LiveBench&lt;/strong&gt; separa &lt;strong&gt;Coding&lt;/strong&gt; de &lt;strong&gt;Agentic Coding&lt;/strong&gt; e mostra &lt;strong&gt;cost per successful task&lt;/strong&gt; (benchmark público, não telemetria minha).&lt;/p&gt;

&lt;h2&gt;
  
  
  14. Pareto, tabela de fontes e matriz
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Fonte&lt;/th&gt;
&lt;th&gt;O que eu olho&lt;/th&gt;
&lt;th&gt;Para que serve&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;SWE-bench&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Issues reais resolvidas&lt;/td&gt;
&lt;td&gt;capacidade de engenharia&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;LMArena Coding&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;preferência humana em coding&lt;/td&gt;
&lt;td&gt;qualidade percebida&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Artificial Analysis&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;inteligência, velocidade e preço&lt;/td&gt;
&lt;td&gt;custo-benefício&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Harness/Agent Benchmarks&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;tarefa completa + custo&lt;/td&gt;
&lt;td&gt;agentic coding&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Pricing oficial provider/harness&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;$/token ou créditos&lt;/td&gt;
&lt;td&gt;decisão econômica&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Nunca escolheria modelo só por estar em primeiro lugar. Busco &lt;strong&gt;Pareto&lt;/strong&gt;: qualidade suficiente pelo menor custo e latência na classe de tarefa.&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;                    COMPLEXIDADE DA TAREFA
                           ↑

         Frontier         │  Opus / GPT frontier
         Balanced         │  Grok / Sonnet
         Efficient        │  §4 cheap (Flash / Composer)
                          └────────────────────────────→
                              CUSTO / LATÊNCIA
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;&lt;strong&gt;Não procure o ponto mais alto. Procure a fronteira de Pareto.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Exemplo ilustrativo (números redondos para raciocínio, &lt;strong&gt;não&lt;/strong&gt; dados de produção):&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Modelo A: qualidade 95, custo $10&lt;/li&gt;
&lt;li&gt;Modelo B: qualidade 93, custo $1&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Em tarefa de baixo risco, B pode ser melhor economicamente. Em &lt;strong&gt;pagamento, segurança, concorrência, arquitetura crítica&lt;/strong&gt;, dois pontos percentuais podem justificar frontier.&lt;/p&gt;

&lt;h2&gt;
  
  
  15. Bookmarks que eu deixo abertos
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;a href="https://www.swebench.com/" rel="noopener noreferrer"&gt;SWE-bench&lt;/a&gt;: issues reais de software&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://arena.ai/leaderboard/text/coding" rel="noopener noreferrer"&gt;LMArena Coding&lt;/a&gt;: preferência humana em programação&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://arena.ai/leaderboard" rel="noopener noreferrer"&gt;LMArena Agent Leaderboard&lt;/a&gt;: agentes, harnesses, custo por tarefa&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://artificialanalysis.ai/" rel="noopener noreferrer"&gt;Artificial Analysis&lt;/a&gt;: qualidade, preço, velocidade&lt;/li&gt;
&lt;li&gt;
&lt;a href="https://livebench.ai/" rel="noopener noreferrer"&gt;LiveBench&lt;/a&gt;: coding vs agentic coding, cost per successful task&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Benchmark não escolhe modelo por você. Ele reduz achismo.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;A métrica de engenharia continua sendo: &lt;strong&gt;quanto custa entregar uma tarefa correta em produção?&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;p&gt;&lt;strong&gt;Benchmarks:&lt;/strong&gt; SWE-bench · LiveBench · Artificial Analysis · LMArena · OpenSOTA&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Uso real / comunidade:&lt;/strong&gt; Limite Semanal · IndyDevDan · Sam Witteveen · GosuCoder · Armin Ronacher · Fireship&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Fonte definitiva:&lt;/strong&gt; sua própria telemetria de execução.&lt;/p&gt;

&lt;h2&gt;
  
  
  16. YouTube e comunidade: shortlist, não veredito
&lt;/h2&gt;

&lt;p&gt;Benchmark não conta a história inteira. Para limite de assinatura, contexto longo, agente rodando horas, diferenças entre Cursor, Claude Code e Codex, eu também olho quem usa isso todo dia.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Em português:&lt;/strong&gt; &lt;strong&gt;Limite Semanal&lt;/strong&gt; (consumo, limites, escolha de ferramentas). Canal é &lt;strong&gt;comunidade&lt;/strong&gt;, não veredito.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Em inglês:&lt;/strong&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;IndyDevDan&lt;/strong&gt;: Claude Code, multi-agent, orchestration, context engineering&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sam Witteveen&lt;/strong&gt;: LLM engineering, agentes, experimentos técnicos&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;GosuCoder&lt;/strong&gt;: comparações entre coding agents e modelos&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Armin Ronacher&lt;/strong&gt;: agentic coding e desenvolvimento orientado a agentes&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Fireship&lt;/strong&gt;: novidades de ferramentas e SDKs (menos profundo em routing)&lt;/li&gt;
&lt;/ul&gt;

&lt;blockquote&gt;
&lt;p&gt;&lt;strong&gt;Benchmark me ajuda a montar a shortlist.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Uso real me ajuda a escolher o modelo.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Telemetria do meu harness me diz se eu estava certo.&lt;/strong&gt;&lt;/p&gt;
&lt;/blockquote&gt;

&lt;h2&gt;
  
  
  17. Telemetria: fonte definitiva (exemplo ilustrativo)
&lt;/h2&gt;

&lt;p&gt;Depois de benchmarks e comunidade, a melhor fonte deveria ser &lt;strong&gt;a própria empresa&lt;/strong&gt; (ou o seu fluxo solo instrumentado).&lt;/p&gt;

&lt;p&gt;Campos que eu registraria por execução:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;modelo
tipo da tarefa
tokens consumidos
tempo até conclusão
número de retries
testes executados
resultado dos testes
intervenções humanas
custo
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Depois de centenas de execuções &lt;strong&gt;com log de tarefa, retries e sucesso&lt;/strong&gt;, você responde: &lt;strong&gt;"qual modelo funciona no nosso software engineering system?"&lt;/strong&gt; Só o extrato de tokens por modelo não fecha essa conta.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Exemplo ilustrativo&lt;/strong&gt; (didático, &lt;strong&gt;não&lt;/strong&gt; medição minha em produção):&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;Testes unitários / Gemini Flash → 91% sucesso → $0.08/tarefa
Feature pequena / Grok → 88% sucesso → $0.42/tarefa
Debug distribuído / Opus → 84% sucesso → $2.31/tarefa
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Use como &lt;strong&gt;formato de relatório&lt;/strong&gt;, não como promessa. Só telemetria real do seu harness fecha o loop.&lt;/p&gt;




&lt;p&gt;Isso não é mais um "ranking dos melhores LLMs de 2026". É política: evidência pública para shortlist, harness para contexto, routing para custo total, code review humano onde o risco manda.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Para debater:&lt;/strong&gt; no Cursor (ou outro harness), qual tarefa ainda está no modelo mais caro só porque ninguém escreveu a regra de descer de camada?&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A)&lt;/strong&gt; FAST / cheap: typo, rename, grep, formatação.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;B)&lt;/strong&gt; BALANCED: feature pequena, refactor local, testes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;C)&lt;/strong&gt; FRONTIER: arquitetura, incidente, gate de PRD.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Qual letra você deixaria como default hoje, e qual tarefa real ainda acorda o tier errado?&lt;/p&gt;

&lt;p&gt;Por isso estou construindo o &lt;strong&gt;&lt;a href="https://github.com/tiagovilasboas/harness-downshift" rel="noopener noreferrer"&gt;downshift&lt;/a&gt;&lt;/strong&gt;. Ele surgiu para &lt;strong&gt;auxiliar o desenvolvedor nessa escolha de modelo de forma antecipada&lt;/strong&gt;, principalmente quando trabalhamos com &lt;strong&gt;subagentes&lt;/strong&gt; e &lt;strong&gt;várias tarefas&lt;/strong&gt; (multitarefa, fan-out). O foco &lt;strong&gt;não&lt;/strong&gt; é o chat único do dia a dia: no desenho do projeto, a sessão principal continua com o modelo que você escolheu; o router atua &lt;strong&gt;no spawn do subagente&lt;/strong&gt;, classificando a tarefa e encaixando tier antes do filho começar (hooks no Claude Code, Cursor e Codex). É o complemento prático deste texto: política na delegação, não remorso na fatura.&lt;/p&gt;

&lt;p&gt;A segunda decisão, depois do tier, é calibrar o &lt;strong&gt;effort&lt;/strong&gt; da tarefa  -  o par deste texto é &lt;a href="https://dev.to/tiagovilasboas/o-effort-da-tarefa-quando-pensar-demais-vira-stage-3-na-fatura-do-agente-1h3d"&gt;O effort da tarefa: quando pensar demais vira stage 3 na fatura do agente&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>productivity</category>
      <category>braziliandevs</category>
    </item>
    <item>
      <title>Harness Engineer: como um knowledge base (RAG) centralizado pode impactar positivamente sua empresa</title>
      <dc:creator>Tiago Vilas Boas (Montanha)</dc:creator>
      <pubDate>Sun, 27 Sep 2026 18:29:32 +0000</pubDate>
      <link>https://dev.to/tiagovilasboas/harness-engineer-como-um-knowledge-base-rag-centralizado-pode-impactar-positivamente-sua-empresa-2ako</link>
      <guid>https://dev.to/tiagovilasboas/harness-engineer-como-um-knowledge-base-rag-centralizado-pode-impactar-positivamente-sua-empresa-2ako</guid>
      <description>&lt;p&gt;Imagine um novo engenheiro chegando à sua equipe hoje. A barreira número um de produtividade nunca é a sintaxe da linguagem. A verdadeira barreira é o &lt;strong&gt;ramp-up de regras de negócio&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;O desenvolvedor recém-chegado abre o repositório, lê um Confluence desatualizado de dois anos atrás, cria a branch e pede para um assistente de IA gerar o código da feature. A IA gera um código sintaticamente perfeito, com Clean Code e testes unitários passando. O Pull Request é aberto e parece impecável.&lt;/p&gt;

&lt;p&gt;Mas quando a alteração vai para produção... o sistema quebra.&lt;/p&gt;

&lt;p&gt;Por que isso acontece? Porque a regra que aquele código quebrou &lt;strong&gt;não estava escrita no arquivo que ele alterou&lt;/strong&gt;. Ela nasceu de um incidente gravíssimo de dois anos atrás, num serviço vizinho que ninguém documentou na wiki: uma cobrança duplicada no checkout, um cálculo de juros que exige dias úteis ou um vazamento de dados de outro vendedor.&lt;/p&gt;

&lt;p&gt;Neste artigo, vamos entender como a engenharia de harness resolve esse problema na raiz: usando uma &lt;strong&gt;base de conhecimento versionada no Git (Knowledge Base / RAG cirúrgico)&lt;/strong&gt; ancorada nos arquivos do projeto, garantindo que o code review e os agentes de IA nunca repitam os erros que a sua empresa já pagou caro para aprender.&lt;/p&gt;




&lt;h2&gt;
  
  
  O Problema: O Diff Está Certo, mas a Empresa Paga a Conta
&lt;/h2&gt;

&lt;p&gt;Code reviews tradicionais e linters automatizados são ótimos para encontrar bugs locais: ponteiros nulos, sintaxe errada ou consultas SQL ineficientes.&lt;/p&gt;

&lt;p&gt;O que escapa silenciosamente são as &lt;strong&gt;fronteiras de negócio&lt;/strong&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;[ Desenvolvedor / Agente ] ──&amp;gt; Altera `checkout/payment_step.go`
                                        │
                                        ▼
                               [ Testes Unitários: OK ]
                               [ Linter / Build: OK ]
                                        │
                                        ▼
                                 [ PULL REQUEST ]
                                        │
                         (Mas quebrou a regra invisível:)
             "Cobranças de cartão exigem idempotency_key de 32 chars"
                                        │
                                        ▼
                       [ PRODUÇÃO: Cobrança Duplicada! ]
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Seis Classes de Erros que a Memória do Time Costuma Esquecer
&lt;/h3&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Cobrança Duplicada:&lt;/strong&gt; Um novo gateway de pagamento entra sem a chave de idempotência obrigatória que um incidente passado já exigia.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Juros em Calendário Errado:&lt;/strong&gt; O código faz diferença simples de dias (&lt;code&gt;data_fim - data_inicio&lt;/code&gt;) onde o meio financeiro exige dias úteis bancários.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Assinatura com Ciclo a Menos:&lt;/strong&gt; Um operador &lt;code&gt;&amp;lt;&lt;/code&gt; onde o contrato de recorrência exigia &lt;code&gt;&amp;lt;=&lt;/code&gt;, encurtando o acesso do cliente.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;IDOR / Acesso Indevido:&lt;/strong&gt; Um endpoint de detalhes de pedido que recebe o &lt;code&gt;order_id&lt;/code&gt; sem validar o &lt;code&gt;tenant_id&lt;/code&gt; da sessão logada.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Painel de Outro Vendedor:&lt;/strong&gt; Suporte acessando dados de sellers sem token de uso único e sem trilha de auditoria.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Saque Acima do Teto:&lt;/strong&gt; Lógica de transferência que valida saldo, mas ignora o limite regulatório da conta física.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;A dor não é falta de observabilidade ou falta de testes. É &lt;strong&gt;falta de memória institucional no momento do review&lt;/strong&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  A Arquitetura: Knowledge Base Ancorado em Arquivos (File-Path RAG)
&lt;/h2&gt;

&lt;p&gt;Muitas empresas tentam resolver isso jogando todo o Confluence e wikis num banco vetorial com bilhões de embeddings. O resultado? O agente alucina, confunde regras de times diferentes e gera custos astronômicos de infraestrutura.&lt;/p&gt;

&lt;p&gt;A abordagem moderna de &lt;strong&gt;Harness Engineering&lt;/strong&gt; é mais simples e muito mais eficiente: &lt;strong&gt;recuperação por caminho de arquivo (Path-Anchored RAG)&lt;/strong&gt;:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;                  ┌─────────────────────────────────────────┐
                  │      Pull Request Aberto com Diff       │
                  │ Arquivos tocados: src/payments/charge.ts│
                  └────────────────────┬────────────────────┘
                                       │
                                       ▼
                  ┌─────────────────────────────────────────┐
                  │   Recorte Automático no Knowledge Base   │
                  │   Busca fichas vinculadas a este path   │
                  └────────────────────┬────────────────────┘
                                       │
                                       ▼
                  ┌─────────────────────────────────────────┐
                  │     Ficha de Regra Injetada no Review   │
                  │ "Regra #114: Todo charge.ts exige chave  │
                  │  de idempotência SHA-256 no header"     │
                  └────────────────────┬────────────────────┘
                                       │
                                       ▼
                  ┌─────────────────────────────────────────┐
                  │  Revisor / Agente Valida o Contrato      │
                  │  Bloqueia merge ANTES de ir para prod   │
                  └─────────────────────────────────────────┘
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Em vez de obrigar o modelo a decorar 200 regras abstratas, o harness injeta &lt;strong&gt;apenas a ficha exata do arquivo que o desenvolvedor alterou&lt;/strong&gt;.&lt;/p&gt;




&lt;h2&gt;
  
  
  A Anatomia de uma Ficha de Conhecimento (Regra de Negócio)
&lt;/h2&gt;

&lt;p&gt;Para que uma regra de negócio funcione como um sensor confiável e não como um conselho vago, ela precisa ser estruturada como código:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight yaml"&gt;&lt;code&gt;&lt;span class="na"&gt;id&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;RULE-PAY-042&lt;/span&gt;
&lt;span class="na"&gt;titulo&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;Idempotência Obrigatória em Criação de Cobranças&lt;/span&gt;
&lt;span class="na"&gt;status&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;vigente&lt;/span&gt; &lt;span class="c1"&gt;# vigente | a-confirmar | gap&lt;/span&gt;
&lt;span class="na"&gt;severidade&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s"&gt;critica&lt;/span&gt; &lt;span class="c1"&gt;# critica | alta | media&lt;/span&gt;
&lt;span class="na"&gt;arquivos_fonte&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt;
  &lt;span class="pi"&gt;-&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;services/billing/charge_processor.go"&lt;/span&gt;
&lt;span class="na"&gt;como_checar&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="pi"&gt;|&lt;/span&gt;
  &lt;span class="s"&gt;Verificar se a chamada à API do gateway propaga o header 'X-Idempotency-Key'.&lt;/span&gt;
  &lt;span class="s"&gt;Se a requisição for reenviada em caso de timeout, a mesma chave deve ser reutilizada.&lt;/span&gt;
&lt;span class="na"&gt;incidente_origem&lt;/span&gt;&lt;span class="pi"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"&lt;/span&gt;&lt;span class="s"&gt;INC-2024-883&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;(Duplicidade&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;em&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;Black&lt;/span&gt;&lt;span class="nv"&gt; &lt;/span&gt;&lt;span class="s"&gt;Friday)"&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;h3&gt;
  
  
  Os Três Estados de uma Regra
&lt;/h3&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Vigente:&lt;/strong&gt; A regra é lei comprovada. Se o Pull Request violar o campo &lt;code&gt;como_checar&lt;/code&gt;, o revisor ou o agente pode bloquear o merge.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A-Confirmar:&lt;/strong&gt; Hipótese técnica. O revisor aponta como dúvida construtiva no PR, mas não bloqueia o fluxo de entrega.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Gap:&lt;/strong&gt; Identificamos que o sistema atual não garante um comportamento esperado, servindo de alerta de risco para o time.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  Por Que Manter a Base no Git e Não em uma Wiki Corporativa?
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Critério&lt;/th&gt;
&lt;th&gt;Wiki Corporativa (Confluence/Notion)&lt;/th&gt;
&lt;th&gt;Knowledge Base no Git (Markdown)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Ciclo de Vida&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Nasce desatualizada no dia seguinte&lt;/td&gt;
&lt;td&gt;Versionada lado a lado com os PRs&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Integração com IA&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Difícil de indexar cirurgicamente&lt;/td&gt;
&lt;td&gt;Leitura instantânea via CLI, MCP ou scripts&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Auditoria&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Ninguém sabe quem apagou ou editou&lt;/td&gt;
&lt;td&gt;
&lt;code&gt;git blame&lt;/code&gt; e histórico completo de commits&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Custo de Infra&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Licenças caras e servidores extras&lt;/td&gt;
&lt;td&gt;Gratuito, armazenado no próprio repositório&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Ação no Code Review&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Passiva (depende de alguém lembrar de ler)&lt;/td&gt;
&lt;td&gt;Ativa (o script puxa a regra pelo caminho do diff)&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Quando a base de regras vive no Git, os desenvolvedores tratam a governança de negócio com o mesmo cuidado com que tratam o código de produção.&lt;/p&gt;




&lt;h2&gt;
  
  
  O Papel do Harness Engineer
&lt;/h2&gt;

&lt;p&gt;O engenheiro de software tradicional foca em entregar a funcionalidade. O &lt;strong&gt;Harness Engineer&lt;/strong&gt; projeta o ambiente e os sensores para que a entrega aconteça com segurança contínua:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Outer Harness:&lt;/strong&gt; Constrói os scripts e automações de pré-commit e CI que extraem os arquivos alterados e injetam as regras no prompt do revisor.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Curadoria Contínua:&lt;/strong&gt; Transforma post-mortems de incidentes reais em novas fichas de regras no repositório.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Roteamento de Modelos:&lt;/strong&gt; Para triagens simples de regras, utiliza modelos locais ou classificadores eficientes como o &lt;strong&gt;Downshift&lt;/strong&gt; (&lt;code&gt;harness-downshift&lt;/code&gt;) em Go, escalando para modelos de ponta via &lt;strong&gt;OpenRouter&lt;/strong&gt; apenas quando o diff envolve fluxos financeiros críticos.&lt;/li&gt;
&lt;/ol&gt;




&lt;h2&gt;
  
  
  Referências Didáticas e Vídeos Recomendados
&lt;/h2&gt;

&lt;p&gt;Para aprofundar na construção de Knowledge Bases e engenharia de contexto para times:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;📺 &lt;strong&gt;Vídeo (YouTube em Português):&lt;/strong&gt; &lt;a href="https://www.youtube.com/results?search_query=o+que+%C3%A9+rag+inteligencia+artificial+portugues" rel="noopener noreferrer"&gt;RAG Descomplicado: O Que é Retrieval-Augmented Generation e Como Usar&lt;/a&gt; - Introdução didática sobre recuperação de contexto para modelos de IA.&lt;/li&gt;
&lt;li&gt;📺 &lt;strong&gt;Vídeo (YouTube em Português):&lt;/strong&gt; &lt;a href="https://www.youtube.com/results?search_query=architecture+decision+records+adr+portugues" rel="noopener noreferrer"&gt;Como Documentar Arquitetura com Markdown e Git (Architecture Decision Records)&lt;/a&gt; - Boas práticas para manter documentação viva e versionada no Git.&lt;/li&gt;
&lt;li&gt;📖 &lt;strong&gt;Artigo de Referência:&lt;/strong&gt; &lt;a href="https://martinfowler.com/articles/harness-engineering.html" rel="noopener noreferrer"&gt;Harness Engineering for Coding Agent Users (Martin Fowler)&lt;/a&gt; - Como guias feedforward e sensores feedback criam guard-rails para equipes de software.&lt;/li&gt;
&lt;/ul&gt;




&lt;h2&gt;
  
  
  Como Começar na Sua Squad Nesta Semana
&lt;/h2&gt;

&lt;p&gt;Você não precisa catalogar 200 regras no primeiro dia. Comece pequeno com este plano de 3 passos:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Pegue o último incidente da sua equipe:&lt;/strong&gt; Em vez de deixar o post-mortem esquecido em um PDF, crie uma pasta &lt;code&gt;rules/&lt;/code&gt; no repositório.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Escreva sua primeira ficha:&lt;/strong&gt; Crie um arquivo &lt;code&gt;RULE-001.md&lt;/code&gt; descrevendo o arquivo afetado e a instrução exata de &lt;code&gt;como_checar&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Adicione ao checklist do PR:&lt;/strong&gt; Coloque no template de Pull Request a pergunta: &lt;em&gt;"Este PR altera algum arquivo com regra cadastrada em &lt;code&gt;rules/&lt;/code&gt;?"&lt;/em&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;O maior valor de uma empresa de tecnologia não é o código que ela escreveu hoje, mas a capacidade de &lt;strong&gt;não repetir os erros que já custaram caro no passado&lt;/strong&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>codereview</category>
      <category>architecture</category>
      <category>braziliandevs</category>
    </item>
  </channel>
</rss>
