AI and Design Systems in 2026: From Static Libraries to Governed Co-Design

In design-system work, I’ve seen libraries accumulate complexity, fall behind product needs, and become expensive to govern. Their value is real, but without clear ownership and evidence-led feedback, maintenance can displace the user problems the system exists to solve.

AI changes where some of that work happens. It can accelerate drafting, compare implementation with system intent, and help teams navigate a growing body of components and guidance. What it cannot do is remove the need for product judgment, accessibility verification, or accountable release decisions.

Originally published 10 May 2025; materially revised 12 July 2026 to reflect current product capabilities.

Design systems still depend on manual judgment

Many design systems are still updated, reviewed, and documented by hand. They depend on consistent usage, contribution discipline, and maintenance rituals. Even with that effort, they can lag behind the products they are meant to serve.

That maintenance burden is real: documentation, contribution review, and release coordination can crowd out product work. The opportunity is not a system that magically maintains itself. It is a system that gives its owners better signals, reduces repetitive work, and makes deviations easier to investigate.

The distinction matters. A mature system is an organisational capability, not just a Figma library. That is why my multi-brand design-system case study focuses as much on adoption and collaboration as it does on components.

AI can draft interfaces, but drafting is not design assurance

Current tools can generate editable starting points. Figma First Draft creates wireframes and designs, while Framer and Uizard can generate responsive pages or multi-screen prototypes from prompts. Figma’s newer MCP write capability can also work with existing components, variables, and styles, although that capability remains in beta.

These tools shorten the route from an idea to something concrete enough to critique. They do not guarantee brand fit, usability, or accessibility. Figma’s own AI terms make the responsibility clear: generated output is unverified and still needs human review.

That is the useful framing for design teams. Generation is scaffolding. The designer still has to understand the user, choose the right interaction model, test the difficult states, and decide whether the result deserves to ship.

The stronger opportunity is an evidence loop

A more credible near-term model connects system governance to evidence without treating analytics as an automatic design verdict:

• Instrument component variants and journeys against defined outcomes.
• Combine quantitative signals with research and accessibility evidence.
• Generate candidate variants for controlled experiments.
• Keep adoption, deprecation, and release decisions under human review.

Conversion data and heatmaps can tell a team where to investigate. They do not prove that a component caused an outcome. The job is to bring several forms of evidence together, understand the context, and make a decision that can be explained later.

Where telemetry contains personal data or supports profiling, the system also needs privacy, data-minimisation, and governance controls. The UK ICO’s guidance on AI and data protection is a useful reminder that better automation does not reduce accountability.

Tokens make constraints legible to machines

Design tokens provide a machine-readable contract for decisions such as colour, spacing, typography, and references between values. The Design Tokens Community Group’s 2025.10 specification is stable and intended for implementation, although it is a Community Group report rather than a W3C Standard.

Tokens can help constrain generated UI across platforms. They can give design tools, code agents, and validation pipelines the same shared input. But tokens do not capture the full semantics, behaviour, or governance of a component. A machine can know which spacing value is valid without knowing whether the chosen pattern makes sense for the task.

More predictable generation comes from combining tokens with validated components, usage guidance, tests, and explicit review—not from tokens alone.

AI-assisted maintenance, not “self-healing”

Agentic tools can already inspect repositories and structured design context. Codex and Claude Code work across codebases, while Figma MCP exposes components, variables, and layout data. That creates practical opportunities to:

• Detect likely duplicate components for review.
• Surface low-use components as deprecation candidates.
• Run automated accessibility checks and suggest fixes.
• Flag drift between design assets and implementation.

What the available products do not demonstrate is a production design system that can safely merge or deprecate components, interpret research, and guarantee accessibility without human review. The building blocks exist; a trustworthy autonomous system does not arrive off the shelf.

Designers move towards direction and evaluation

These tools shift some effort from assembly towards direction, constraint-setting, and evaluation. They do not remove the need for product judgment.

The higher-value work becomes:

• Defining constraints and success criteria.
• Curating reusable components and interaction patterns.
• Evaluating generated work against research and accessibility.
• Governing data, risk, contribution, and release decisions.

Designers who are new to a system may also get better just-in-time guidance. An assistant could explain why a pattern exists, cite the internal standard, or surface evidence from an earlier experiment. That is useful mentorship only if the source is visible and the decision remains with the designer.

The goal is faster learning with accountable judgment

Design systems can become more responsive without becoming autonomous. The opportunity is to let agents handle scaffolding, comparison, and repetitive maintenance while people retain responsibility for evidence, inclusion, and release quality.

For me, the goal is not to build faster at any cost. It is to learn faster without surrendering judgment.

Treat the system as a product, not a file: give it ownership, feedback loops, machine-readable foundations, and explicit human review.