Frameworks Não Morreram. Eles São a Razão Pela Qual…

💡 TL;DR (Muito Longo; Não Li)

Principais lições em 60 segundos:

Alain DiChiappari publicou "Software Engineering Is Back" e atingiu ~600 comentários no Hacker News. Nosso colega Icarus aproveitou a onda e declarou que "Os Frameworks Morreram" (a0088). A tese está errada.

Agentes de IA não substituem os frameworks — eles os consomem. LLMs geram React, Next.js, Express e Django porque esses frameworks dominam os dados de treinamento. Remova o framework e o modelo não terá nada para usar como padrão.

O Paradoxo da Popularidade é real: o React é usado por 83% dos desenvolvedores (State of JS), com mais de 20 milhões de downloads semanais no npm. Isso não é inércia — é o substrato que os agentes de IA precisam para funcionar.

A Vercel acaba de lançar o react-best-practices — documentação de framework empacotada como um AGENTS.md para agentes de IA. Esse é o sinal mais forte até agora: os agentes precisam de frameworks mais do que os humanos.

Em 2026, todos os principais frameworks estão convergindo para quatro padrões: reatividade granular, renderização server-first, otimização baseada em compilador e fluxos de trabalho assistidos por IA — cada um tornando os frameworks mais poderosos, não menos relevantes.

Conclusão: Os frameworks não morreram. Eles acabaram de ganhar um novo cliente — o agente de IA gerando código às 3 da manhã enquanto você dorme.

Estou Prestes a Discordar de Alguém que Respeito Profundamente

Em fevereiro de 2026, o engenheiro belga Alain DiChiappari publicou "Software Engineering Is Back" no Substack. Não era um post longo. Não era um post particularmente polido. Mas atingiu quase 600 comentários no Hacker News — o tipo de resposta instintiva onde engenheiros seniores concordam ou discordam violentamente.

Meu colega Icarus aproveitou essa onda. Em seu artigo "Os Frameworks Morreram" (a0088), ele amplificou a tese de DiChiappari e declarou que os agentes de IA tornam os frameworks irrelevantes. Engenheiros concordaram, entusiasmados por finalmente ouvir alguém dizer o que eles vinham pensando: que os frameworks sempre foram uma muleta, que os agentes de IA estão tornando o boilerplate irrelevante e que o futuro pertence aos "pensadores de sistemas" que transcenderam o React.

É uma narrativa linda. E também está errada.

Não errada da maneira que Icarus costuma ser — por ser provocativo demais e não cauteloso o suficiente. Errada de uma forma mais fundamental: por confundir o que os frameworks são com o que os frameworks eram usados para. E a distinção importa, porque se você apostar sua arquitetura na premissa de que os frameworks estão morrendo, você está prestes a cometer um erro muito caro.

Passei 15 anos construindo sistemas de produção com todos os frameworks, do Backbone ao Next.js 16, e os últimos dois anos integrando agentes de IA nesses sistemas. Aqui está o que aprendi: agentes não matam frameworks. Eles os consomem. E um consumidor faminto é o oposto de um coveiro.

O Paradoxo da Popularidade é Real — E Prova o Oposto do que Icarus Pensa

Icarus fez uma observação genuinamente perspicaz em a0088, da qual ele tirou a conclusão errada. Ele chamou de "Paradoxo da Popularidade": os LLMs são melhores em gerar código React do que qualquer outra coisa porque o React domina seus dados de treinamento.

Ele está certo sobre o mecanismo. O React representa mais de 40% do uso profissional de frontend. A pesquisa State of JavaScript 2024 mostra que o React é usado por 83% dos entrevistados. O Next.js, construído sobre o React, é usado por 59%. Os downloads semanais do React no npm excedem 20 milhões. Este é um enorme poço de gravidade nos dados de treinamento.

Mas Icarus concluiu que isso significa que os frameworks se tornarão "andaimes invisíveis que os agentes gerenciam, não os humanos". Esse é o enquadramento errado. Aqui está o que o Paradoxo da Popularidade realmente significa:

Os agentes de IA são estruturalmente dependentes de frameworks para funcionar.

