Agentes CLI: por que tanta gente sênior voltou a olhar para o terminal

Teve uma fase em que parecia resolvido. Cola um chat na IDE, pede um componente, o código aparece. A programação com IA tinha encontrado sua interface definitiva.
Funcionou muito bem. Até parar de funcionar.

A sidebar é boa. Até não ser.

Quando a tarefa é pequena, a sidebar resolve. Cria um componente, ajusta um teste, monta um script rápido. Funciona. O problema é que projeto real quase nunca quebra em pedacinhos tão organizados. Tem build, migração, git, logs, variáveis de ambiente, testes que precisam rodar em ordem específica, e um monte de contexto espalhado longe da janela do editor.
Foi por isso que o pessoal mais experiente começou a voltar pro terminal. Não por nostalgia. Por alcance.
Uma refatoração séria raramente é só "editar código". Normalmente envolve um ciclo:

mapear onde a mudança toca de verdade
inspecionar dependências
rodar testes, lint
comparar diffs
repetir quando quebra
No terminal, isso vira fluxo contínuo. O agente lê arquivo, busca referência, roda comando, vê resultado e ajusta a próxima ação. Na interface de chat da IDE, esse ciclo fica truncado. A sensação é de velocidade. A operação nem sempre acompanha.
Em 2026, a conversa deixou de ser "qual IA escreve melhor" e virou "qual ambiente deixa a IA trabalhar sem se perder".

O terminal virou o habitat natural do agente

Muita gente ainda fala de terminal como coisa manual, artesanal. E de agentes como se fossem algo separado. Na prática, o contrário está acontecendo: o terminal virou o lugar onde o agente consegue agir com menos atrito.
Ali moram as coisas que movem um projeto:

git diff, git status, git grep
scripts de teste e build
comandos de migração
linters e validadores
configuração do ambiente
Quando o agente opera perto dessas ferramentas, ele para de ser autocomplete glorificado. Começa a participar do ciclo real de engenharia.
O Claude Code e ferramentas como o OpenClaw já rodam com acesso direto ao shell. O dado que me chamou atenção: agentes CLI gastam até 5.5x menos tokens em tarefas complexas do que fluxos via GUI, porque não ficam reconstruindo contexto visual a cada iteração. Menos overhead de apresentação, mais contexto real do projeto.
Isso não significa autonomia cega. Só contexto melhor.

Não é "IDE perdeu" e "CLI venceu"

Esse tipo de simplificação atrapalha. O fluxo que faz sentido para muita gente está ficando híbrido:

IDE para leitura, edição rápida, feedback visual
terminal para tarefas longas, repetitivas ou com mais superfície de risco
humano decidindo quando pedir execução e quando pedir só diagnóstico
Esse último ponto é subestimado. Nem todo pedido para um agente deveria terminar em diff.
Às vezes o melhor uso é pedir que o agente mapeie o impacto antes de alterar arquivo. Listar hipóteses para um bug. Propor um plano de refatoração. Apontar quais testes valem rodar primeiro.
Quem trata toda interação como se o agente precisasse gerar código desperdiça contexto e aumenta ruído. O ganho real aparece quando a IA é parte do fluxo, não botão de "fazer tudo".

O gargalo nunca foi digitação

Quando o agente sai da demo e entra no repositório de verdade, fica claro: o gargalo era governança.
Se o projeto não tem comando previsível, teste confiável, estrutura clara e algum limite de atuação, o agente não vira parceiro. Vira multiplicador de confusão.
Por isso práticas antigas voltaram a parecer urgentes:

testes como contrato
scripts claros para validação
documentação curta, mas honesta
módulos com fronteira menos ambígua
diffs menores e mais fáceis de revisar
Tem uma ironia boa aqui. Muita gente vendeu IA como a tecnologia que ia permitir pular disciplina de engenharia. O que eu vejo no dia a dia é o oposto: quanto mais agente no fluxo, mais caro fica um projeto bagunçado.
E essa ideia de "ferramenta certa na camada certa" aparece em lugares inesperados. Outro dia fui olhar o changelog de um projeto que remove marcas d'água do Gemini, o Removedor de Marca d'água do Gemini Online. A v1 usava OpenCV com template matching para localizar o logo e fazer inpainting. A v2 trocou para um modelo neural LaMa rodando via ONNX Runtime no navegador — funcionava, mas pesava 200MB e levava mais de 30 segundos por imagem. Na v3, descartaram o modelo de IA e implementaram reverse alpha blending: matemática pura, milissegundos de processamento, 2MB no total. A solução determinística ganhou. Nem tudo precisa de rede neural. Às vezes o algoritmo certo resolve mais rápido e com menos surpresas do que jogar um modelo gigante no problema.

Token, repetição e custo invisível

Custo operacional é outro ponto que aparece forte quando o agente sai do sandbox.
Quando você usa um agente com liberdade para explorar código, rodar comando e tentar de novo, o consumo deixa de ser abstrato. Cada loop mal definido gasta contexto, tempo e dinheiro sem produzir avanço proporcional.
O caso da Uber virou referência: esgotaram o orçamento anual de tokens de IA em quatro meses, com 70% do código commitado via Claude Code. O "vibe coding" sem controle de custos virou o novo vazamento de memória.
A conversa de FinOps saiu da infraestrutura e encostou no dia a dia de desenvolvimento. Não precisa transformar o time numa planilha, mas já faz sentido pensar em:

quais tarefas merecem um agente mais caro
quando vale interromper um loop exploratório
quais comandos reduzem tentativa e erro
como evitar pedir três vezes a mesma investigação com palavras diferentes
Prompt ruim sempre custou caro. Agora workflow ruim custa mais.

O que muda no dia a dia

Na prática, o dev sênior está ficando menos parecido com um operador de teclado e mais com alguém que monta o ambiente onde o trabalho acontece.
Isso inclui decidir:

qual contexto o agente precisa para não sair quebrando borda
qual comando dá resposta confiável
que parte do trabalho pode ser delegada
onde a revisão humana é obrigatória
A vantagem não está em conversar com a IA de um jeito místico. Está em montar um sistema de trabalho onde ela acerta mais e atrapalha menos. E esse sistema quase sempre passa pelo terminal, porque é ali que o projeto mostra como realmente funciona.

Um ajuste prático para esta semana

Se você já usa IA para programar e quer testar essa virada sem reinventar tudo:

Escolha uma tarefa chata, mas delimitada.
Defina antes quais comandos validam a mudança.
Peça primeiro um plano curto, não implementação direta.
Só depois deixe o agente executar no terminal.
Revise o diff como engenheiro, não como torcida.
Parece detalhe, mas muda a qualidade da interação.

Fechando

O terminal não voltou porque dev sênior gosta de sofrer. Voltou porque agentes funcionam melhor quando conseguem tocar as ferramentas reais do projeto.
A IDE continua importante. O chat continua útil. Para trabalho pesado, a interface mais valiosa é a que dá acesso ao sistema inteiro.
O próximo salto não vem de colocar mais uma aba no editor. Vem de montar um fluxo onde o agente investiga, executa, valida e para quando precisa parar.
Se você ainda usa IA só como autocomplete turbinado, talvez esteja vendo só a camada de cima.