The Post-Static Design Era
Design was a file. Then a system. Now it is infrastructure – available at runtime, when the agent builds.
For most of software history, design was something you captured in a static artifact and handed off. A Figma file. A style guide. A token export. The post-static era begins when the artifact is no longer enough – when the agent building the interface needs the design to be present at the moment of building, not waiting to be consulted.
The three eras
Design in software has moved through three distinct phases, each defined by where design decisions live and who consumes them. In the craft era, design was in the designer's head – expressed through direct involvement in every significant decision, with consistency maintained by proximity. One designer, one product, one coherent sensibility. Scale broke this model.
The craft era gave way to the systems era – design encoded in shared artifacts that many people could reference without requiring the original designer's presence. Style guides, then component libraries, then design systems with token infrastructure. Figma and Tokens Studio and Style Dictionary and Storybook are the tools of the systems era. They are excellent. They solved the coordination problem that scale created. The systems era is not over. But it is no longer sufficient on its own.
What changed
The systems era assumed human consumers. Style guides are written for humans to read. Component libraries are built for developers to implement. Even the most sophisticated token systems are ultimately serving humans who make the final composition decisions. The emergence of coding agents – Cursor, Claude Code, GitHub Copilot – changed the consumer. Agents do not read style guides in the way humans do. They can index documentation, but they apply it without the interpretive layer that a human brings. They do not pause to ask "does this feel right for this brand?" They build, and the result reflects whatever design foundation was available at the moment of building.
The static artifact – the Figma file, the Storybook documentation, the published token package – was built for a human to interpret. Agents need something they do not have to interpret: a service they can invoke.
What post-static design means
Post-static design is not the absence of design artifacts. It is the addition of a runtime layer above them. The Figma file still exists. The design system still exists. The token package still exists. But above them sits a layer of infrastructure that makes design judgment available to agents without requiring those agents to derive judgment from static sources.
In post-static design, when a coding agent builds a component, it does not consult documentation. It invokes a service. The service returns design guidance specific to this brand, this context, this composition – and the agent builds accordingly. The Figma file captures intent for human review. The runtime layer delivers that intent to agents when they build. Both exist. They serve different consumers.
What this era requires from teams
The transition to post-static design does not require abandoning the systems era's tools and practices. Figma remains the right tool for visual exploration and handoff documentation. Design tokens remain the right way to maintain value consistency across large codebases. Storybook remains valuable for component documentation.
What post-static design adds is a new practice: encoding expression identity as infrastructure rather than (or in addition to) documenting it as artifact. This is new work. It requires treating brand expression not as something captured in files but as something authored for runtime delivery – structured, versioned, maintained, and made available to the agents that build from it. The teams that develop this practice earliest are the teams that will maintain brand consistency as AI-built interfaces scale.
See also: what AI agents need from design.
Why this era is irreversible
The shift from craft to systems was irreversible because scale made craft unsustainable. The shift from systems to post-static is irreversible for the same reason: the consumer has changed, and the change is not temporary. Coding agents are not a phase. They are an infrastructure shift in how software gets built. The volume of design decisions being made by agents without human review will only increase. The gap between agent-correct and agent-considered will only widen – unless it is filled by infrastructure designed for this consumer.
The post-static design era is not a prediction. It is a description of what is already happening, named so that the teams and brands living through it can see it clearly and respond to it deliberately.
See also: what is expression infrastructure for the foundational category this era demands.