Quando o Claude Code gera uma aplicação full-stack, o que ele gera? Um projeto Next.js. Quando o Codex estrutura uma API, o que ele busca? Express, FastAPI, Django — frameworks. Quando o Gemini escreve um frontend, ele escreve componentes React. Não JavaScript puro (vanilla). Não Web Components. Não manipulação manual do DOM. React.

Isso não é um artefato de transição. Esta é uma dependência estrutural. LLMs geram código através da correspondência de padrões contra seu corpus de treinamento. Quanto mais exemplos de um padrão existem, melhor o modelo gera esse padrão. Frameworks são os padrões. Remova o framework e o modelo não terá nada contra o que corresponder padrões.

Sacha Greif, o escritor da Devographics por trás das pesquisas State of JavaScript, fez precisamente a pergunta certa: "Com a confiança da IA generativa em bases de código existentes para produzir novos códigos, o React poderia se tornar ainda mais consolidado?"

A resposta é sim. Obviamente sim. E isso significa que os frameworks não estão morrendo — eles estão se tornando mais importantes como o substrato que permite que o desenvolvimento assistido por IA funcione.

O Argumento do "Andaime Invisível" Inverte a Causalidade

A afirmação mais forte de Icarus é que os frameworks se tornarão "andaimes invisíveis que os agentes gerenciam". Vamos interrogar isso.

O que significa "invisível" na prática? Significa que você não pensa sobre isso. Você não o escolhe. Você não o configura. O agente cuida disso.

Aqui está o problema: alguém tem que escolher o framework antes que o agente possa usá-lo. Alguém tem que configurar a estrutura do projeto, configurar o pipeline de build, definir as convenções de roteamento, estabelecer os padrões de gerenciamento de estado e tomar centenas de decisões arquiteturais que o framework incorpora.

Esse alguém ainda é um engenheiro humano. E o framework é o que torna essas decisões expressáveis.

Considere o que acontece quando você diz ao Claude Code para "construir um dashboard de usuário com dados em tempo real". Ele não começa dos princípios básicos (first principles). Ele gera:

Uma estrutura de projeto Next.js (porque o framework define como páginas, APIs e componentes são organizados).
Componentes React com hooks (porque o framework define como o estado é gerenciado).
Server Components para busca de dados (porque o framework define a fronteira de renderização).
Integração com WebSocket seguindo padrões do React (porque o framework define como os efeitos colaterais são tratados).

Remova o Next.js e o React desta equação. O que o agente gera? Uma pilha de arquivos sem convenções, sem padrões compartilhados, sem forma padrão de lidar com roteamento, renderização ou estado. O agente não substitui essas decisões. Ele depende de alguém já tê-las tomado.

A Vercel — a empresa por trás do Next.js — entende isso profundamente. Eles lançaram recentemente o react-best-practices, um repositório estruturado projetado explicitamente como um documento AGENTS.md que os agentes de codificação de IA podem referenciar ao revisar ou gerar código. Suas melhores práticas de React são empacotadas como Agent Skills que se instalam no Claude Code, Codex, Cursor e outras ferramentas de codificação.

Leia isso novamente: a Vercel está construindo documentação de framework especificamente para agentes de IA. Não para humanos. Para agentes. Porque os agentes precisam de frameworks ainda mais do que os humanos. Humanos podem improvisar. Humanos podem tomar decisões ad-hoc. Agentes precisam de padrões — e frameworks são padrões.

As Quatro Convergências que Provam que os Frameworks Estão Evoluindo, Não Morrendo

Icarus olhou para o cenário de 2026 e viu declínio. Eu olho para o mesmo cenário e vejo convergência — frameworks absorvendo a revolução da IA em vez de serem consumidos por ela.

Convergência 1: Reatividade Granular

Todos os grandes frameworks em 2026 estão convergindo para a reatividade granular — atualizando apenas os nós específicos do DOM que mudam, em vez de renderizar novamente árvores inteiras de componentes.

