A morte da IDE?

• O centro do trabalho do desenvolvedor está migrando da edição de código linha a linha na IDE para interfaces de orquestração e supervisão de agentes, e várias ferramentas como Cursor Glass, Claude Code Web e GitHub Copilot Agent estão acelerando essa transição
• O novo loop de desenvolvimento assume a forma de "especificação da intenção → delegação → observação → revisão de diff → merge", em que o agente, e não o arquivo, é a unidade central de trabalho
• Padrões como isolamento de tarefas (git worktree), gerenciamento de estado de tarefas, execução assíncrona em segundo plano e roteamento de atenção para execução paralela de agentes estão convergindo em várias ferramentas
• A fadiga de revisão e a sobrecarga de segurança e governança estão surgindo como novos custos quando os agentes acertam 90% e erram de forma sutil
• A IDE não está desaparecendo, mas sim sendo descentralizada (de-centered): continua essencial para inspeção detalhada, depuração e trabalhos de alta complexidade, mas já não é o único lugar onde a programação começa

---

Da edição de arquivos ao controle do fluxo de trabalho

• As IDEs tradicionais eram otimizadas para o loop interno apertado de abrir arquivo → editar → compilar → depurar → repetir, mas, à medida que os agentes passaram a executar de forma autônoma a maior parte desse loop, elas deixaram de ser a unidade dominante de produtividade
• O novo loop assume a forma de "especificação da intenção → delegação → observação → revisão de diff → merge", e o que o diferencia de um "autocompletar com janela de chat" é a combinação entre autonomia no uso de ferramentas e interfaces que tornam essa autonomia controlável
• Claude Code Web (ou Desktop) e Codex recebem tarefas claramente definidas para agentes executados em ambientes de nuvem isolados, com progresso visível no navegador — sem necessidade de terminal ou configuração local
• O GitHub Copilot Agent planeja e implementa mudanças em múltiplos arquivos de forma independente, além de criar branches, executar testes e enviar PRs; o principal papel do desenvolvedor passa a ser revisar os resultados e iterar
• Conductor é um app desktop que executa vários agentes do Claude Code simultaneamente em workspaces isolados, oferecendo monitoramento ao vivo do progresso
• Google Jules lida com trabalho assíncrono em segundo plano — você atribui a tarefa e revisa o resultado quando ela termina
• O modelo mental compartilhado por essas ferramentas: o agente é a unidade de trabalho, não o arquivo — a interface a ser otimizada não é a de digitar mais rápido, mas a de instruir, monitorar e revisar agentes

A camada de orquestração em formação

• O isolamento de trabalho (Work Isolation) está se consolidando como primitivo básico: agentes paralelos não podem colidir entre si, então quase todas as principais ferramentas adotam git worktree (ou abordagem semelhante) — o Conductor mapeia cada sessão de agente para um workspace isolado, e o Vibe Kanban aplica o mesmo método a fluxos de trabalho com agentes baseados em kanban
• Planejamento e estado das tarefas viram a UI principal: ferramentas como o Vibe Kanban substituem "abas e arquivos" por "tarefas e estados" — você cria cartões de tarefa (landing page, serviço de backend, integração de e-mail etc.), atribui cada um a um agente e a um modelo, e gerencia tudo como um board de projeto leve, enquanto a "equipe" executa de forma autônoma
• Agentes em segundo plano e design assíncrono por padrão: Cursor, Copilot, Antigravity e outros oferecem suporte a agentes em segundo plano que operam sem participação do usuário durante a execução — você define a intenção, sai da frente e revisa ao final; Jules funciona da mesma forma, partindo da premissa de que a atenção do usuário é valiosa demais para ficar olhando uma barra de progresso
• Gerenciamento de atenção para agentes paralelos: quando vários agentes rodam ao mesmo tempo, o verdadeiro gargalo é identificar qual deles precisa de intervenção naquele momento — o Conductor mostra o progresso ao vivo entre sessões, e o cmux introduz anéis de notificação e badges de não lido nos painéis do terminal — "o agente precisa de atenção" está surgindo como um evento de primeira classe (first-class event) no ambiente de desenvolvimento
• Agentes embutidos no ciclo de vida do software: o agente de programação do GitHub Copilot é assíncrono e garante segurança por meio de uma camada de controle, operando sobre GitHub Actions — ele se conecta não ao modo como o código é escrito, mas ao modo como o código é realmente entregue (issue → PR → CI → merge)
• Essas ferramentas não afirmam que a IDE é inútil, e muitas delas interoperam com IDEs, mas o padrão recorrente — workspaces paralelos, revisão centrada em diff, estado de tarefas, execução em segundo plano e integração ao ciclo de vida — é justamente o deslocamento do centro de gravidade ao qual se refere a tese da "morte da IDE"

