Até onde ainda precisamos de IDE?

Até agosto deste ano, meu jeito de trabalhar com agente de IA tinha uma regra que eu nunca escrevi em lugar nenhum, mas seguia à risca: um VS Code por projeto. Cada janela com o Claude Code rodando no terminal integrado, e eu do lado, olhando os arquivos modificados, de vez em quando pedindo uma alteração específica num deles e validando cada mudança (ou quase todas).

Em dia cheio eram várias janelas abertas ao mesmo tempo. E o que me fez mudar não foi nenhuma reflexão sobre o futuro da programação. Foi bem mais sem graça: eu passava boa parte do tempo alternando entre elas só para descobrir qual tarefa já tinha terminado. Uma podia estar esperando uma resposta minha, outra ainda rodando, outra parada num erro. A ferramenta que deveria me ajudar a acompanhar o trabalho tinha virado o lugar onde a minha atenção travava.

Eu queria ver tudo

Insisti nesse formato por bastante tempo, e sabia o motivo. Eu queria ver o código. Todo ele.

O editor sempre foi o meu lugar de entender software, mesmo antes de ser uma IDE de verdade. Comecei no bloco de notas, na época em que programava PIC (um microcontrolador), depois passei pelo Code::Blocks e por vários outros até chegar no PyCharm, o primeiro em que eu conseguia dar um Ctrl+clique e entrar nas classes das bibliotecas para ver como elas funcionavam por dentro. E finalmente o VS Code, onde eu revisava os commits pelo GitLens: o diff, o histórico do arquivo, quem mexeu naquela linha e quando. Era ali que eu me sentia seguro para dizer que uma mudança estava certa.

Largar isso me dava um receio concreto: deixar de ver todo o código que entrava no projeto. Demorei para entender que o medo não era de perder a ferramenta. Era de deixar de ser responsável pelo que vai para o repositório. É o mesmo motivo pelo qual não gosto de ver todos os commits de um projeto assinados por um agente como coautor, como contei quando falei de combinados com a IA. Ver o código, para mim, era a forma de assumir o que estava ali.

A revisão mudou de lugar

Hoje uso o app do Claude Code, com vários projetos no mesmo lugar. Vejo o que cada agente está fazendo, o que terminou e o que está parado esperando por mim, sem caçar janela.

A revisão não sumiu. Ela mudou de lugar e ganhou duas camadas. Primeiro eu leio os commits no próprio app, logo depois que o agente termina. Depois, no GitHub, reviso as PRs do time, como sempre fiz.

Não vou fingir que é a mesma coisa. Ler um diff por entrega não é o mesmo que ter o arquivo inteiro aberto, com o histórico e o blame do lado. Perco parte do contexto em volta do trecho alterado, e às vezes leio a mudança confiando que o resto do arquivo continua como eu lembrava. Em troca, acompanho mais projetos sem me perder, e a atenção vai para a decisão em vez de ir para a troca de janela. Ainda não sei direito quanto essa troca me custa.

Onde o VS Code continua

Não desinstalei nada. O VS Code continua aberto em alguns tipos de trabalho, e eles dizem bastante sobre o papel que sobrou para a IDE.

O primeiro é hardware. Quando vou brincar com Arduino, quero a placa conectada, a porta serial, o monitor mostrando o que está acontecendo. Programei muito Arduino, dando aula e por curiosidade, e o ciclo de gravar na placa e ver acontecer na hora é metade da graça. Código que encosta no mundo físico ainda pede a mão na massa.

O segundo é a tarefa muito simples, aquela em que eu mesmo começo escrevendo. Às vezes explicar o que eu quero dá mais trabalho do que fazer, e o pensamento sai mais rápido digitando do que pedindo.

O terceiro são os projetos que dependem de debugger e de ferramentas que só consigo usar com facilidade dentro do editor. Breakpoint, inspecionar variável, andar linha a linha. O agente é bom lendo log e propondo hipótese. Mas tem bug que só aparece quando você para o programa no meio e olha o estado com calma, e para isso a IDE ainda é o melhor lugar que eu conheço.

Nos três casos, quase não estou usando a IDE para escrever. Estou usando para olhar, para tocar e para investigar.

Para onde isso vai

Até onde ainda precisamos de IDE? Para escrever código, cada vez menos. Para entender, depurar e mexer com o mundo físico, para mim ainda faz sentido, e é confortável, abrir a IDE.

O papel dela hoje, pelo menos para mim, não é de escritório, é de bancada. Não é onde passo o dia. É onde vou quando preciso pôr a mão em alguma coisa específica, e depois volto.

Para onde isso vai, eu tenho um palpite, em degraus. O público em geral sequer vai ver código. Para quem só usa o software, tanto faz se ele foi escrito numa IDE ou não. Nós, engenheiros de software, vamos ter cada vez mais ferramentas dentro de apps como o próprio Claude Code: os terminais rodando, os serviços no ar, os agentes e subagentes trabalhando, a comparação de código. Não é o agente indo morar dentro da IDE. É a IDE indo morar dentro do app do agente, aos pedaços.

E talvez chegue um momento em que nem isso seja necessário. Não sei quando, nem se chega. A pergunta que me segura nesse degrau é outra: quando der errado, quem vai abrir o debugger? E onde essa pessoa aprendeu a usar um? É a mesma dúvida de quando me perguntei quem vai formar o próximo sênior, só que vista pela ferramenta.

De onde eu estou falando

Vale dizer de onde vem essa visão. Hoje passo menos tempo codando do que já passei, e a maior parte do meu trabalho com código é revisar e decidir. Para quem passa o dia inteiro dentro de uma base só, a IDE talvez continue sendo o centro, e faz sentido que seja.

Para quem está começando, acho que ela é mais importante do que nunca. É lá que se aprende a ler o código dos outros e a depurar, e nenhum agente faz isso por você se você não souber o que está olhando.

Passei muito tempo insistindo que precisava ver tudo. Talvez eu estivesse certo, talvez fosse só costume. Hoje acho que a pergunta não é se a IDE vai sumir. É o que a gente ainda vai querer ver com os próprios olhos, e por quanto tempo vai saber fazer isso.