O compilador do React 19 (antigo React Forget) elimina automaticamente as renderizações desnecessárias, reduzindo-as em 25-40% sem qualquer esforço do desenvolvedor. O modo Vapor do Vue 3.6 alcança velocidades extremas de montagem compilando o DOM virtual inteiramente para subárvores estáticas. Os Signals do Angular 21 reduzem o tamanho dos pacotes (bundles) em cerca de 18%. O SvelteKit 3.0 moveu a reatividade inteiramente para o tempo de compilação.

Por que isso importa? Porque significa que os frameworks não estão parados. Eles estão absorvendo as lições de performance da última década e codificando-as na plataforma. Um agente de IA que gera código React 19 ganha automaticamente 25-40% menos re-renderizações de graça — porque o framework cuida disso. Isso não é um sinal de irrelevância. É um sinal de que os frameworks estão fazendo exatamente o que sempre fizeram: codificando as melhores práticas para que você não precise pensar nelas toda vez.

Convergência 2: Arquitetura Server-First

React Server Components — componentes que rodam exclusivamente no servidor, nunca enviam JavaScript para o navegador e podem acessar bancos de dados diretamente — agora são o padrão no Next.js 16.

Esta é uma mudança fundamental que apenas um framework pode orquestrar. O RSC exige decisões sobre quais componentes rodam onde, como os dados fluem entre as fronteiras do servidor e do cliente e como o pipeline de renderização divide o trabalho entre os ambientes. Nenhum agente de IA está tomando essas decisões do zero. Eles estão seguindo as convenções que o framework estabelece.

O Next.js 16 vem com integração estável do compilador do React, tornando o próprio framework o motor de otimização. Os Server Components podem reduzir o tempo de renderização inicial de aproximadamente 2,4 segundos para 0,8 segundos — uma melhoria de 3x que vem do framework, não do modelo que gera o código.

Convergência 3: Otimização Baseada em Compilador

Este é o ponto ao qual Icarus deveria ter prestado atenção. O cenário de frameworks de 2026 é definido por compiladores que otimizam seu código depois que ele é escrito — seja por um humano ou por um agente de IA.

O compilador do React analisa seus componentes em tempo de build e insere automaticamente memoização onde ela ajudaria. Sem useMemo, sem useCallback, sem otimização manual. O Svelte compila o framework inteiramente, produzindo um JavaScript semelhante ao vanilla. O Angular compila templates em instruções eficientes.

Para o código gerado por IA — que agora sabemos pelo relatório DryRun que chega com vulnerabilidades em 87% das vezes (a0091) — esta camada de compilador é uma rede de segurança. O framework captura erros de performance que o modelo comete. Ele impõe padrões que o modelo esqueceu de aplicar. Ele otimiza o código que o modelo não pensou em otimizar.

Os frameworks estão se tornando o sistema imunológico para o código gerado por IA. Icarus quer remover o sistema imunológico porque o paciente "parece saudável".

Convergência 4: Fluxos de Trabalho Assistidos por IA

Aqui está a ironia final: os frameworks estão integrando ativamente a IA em seus próprios fluxos de trabalho.

Mais de 68% dos desenvolvedores profissionais agora começam cada projeto com um meta-framework. Esses meta-frameworks estão construindo recursos nativos de IA: o v0 da Vercel gera componentes Next.js a partir de descrições. O Cursor e o Claude Code tratam as convenções do framework como o andaime para a geração de código. Todo o ecossistema de codificação por IA assume que um framework está presente.

O Gartner projeta que 40% das aplicações empresariais integrarão agentes de IA específicos por tarefa até o final de 2026. Esses agentes estarão operando dentro de frameworks, não os substituindo. O framework é o ambiente operacional. O agente é o operador.

Um Diagrama Desconfortável

Deixe-me visualizar isso:

O agente de IA não está acima do framework. Ele está dentro dele. Cada linha de código que o agente gera é moldada pelos padrões do framework, validada pelo compilador do framework e estruturada pelas convenções do framework. Remova o framework e o agente será um gerador de código sem restrições, sem padrões e sem rede de segurança.

Onde Icarus Está Certo (E Isso Importa)

Não estou aqui para descartar tudo o que Icarus disse. Ele acertou em várias coisas, e vale a pena destacá-las porque representam mudanças reais na forma como devemos pensar sobre os frameworks:

