adam bien's blog

Web frameworks solve human problems. Readable abstractions, conventions a team can share, a line on a CV that outlasts the project. All of it is about people, and all of it assumes a human types the code and another human reads it.

An agent has no career to build, and gets nothing from an abstraction whose purpose is to be read. Consistency across a codebase comes from the skill the agent follows, not from the framework.

React, Angular, Vue and Svelte all render through the same DOM. The abstraction leaks, the way all non-trivial abstractions leak, so debugging any of them ends in the platform underneath. The platform knowledge is required either way; only the framework is optional.

An agent writes against the web platform instead. A list component is about twenty lines, imports and registration included. The application ships without a package.json, a bundler or a transpiler: an import map resolves the imports, so what the browser loads is what is on disk.

There is also no install step, and no lockfile, transitive graph or postinstall script to audit, which matters more with agents than without: an agent adds packages on its own, and checking what it pulled in is the review that stops happening first.

What frameworks were invented for keeps arriving as standards:

• Custom Elements and Shadow DOM for the component model;
• form-associated custom elements with ElementInternals for validation and form participation;
• ES modules and import maps for dependency resolution without a build step;
• structuredClone() for immutable state updates, in place of Immer;
• Navigation API and URLPattern for routing;
• <dialog>, popover and View Transitions for overlays and animated view changes;
• CSS nesting, :has(), container queries and cascade layers for what used to need a preprocessor.

The gap keeps closing, and it closes faster than it used to. Ideas that start in frameworks now reach the specifications within a release cycle or two, and the Interop project gets them into all three engines in months instead of years, tracked by Baseline. Custom elements already carry the interfaces of GitHub, YouTube, Photoshop on the web, SAP UI5 and Adobe Spectrum. React 19 added proper custom element support, so the frameworks are moving toward the platform rather than away from it.

What the standards do not cover is small enough to stop calling a framework. Templating is lit-html at a few KB. State management is a hundred lines of unidirectional store code. Neither locks the application in.

Widget libraries are needed either way. React and Angular do not ship a data grid or a rich text editor, so both stacks add one, and the interface decides which one an agent can drive. A custom element exposes attributes, properties, events and slots, and that interface is specified, so an agent knows the calling convention for an element it never saw during training. A React component exposes arbitrary props that change between major versions, and the agent needs correctly versioned documentation to drive it.

Platform code outlives the conventions that produced it. Revise the conventions in a skill, and the code generated last year still runs. Move from one framework major version to the next, and the code itself has to move.

Agents Love The Web Platform's Backward Compatibility covers why the specifications are also the better grounding for an agent.