The component library was the right answer to a problem agents no longer have
Component libraries exist because building UI was expensive and inconsistency was hard to prevent. AI agents changed the cost equation. The case for building unencumbered — and what you need instead.
An agent is building a contract review interface. The job is clear: a legal ops team needs to scan a hundred vendor agreements and flag anything that deviates from standard terms. The ideal interaction is a comparison row — the clause on the left, the standard on the right, a flag inline, an approve/reject action on the row itself.
The component library has a modal. The modal is what you use when something needs reviewing.
The agent uses the modal. It's wrong for the job — the user has to open and close it a hundred times instead of scanning down the page — but it's what the library supports. Alternatively, the agent files a request: can we add a comparison row component? The request goes into the backlog. The backlog is reviewed quarterly. The interface ships with the modal, the legal ops team spends twice as long on reviews, and three months later someone closes the backlog ticket as won't-fix because the product roadmap has moved on.
Here's what's notable about that story: building the comparison row from scratch would have taken the agent about ninety seconds.
What component libraries were for
Component libraries exist because, not long ago, building UI was expensive and inconsistency was a real bug.
A custom date picker cost a day or two. A multi-select with async search cost three. A row with an inline action and a conditional disclosure took a half-sprint to build well and a full sprint to build well and accessibly. If you had a team of developers building a product with fifty features, the math was clear: shared components with shared defaults, built once and maintained in one place, paid for themselves within the first few months.
Libraries also encoded judgment. The decisions about padding values and border radii and focus states and keyboard behavior — someone made those decisions carefully, and putting them in a library meant you didn't make them again badly on every new feature. That's genuinely valuable. A well-built component library is accumulated design intelligence.
The case for the component library was real. It solved a real problem at real cost.
The cost equation inverted
AI agents can build a purpose-built primitive — a component designed for exactly the job at hand — in seconds.
Not a close approximation. Not a library component with overrides stacked on top. A component built from scratch, to spec, for the specific interaction the job requires. The comparison row. The inline flag with contextual expand. The multi-step confirmation that flows forward instead of interrupting. Whatever the job asks for.
The marginal cost of that purpose-built primitive is close to zero.
The marginal cost of working around a library constraint is real and it compounds. The agent compromises the design — uses the modal because the library has a modal. Or the agent files the update request and waits. Or the agent ships an override, !important and z-index stacked until it looks right, until the next version bump breaks it. Each of these outcomes is worse than building fresh, and each one happens because the library was treated as a constraint rather than raw material.
"Can we update the component library?" is the symptom. The disease is the assumption that the library controls what gets built.
Pattern: component libraries solved a consistency problem at a time when custom components were expensive. When an agent can build and customize any component in seconds, the library's value proposition inverts — instead of absorbing cost, it adds constraint. The right unit of judgment shifts from "does this conform to the library?" to "does this serve the job?"
The ephemeral argument
There's a second thing happening alongside the cost shift.
UIs are becoming more distilled. The thick, multi-surface applications that dominated the last decade of SaaS are giving way to something more situational: interfaces built for a specific job, a specific session, sometimes a specific user. The contract review interface for the legal ops team doesn't need to share a component vocabulary with the expense reporting tool or the vendor onboarding flow. It needs to serve the job it was built for.
Component libraries are optimized for permanence. Build once, use everywhere, update in one place. That model works well when the interface is expected to last years and serve many jobs. It works poorly when the interface is expected to serve one job and may be rebuilt or retired before the next major library version.
The right model for agent-built UI is different: the library as a starting position, not a destination. Defaults as a floor, not a ceiling. An agent working on a new interface should start from whatever baseline the library provides — it's free, it's already solved, it encodes that accumulated judgment — and then build from there, unencumbered, to the shape the job actually requires.
The shift isn't "ignore the library." It's "don't let the library be the ceiling."
What you need instead of library conformance
When agents build unencumbered, the question "is this component right?" doesn't disappear. It stops being answerable by checking the library spec.
Library conformance is a proxy for quality. A component that exists in the library, used as specified, is probably fine — it's been reviewed, it's accessible, it behaves predictably. That proxy is useful when the alternative is a developer building something new without review. It's less useful when the alternative is an agent building something new in ninety seconds.
The question behind the proxy is: does this component serve the user's job? Does it add extraneous load — steps, clicks, cognitive overhead — that the job doesn't require? Does it fit the way the user thinks about the task, or does it impose a different mental model?
Those are design judgment questions. They can't be answered by checking whether the component exists in the library. They require knowing the job, the user, and what good looks like for that specific combination. That's a different kind of quality gate — one that runs on understanding rather than conformance.
The component library isn't going away. It still provides defaults worth starting from and judgment worth inheriting. What's changing is its role: from the thing that controls what gets built to the thing that provides the raw material for building.
The control, in an agent-built world, moves somewhere else. To the question that actually matters — not "is this in the library?" but "does this serve the job?" That question needs an answer. The library isn't the place to look for it.