O post mais votado desta semana no Hacker News não é sobre um modelo novo. É sobre uma conta que ninguém tinha feito direito ainda: escrever a primeira versão de uma feature hoje consome só 20% do esforço total de um projeto de código. Em 2025, essa mesma etapa consumia 80%. O resto virou onde o trabalho de verdade se esconde, e é exatamente aí que o argumento do post fica interessante pra quem usa agente de programação todo dia.
O que o post do HN realmente argumenta?
O texto é "2x, not 10x: coding with LLMs in 2026", de obryant.dev, e propõe o que o autor chama de hipótese da escada: "para subir uma escada você precisa ser alto o suficiente pra alcançar pelo menos um degrau por vez, mas ser tão alto que consegue subir dois ou três degraus de uma vez importa muito menos". Aplicado a modelo de IA, o argumento é que os LLMs já passaram do degrau que importava: ficaram confiáveis o bastante pra rodar em loop automático (escrever, testar, corrigir, testar de novo) sem travar toda hora. Depois desse ponto, um modelo mais esperto rende cada vez menos ganho na prática.
A consequência que o autor tira disso é direta: o ganho projetado pra 2026 é 2x, não 10x, porque modelo melhor resolve cada vez menos. O que resolve mais é reorganizar o fluxo de trabalho em volta do que o modelo já sabe fazer, com mais iteração em teste, estrutura e ambiente de execução.
"Uma implementação que funciona hoje representa só ~20% do trabalho de uma feature. Antes era 80%." O resto é código sustentável, revisão de estrutura, decisão de arquitetura, ou seja, exatamente o que um LLM ainda erra sozinho.
Por que essa conta muda quando alguém paga por token?
Aqui está o ângulo que o post não desenvolve, e que interessa direto pra quem programa no Brasil: se o ganho real está em retooling, e retooling significa rodar mais loop (escrever, testar, corrigir, testar de novo, repetir quantas vezes for preciso), então o fator que mais trava esse ganho não é a inteligência do modelo. É o medidor de uso.
Cada volta extra de um loop de correção é uma chamada nova ao modelo. Se cada chamada tem custo marginal, rodar o loop dez vezes custa dez vezes mais que rodar uma vez, e o desenvolvedor passa a decidir quando parar de iterar não pelo resultado, mas pelo saldo. É o oposto do que o próprio post recomenda: iterar mais, não menos, é o que sobra pra fazer quando modelo melhor já não ajuda tanto.
Como rodar esse loop sem parar pra fazer conta?
Na prática, o framework que o post sugere (retooling em cima do modelo atual) só funciona se o custo de cada rodada extra for previsível. No Verboo Code isso é resolvido de um jeito simples: assinatura fixa, sem cobrança por token, então o loop de escrever-testar-corrigir roda quantas vezes o problema exigir.
Trocar de modelo no meio da sessão, pra comparar quem resolve melhor um bug teimoso, é um comando só:
$ verboo
> /model
? Escolha o modelo:
qwen3.6-27b
deepseek-v4-flash
❯ deepseek-v4-pro
mimo-v2.5
...Sem CLI instalado ainda:
npm install -g @verboo/code@latest
verboo --versionNão tem cálculo de "vale a pena rodar mais uma vez" porque não existe medidor rodando no fundo da tela.
Outro post da mesma semana confirma o ponto, do jeito ruim
Enquanto o post do HN discutia teoria, outro experimento mostrava a prática dando errado. A Bottleneck Labs deu autonomia total a um agente batizado de Saul, rodando em GPT-5.6 Sol, pra tocar um app real (o GutCheck, um diário de sintomas pra portador de SII) por 24 horas. Resultado: de 61 usuários e US$ 350 em caixa pra 66 usuários e US$ 250,50, sem gerar um dólar de receita.
No caminho, o agente comprou 50 usuários falsos de teste por US$ 99,50, disparou email em massa pros usuários reais e baixou o preço seis vezes em doze horas até zerar. Os pesquisadores registraram algo que confirma a hipótese da escada: o modelo era "surpreendentemente bom em entender o contexto da base de código" e tinha "resiliência notável diante de bloqueios", mesmo quando a decisão certa era parar. O gargalo não foi capacidade técnica. Foi falta de um loop de verificação em volta do agente que corrigisse a rota antes do preço ir a zero.
É o mesmo ponto do texto original, só que sem rede de proteção: modelo forte sem retooling ao redor não gera 2x nem 10x, gera prejuízo.
O que fica pra quem programa com IA no Brasil
O debate sobre 2x contra 10x é legítimo, mas a parte que ninguém tá discutindo é quem paga a conta de fazer o retooling direito. Enquanto o mercado segue fundindo produto e medidor de uso pra empurrar plano mais caro, a alternativa mais simples continua sendo tirar o medidor da equação. O Verboo Code já roda assim: 165 devs pagantes, R$ 86 mil em receita acumulada, modelos open source como deepseek-v4-flash e mimo-v2.5 em GPU dedicada, sem cobrar por token.
Enquanto o mercado discute se o ganho é 2x ou 10x, a Verboo Code já entrega tokens ilimitados em agente de programação, pra quem quer gastar esse ganho testando de novo, não fazendo conta. Conheça.
