About three months ago, I saw a post on X claiming that AI has ended framework wars. The more I thought about it, the more I realised the opposite is true.
If AI truly ended framework innovation, it would be a disadvantage to software engineering.
AI has made it easier for developers to experiment with different tools and ecosystems. Today, switching between React, Vue, Svelte, Laravel, Django, or Solid is easier than ever because AI reduces the friction of learning syntax and boilerplate but framework wars were never really about syntax.
Frameworks are structured systems of abstractions, conventions, rendering models, state management patterns, and architectural decisions. They exist because software complexity keeps increasing.
AI adds to that complexity. It can generate components, scaffold APIs, and suggest implementations but it cannot replace the architectural guarantees frameworks provide. Once applications become stateful, distributed, asynchronous, and context-heavy, structure becomes more important than code generation itself.
The real competition between frameworks is no longer about developer experience alone. It is about which abstractions can support emerging problems such as AI orchestration, shared client-server context, asynchronous rendering, concurrent interactions, browser-native agents, speech synthesis and streaming interfaces.
Let's examine some of the emerging problems one by one.
Client-server unification
One of the oldest problems in web development is the separation between the client and the server.
Even today, most frameworks still treat them as different environments with different execution models, different contexts, and different rendering pipelines.
React, Vue, Svelte, Solid, and others attempt to bridge this gap but the boundary still exists. They all force you to fetch on one side and synchronise it response on another, leading to context duplication.
AI applications rely heavily on context like conversation history, memory, tool state, user intent, streaming data, orchestration state, and agent coordination. Yet we are forced to duplicate and manage all of those complexity on the client and the server.
The web needs frameworks capable of treating the client and server as a continuous execution environment instead of two disconnected worlds communicating through fragile synchronization patterns. This is not something AI solves automatically. It is a framework problem.
Asynchronous Rendering
Existing approaches to asynchronous rendering still struggle with AI-native orchestration patterns.
Many frameworks support asynchronous data fetching and partial interactivity, but true asynchronous rendering, where rendering itself behaves as a first-class asynchronous process, remains limited and it is extremely important in the AI era because AI systems are inherently asynchronous.
We need agents to call tools, subagents to delegate tasks and sync operations with ease.
Traditional UI architectures struggle with this model because they were designed around deterministic interaction flows.
As a result, developers end up writing excessive coordination logic for state synchronization, loading orchestration, race-condition handling, streaming workarounds, nested async effects and concurrency patches
The complexity spreads everywhere not because AI is flawed but because most frontend architectures were never designed for AI-native execution models.
A truly asynchronous rendering system would allow interfaces themselves to participate in orchestration flows instead of merely reacting to completed operations.
That changes everything.
It means agents and subagents can become naturally embedded into web interfaces instead of existing as sidebars, terminals, or isolated chat windows. The browser stops being a passive renderer and becomes an orchestration environment.
Speech Synthesis
Speech systems expose another major gap in modern web frameworks.
Running speech-to-text or text-to-speech over the network is expensive. Latency, scalability, bandwidth, privacy and infrastructure costs quickly become difficult to manage.
Browsers already provide speech capabilities through the Speech Synthesis API but the developer experience is inconsistent and difficult to control reliably.
Events such as onboundary and onmark, which are critical for synchronised speech interactions behave inconsistently across browsers.
That inconsistency makes it difficult to build reliable speech-driven interfaces. And again, this is not an AI problem. It is a framework problem.
What developers need is a client-side architecture capable of treating speech as a first-class interactive system instead of a disconnected browser feature.
Once speech becomes properly integrated into rendering and interaction systems, browser-native AI agents become more practical. Interfaces stop feeling like static pages with chat overlays. They start behaving like responsive conversational systems.
Framework Wars Are Necessary
AI did not end framework wars. If anything, it made them more important.
Every new layer of complexity creates demand for better abstractions, better execution models, and better ways to structure systems. That is exactly what frameworks are for.
Discouraging framework innovation will not simplify AI development. It will only leave developers with complex problems and fewer architectural tools capable of solving them.
Frameworks remain one of the most effective ways we have to turn powerful capabilities into scalable, maintainable, and reliable systems.
The future of AI on the web will not be determined only by models. It will also be determined by the frameworks capable of making those models programmable, interactive, asynchronous, and composable at scale. So framework wars are not over. The next generation has begun.
Have you experienced any of these challenges while building AI applications or modern web systems?
I would love to hear your perspective in the comments.