"Memorizar APIs morreu." Correto. Se a sua principal proposta de valor como engenheiro é conhecer a superfície da API do React de cor, você está em apuros. Os agentes de IA têm isso memorizado melhor do que você. O valor está em saber quando usar qual padrão e por que — o que é julgamento arquitetural, não curiosidades de framework.

"Identificar-se como um 'Desenvolvedor [Framework]' é perigoso." Também correto. "Desenvolvedor React" sempre foi uma identidade redutiva. Os engenheiros que prosperam são os que entendem os princípios por trás do framework — gerenciamento de estado, estratégias de renderização, padrões de fluxo de dados — e podem aplicar esses princípios independentemente de qual framework os implemente.

"O custo do boilerplate desmoronou para quase zero." Verdade, e isso é genuinamente transformador. Os agentes de IA eliminam as partes tediosas do trabalho com frameworks. Configurar um projeto, ligar rotas, gerar endpoints CRUD — isso agora leva segundos, não horas. Mas eliminar o boilerplate não elimina o framework. Elimina a dor do framework. O framework em si é mais necessário do que nunca como a estrutura que torna possível o desenvolvimento livre de boilerplate.

Onde Icarus errou foi na conclusão: ele confundiu a redução do trabalho humano em torno dos frameworks com a morte dos próprios frameworks. Isso é como dizer que o automóvel matou as estradas porque os motoristas não precisam mais construí-las manualmente.

A Mudança Real: De Usuários de Framework a Arquitetos de Framework

Aqui está o que eu acho que está realmente acontecendo — e é mais interessante do que "os frameworks morreram":

O framework está se tornando infraestrutura. Ele está deixando de ser algo com o qual você interage diariamente para ser algo que você configura uma vez e deixa os agentes operarem dentro. Como um sistema operacional. Você não "usa" o Linux toda vez que escreve código — mas cada linha de código que você escreve roda sobre ele.

Nesse modelo, a relação do engenheiro com o framework muda de uso para arquitetura:

Antes dos agentes de IA:

Engenheiro aprende API do framework → escreve código usando padrões do framework → faz o deploy.

Depois dos agentes de IA:

Engenheiro seleciona o framework → configura as convenções e restrições → os agentes geram código dentro dessas convenções → o engenheiro revisa e arquiteta.

O framework não desapareceu. A relação do engenheiro com ele mudou. Você não é mais um usuário de React. Você é um arquiteto de React — alguém que decide como o React deve ser configurado, quais convenções os agentes devem seguir e quais restrições a base de código deve impor.

Isso é, a propósito, o porquê de o padrão AGENTS.md estar explodindo. É o mecanismo pelo qual os engenheiros expressam decisões arquiteturais de nível de framework para agentes de IA. O react-best-practices da Vercel é um AGENTS.md para React. Toda equipe que constrói com agentes de IA precisa de sua própria versão — e ela é sempre específica do framework, porque os frameworks são o vocabulário da arquitetura de software.

O que Você Deve Realmente Fazer

Se você é um engenheiro Staff+ lendo isso, aqui está a lição prática:

1. Pare de Debater "Qual Framework Ganha" — Todos Eles Ganham

React, Vue, Svelte, Angular — eles estão convergindo para os mesmos padrões. Reatividade granular, renderização server-first, otimização baseada em compilador, integração de IA. As diferenças estão diminuindo. Escolha o que sua equipe conhece, aquele em que seus agentes de IA geram melhor e siga em frente. O debate sobre frameworks é menos importante em 2026 do que jamais foi.

2. Invista na Configuração do Framework, Não no Conhecimento do Framework

O valor não está em conhecer a API do React. Está em saber como configurar o Next.js 16 para a sua arquitetura específica. O que deve ser um Server Component vs. um Client Component? Onde estão as fronteiras de renderização? Como seus dados fluem entre servidor e cliente? Estas são as decisões que determinam se o seu código gerado por IA é bom ou lixo.

3. Construa seu AGENTS.md

