For decades, digital design has relied on a peculiar assumption: that software must first be translated into another medium before it can be understood.
Designers sketch interfaces in wireframes, compose layouts in graphics software, arrange screens in collaborative canvases, and only later see these artifacts reconstructed as functioning systems. The mockup becomes a representational layer suspended between imagination and execution—a blueprint for a product that will eventually exist elsewhere, in another material, another logic, another medium.
This workflow has become so normalized that it no longer appears historically specific. Yet it is.
Most contemporary software is not fundamentally visual. It is behavioral. It unfolds through time, state, responsiveness, latency, interaction, personalization, data flow, permissions, recommendation systems, and adaptive logic. A modern product behaves less like a printed composition and more like an environment. Yet much of interface design still operates through representational practices inherited from print, industrial drafting, and static composition.
The mockup belongs to a world where products existed separately from their production.
Marshall McLuhan argued that every medium reorganizes perception independently of its content. The important question is therefore not what a medium shows, but what kinds of thought it makes possible. Representation is never neutral. Every medium privileges certain relationships while obscuring others.
The mockup privileges surfaces.
It encourages designers to think spatially about systems that increasingly operate temporally. Screens appear as discrete frames rather than contingent states within larger behavioral systems. Products become collections of views instead of ongoing processes. The logic of print quietly persists inside digital design.
This inheritance runs deeper than contemporary interface tools. Modern design workflows descend from much older industrial abstractions: architectural blueprints, engineering diagrams, mechanical drafting, publishing layouts. These systems emerged because production was expensive, centralized, and downstream from design itself. A building could not be continuously reshaped during construction. A printing press required finalized composition before reproduction. Industrial manufacturing rewarded advance specification because the artifact existed separately from its execution.
Software partially dissolved these conditions.
Unlike print or manufacturing, software is inherently mutable. It can change after release. It can adapt continuously. It can behave differently across contexts, users, and environments. It can be rewritten while operating. The boundary between prototype and product weakens when the medium itself becomes dynamic.
Yet design culture largely preserved the representational paradigm.
The history of interface design can almost be read as the refinement of representational abstraction:
- wireframes,
- Photoshop comps,
- static mockups,
- clickable prototypes,
- collaborative canvases,
- design systems.
Each stage increased fidelity and coordination while maintaining the same underlying separation: the product exists first as representation and only later as executable reality.
What changes now is not simply tooling but the stability of this separation itself.
Generative systems increasingly collapse the distance between concept and execution. Instead of representing behavior statically, designers can now produce behavior directly through code generation, prompting, simulation, and runtime iteration. The product no longer needs to be fully abstracted before it can exist.
The intermediary medium begins to destabilize.
This shift matters because media shape attention. When designers work primarily through static representations, they naturally optimize for:
- visual consistency,
- compositional clarity,
- and fixed states.
When designers work through executable systems, attention shifts toward:
- behavior,
- orchestration,
- adaptation,
- runtime conditions,
- and system dynamics.
Different media produce different definitions of design.
McLuhan wrote that “the content of any medium is always another medium.” The mockup exemplifies this perfectly. Its content is software itself. But as software increasingly gains the capacity to generate, modify, and simulate its own interfaces, the representational layer starts to lose necessity. The abstraction no longer precedes the artifact with the same inevitability.
The screenshot becomes an increasingly inadequate container for computational behavior.
This does not mean representational design disappears entirely. Older media rarely vanish cleanly. Painting survived photography. Theatre survived cinema. Print survived television. More often, media lose universality while retaining specialized functions. Mockups may persist as organizational artifacts—useful for alignment, communication, governance, or negotiation—even as they cease to function as the primary site of product formation.
The deeper transformation is epistemological.
For years, interface design treated software as something that could be understood through surfaces. But contemporary computational systems increasingly exceed representation. Machine learning models, generative interfaces, adaptive systems, and autonomous agents operate through processes that resist static visualization. Their essential logic unfolds through behavior rather than appearance.
The mockup belongs to an era when software still resembled paper.
What emerges now is not simply a new category of tools but a new relationship between thinking and making. The separation between design and implementation begins to erode. Design moves closer to simulation, orchestration, systems modeling, and executable environments. The designer becomes less a composer of screens and more a shaper of conditions under which systems behave.
Perhaps this is the real transformation introduced by AI-assisted software creation: not the disappearance of design, but the gradual collapse of the representational layer that once separated imagination from execution.