Por que os desenvolvedores ainda recorrem à IDE

• O contra-argumento mais forte à ideia de que a "IDE morreu": a IDE condensa problemas difíceis como navegação precisa, raciocínio local, depuração interativa e compreensão do sistema por manipulação direta em um único loop de feedback de alta fidelidade
• Mesmo as ferramentas de orquestração mais ambiciosas mantêm uma saída para edição manual — revisar diffs dentro da thread, comentar alterações e depois ajustar manualmente no editor faz parte do fluxo de trabalho intencional
• Há áreas em que as próprias ferramentas de agentes expõem seus limites: refatoração multi-arquivo em repositórios grandes continua sendo um dos desafios mais difíceis para agentes de engenharia de software — são situações que exigem um modelo mental do sistema que o agente não consegue reconstruir totalmente apenas com contexto
• O modo de falha que ainda prende os desenvolvedores ao nível de inspeção da IDE: quando o agente acerta 90% e erra de forma sutil — com frequência, o custo de encontrar o problema supera o custo de escrever diretamente, e, em mudanças de alto risco, a IDE continua sendo a melhor ferramenta para inspeção minuciosa

Novo custo: fadiga de revisão e sobrecarga de governança

• Quando o desenvolvimento vira "vários agentes em execução paralela", o fluxo de trabalho herda problemas de gestão de sistemas distribuídos em vez de edição de texto — observabilidade, permissões, isolamento e governança
• Fluxos de trabalho com agentes invertem o trabalho: em vez de escrever código, a revisão se torna o centro, e encarar 12 diffs de 12 agentes paralelos no fim do dia vira um problema real de fadiga de revisão — daí o foco das ferramentas mais cuidadosas em roteamento de atenção, planos estruturados e gates de revisão em primeiro lugar
• À medida que os agentes ganham acesso a mais ferramentas — navegação na web, consultas a banco de dados, escrita no sistema de arquivos, gatilhos de deploy — a superfície de segurança se expande; tão importante quanto o que o agente pode fazer é o que ele tem permissão para fazer
• Em termos de observabilidade e controle, os modos de agente integrados à IDE já estão evoluindo na direção de logs explícitos de ferramentas e gates de aprovação — no momento em que o agente passa a operar de forma assíncrona e mexe em pipelines de CI, governança deixa de ser opcional e se torna obrigatória

O que sobrevive: IDE, plano de controle ou ambos

• A "morte da IDE" está correta como direção do centro de gravidade, mas errada como previsão literal
• A versão mais forte da tese: a IDE recua do papel de espaço principal de trabalho e se torna uma entre várias ferramentas subordinadas — usada para inspeção minuciosa, depuração e edição final, enquanto planejamento, orquestração, revisão e gerenciamento de agentes migram para dashboards, issue trackers, terminais de observabilidade e planos de controle na nuvem
• O enquadramento de uma "IDE maior" também tem fundamento: a nova "IDE" é um sistema que oferece orquestração multiagente, workspaces isolados, permissões e logs de auditoria, revisão centrada em diff, conectividade estável com ferramentas e roteamento de atenção — o editor de arquivos continua existindo, mas já não é a porta de entrada (front door)
• A IDE não morre; ela é descentralizada (de-centered) — o trabalho migra para superfícies de orquestração, e os humanos passam mais tempo definindo intenções, delegando a runtimes paralelos de agentes e fazendo supervisão, revisão e governança
• A IDE continua central para precisão, compreensão e problemas de alta complexidade que os agentes ainda têm dificuldade em resolver, mas já não é o único lugar onde a programação acontece e, para cada vez mais desenvolvedores, também não é mais o primeiro lugar para onde vão