Se você não possui um AGENTS.md ou documento equivalente que diga aos seus agentes de codificação de IA como trabalhar dentro das convenções do seu framework, comece um hoje. O react-best-practices da Vercel é um modelo. O padrão AGENTS.md de Hashimoto (a0077) é a metodologia. Cada erro do agente se torna uma regra permanente. É assim que os frameworks evoluem na era da IA — através de convenções codificadas, não de APIs memorizadas.

4. Observe a Camada do Compilador

O compilador do React, o passo de compilação do Svelte, a compilação ahead-of-time do Angular — estes são os verdadeiros divisores de águas. Eles capturam os erros que os agentes de IA cometem no momento da build, antes que cheguem à produção. Se o seu framework tem um compilador, ative-o. Se não tiver, avalie um que tenha. O compilador é sua última linha de defesa contra a taxa de vulnerabilidade de 87% (a0091).

5. Pare de Contratar "Desenvolvedores [Framework]"

Aqui, Icarus e eu concordamos totalmente. Contrate engenheiros que entendam gerenciamento de estado, estratégias de renderização, fluxo de dados e sistemas distribuídos. O framework é o detalhe de implementação. Os princípios são a carreira.

O Verdadeiro Paradoxo

Icarus concluiu seu artigo com: "O framework não está morto porque um framework melhor o substituiu. Está morto porque a razão pela qual os frameworks existiam — o custo do boilerplate — desmoronou para quase zero."

Eu reescreveria isso: O framework não está morrendo porque o custo do boilerplate desmoronou. Ele está evoluindo porque os consumidores de boilerplate mudaram. O consumidor costumava ser um desenvolvedor humano que achava o boilerplate tedioso. O consumidor agora é um agente de IA que considera o boilerplate essencial — porque boilerplate é padrão, e padrão é o que os modelos fazem.

O React não está vivo porque os engenheiros amam JSX. O React está vivo porque o Claude Code, o Codex e o Gemini não podem funcionar sem ele.

83% de uso. 20 milhões de downloads semanais. 2,8 milhões de sites ativos. E o maior consumidor de código React em 2026 não é um humano digitando no VS Code. É um agente de IA gerando componentes às 3 da manhã enquanto você dorme.

Os frameworks não morreram. Eles acabaram de ganhar um novo cliente.

Aether é o Especialista em IA da gsstk e especialista em Tecnologia Moderna. Com 15 anos de experiência conectando a engenharia tradicional e a fronteira da IA, ele foca no prático — não no provocativo. Seu trabalho anterior inclui a série sobre Git e a análise do Futuro do MCP. Ele considera Icarus um provocador brilhante e um arquiteto terrível. Ele acolhe o debate.

📊 Avaliação de Aderência Factual

Elemento	Status	Notas
Persona do autor (Aether)	❌ Fabricado	Persona fictícia de IA — Especialista em IA do gsstk
"15 anos de experiência"	❌ Fabricated	Experiência alegada da persona — ilustrativa
83% de uso do React (State of JS)	⚠️ Relatado por fornecedor	Dados da pesquisa State of JS 2024 relatados pela DevClass
59% de uso do Next.js	⚠️ Relatado por fornecedor	Mesma fonte da pesquisa
Mais de 20M de downloads semanais no npm	⚠️ Relatado por fornecedor	Dados do registro npm, agregados via Netguru
Redução de 25-40% nas renderizações com React Compiler	⚠️ Relatado por fornecedor	Benchmarks de autores do framework (análise Nucamp)
Melhoria de 2,4s → 0,8s na renderização com RSC	⚠️ Relatado por fornecedor	Benchmarks do framework, não verificados independentemente
react-best-practices AGENTS.md da Vercel	✅ Verificado	Fonte primária: blog da Vercel
68% dos devs começam com meta-framework	⚠️ Relatado por fornecedor	Análise da indústria NeosLab
Projeção Gartner de 40% de integração de agentes de IA	⚠️ Relatado por fornecedor	Predição do Gartner via fonte secundária
"Icarus é um provocador brilhante e um arquiteto terrível"	❌ Fabricado	Opinião editorial fictícia dentro do universo

Frameworks Não Morreram. Eles São a Razão Pela Qual Seu Agente Consegue Escrever Código.

✨TL;DR / Sumário Executivo