Brand Becomes Software

Thesis

Design systems spent decades as documents: a Figma library file, a Storybook, a brand guide as PDF, at best a JSON file of tokens. People read them, interpreted them, implemented them.

Three current products shift that function. Claude Design by Anthropic Labs – available as a research preview since April 17, 2026, running on Claude Opus 4.7, with Canva as export partner – works differently from earlier prototyping tools: teams upload codebase files and design documents, the system extracts colors, typography and components and applies them consistently across prototypes, slide decks, marketing material and code-backed interactions. Vercel v0 generates interfaces from a registry-based component set. shadcn/ui distributes design decisions as paste-by-reference snippets. Three vendors, one shared movement: the design system is executed, not read.

The consequence touches two disciplines at once. Brand design loses the PDF as its primary working medium. Design ops loses library maintenance as its central activity. Both gain something else: curating a rule set that generators consume, and evaluating what those rule sets produce.

The design system is executed, not read.

What Separates This from the Previous Tool Generation

What structurally separates Claude Design from v0, Lovable or Subframe is not generation itself – it is the closing of the chain. Anthropic describes a “one-step handoff bundle to Claude Code”: what emerges in the prototype moves into implementation in the same stack, in a single step. That creates a vertical integration from conversational draft to deployed application – design, code and delivery inside the same infrastructure.

This reaches deeper than a workflow optimization: it changes who makes which decision in the chain. Where designers, engineering and DevOps used to manage handovers, the handover becomes configuration. The Brilliant case study Anthropic cites in its announcement illustrates the magnitude: complex pages that took over twenty iterations in other tools came together in two. Speed is a symptom here, not the argument – the real argument is the shortening of the handover layer in which design decisions used to be translated into code.

From Document to Runtime – the History

The token idea is twelve years old. Jina Anne formalized it in 2014 in the Lightning Design System at Salesforce – a named design decision in a platform-independent format, from which the variants for CSS, iOS and Android can be generated. Brad Frost added the structural layer in 2016 with Atomic Design: components as combinable elements, styled through tokens. The W3C Design Tokens Community Group has been working on an open interchange format since 2019.

For twelve years the movement remained largely documentary. Tokens were recorded, components catalogued, style guides versioned. The shift to runtime begins with an inconspicuous detail: when a generator no longer reads a token as a hex value in documentation but uses it as structured input for a decision, the status of the file changes: the description turns into a configuration.

The difference is not purely technical. Documentation waits for human interpretation. A configuration makes a decision in every execution – even when nobody is watching. That shifts where governance has to happen: no longer in the review of each individual implementation, but in the consistency of the rule.

Benjamin and Reproducibility

Walter Benjamin described a similar shift in 1936 in The Work of Art in the Age of Mechanical Reproduction. Technical reproduction – photography and film, back then – turned the uniqueness of the artwork into a technical question: what about a work is its singular presence (the aura), and what is its reproducible form?

Benjamin’s essay is no toolbox for design strategy. But it exposes a problem that is currently repeating itself: when reproduction becomes trivial, cultural and economic value shifts away from production toward the decision about production. In nineteenth-century painting that was the choice between the documentary portrait (declining) and the conceptual or expressive work (growing). In the brand and product work of the coming years it may be the choice between artifact production (declining) and system curation plus evaluation (growing).

When reproduction becomes trivial, value shifts away from production toward the decision about production.

The parallel is not new. The typewriter, desktop publishing, the digital camera – every reproduction threshold followed the same pattern. The decisive question is which layer of design work slips behind that threshold next. The signals suggest: brand artifacts and component libraries are up.

What Changes for Brand

A brand guide as PDF is a handover formula. It tells a human counterpart what the brand should look like – logo, color palette, type family, tone. The formula works as long as someone at the other end decides how a color value is to be interpreted in a given situation.

When a generator makes that decision, the intermediate step disappears. A brand system that is consumed generatively therefore needs more than color values:

• Semantics before specification. A token is called color.action.critical, not #E63946, and stands for a meaning: “signal irreversibility”. The color value follows the meaning, not the other way around.
• Rules before examples. Instead of a picture saying “this is what our button looks like”, the system describes when which button appears in which context with which language. Counter-examples and edge cases are part of the system, not an annex.
• Voice as structured context. For generators, tone cannot be specified through adjectives (“warm, precise, never condescending”), but through example pairs (wanted / not wanted) and context-bound rules.

This shift is barely visible in the workshop – and still changes the role of brand work.

Whoever builds a brand system in this form delivers infrastructure. Whoever delivers it as a PDF delivers a certificate.

What Changes for Design Ops

Design ops emerged as a response to a scaling problem: the larger the design teams, the more time they spend on maintenance instead of design. The answer was a role that curates tools, systems and rituals – so designers can work productively.

In the runtime configuration this role shifts. The operational work – maintaining components, versioning tokens, updating documentation – becomes automatable. What does not become automatable is the decision about what the rule is. Design ops thereby moves closer to governance:

• Evaluation instead of review. A review discusses a designer’s work. An evaluation assesses a system’s output against defined criteria (brand conformity, accessibility, contextual fit). The difference is not semantic: reviews don’t scale with generative speed, evaluations do.
• Curation instead of maintenance. Not every exception makes it into the rule. Deciding which exception becomes a rule and which remains a special case becomes the actual substance of the work.
• Infrastructure instead of documentation. Tokens, rules and templates are formatted so generators can consume them. The goal is readability, not completeness.

Projection: Three Years, Three Movements

What can be extrapolated from the current signals – with due caution toward any extension of a curve:

1. Mid-level production work shrinks. Whoever exclusively produces screens and brand applications loses demand. The work moves into generators; the judgment layer stays with people.

2. Junior education becomes an unsolved problem. The classic learning environment – lots of production under supervision, judgment built from it – disappears together with mid-level production work. No established answer is in sight; universities and companies will have to invent new formats over the next two to three years.

3. Organizations with runtime systems gain speed. Teams that set up their brand and component system so generators consume it consistently produce more variants on the same budget. Teams without a runtime system produce the same number of outputs at lower consistency – the brand effect dilutes before anyone identifies the cause.

Perspective

This piece is written from a product design and design ops perspective, with operational experience in the DACH region and a focus on SMEs and mid-size organizations. The brand section draws on collaboration with brand designers, not on own brand practice – that, too, belongs in the framing. What this perspective sees: the operational shift inside teams, the tooling landscape, the economics of small and mid-size engagements.

What it does not see: large-enterprise cycles with multi-year adoption spans, regulatory special cases (e.g. heavily certification-bound industries), non-European markets with a different tool stack and platform landscape. A brand designer at a global consultancy or a design ops manager in a corporation with 500+ designers would co-sign parts of this diagnosis and weight others quite differently.

Critical Assessment

What holds up

• The token history is well documented: Lightning 2014, Atomic Design 2016, W3C DTCG since 2019 – a twelve-year trend toward machine readability that is now slipping into the execution layer
• The three product observations (Claude Design, v0, shadcn/ui) are backed by official announcements, not speculation
• The vertical integration from design to code (Claude Design → Claude Code) is explicitly named by Anthropic as a differentiator – it shows that the argument “the design system becomes runtime” is not hypothetical but concretely formulated as one vendor’s product strategy
• The shift from documentation to configuration has already completed in adjacent fields (infrastructure-as-code, policy-as-code) – an established precedent

What needs qualification

• The projection “mid-level production work shrinks” is no law of nature. Regulatory complexity, enterprise cycles and DACH-specific conditions delay adoption by years
• The term “commodification” is problematic: it suggests loss where re-sorting may be the better fit. Photography did not devalue painting; it displaced it
• Whether automatic extraction (Anthropic: “extracts colors, typography, and components”) actually reads system semantics or merely produces visual approximation is empirically open. The thesis only holds if the tools genuinely take tokens, rule sets and context logic into account – and don’t just generate visual consistency
• The closed loop from Claude Design to Claude Code is closed within Anthropic’s infrastructure. What happens when teams want to mix tools from different vendors (Figma, GitHub, Vercel, other models) is open – vendor lock-in is a real question, especially for organizations that already run several tool stacks

Discussion Questions

01 Edge-case competence: When a design system is executed generatively – who decides on the exception that characterizes a brand, and how does that decision get played back into the system?

02 Paths for juniors: Which learning formats replace mid-level production work as the teaching stage once that layer moves into generators? University, bootcamp, open-source contribution, public portfolio work – which of these gains traction?

03 Where governance lives: Does brand runtime governance belong to the design discipline, to design engineering, to a new role – or to an entirely different discipline (data governance, content operations)?

04 Measurability: How do you measure brand consistency across generated output? Which criteria can be operationalized, which remain a matter of judgment?

Sources

• Anthropic: Introducing Claude Design by Anthropic Labs
• Vercel: Introducing the new v0
• v0 by Vercel
• shadcn/ui
• W3C Design Tokens Community Group – Format Specification
• Walter Benjamin, Das Kunstwerk im Zeitalter seiner technischen Reproduzierbarkeit (The Work of Art in the Age of Mechanical Reproduction), 1936 (third version, published posthumously in 1955 in Schriften)
• Brad Frost, Atomic Design, Brad Frost Web, 2016 (atomicdesign.bradfrost.com)
• Jina Anne, work on the Lightning Design System, Salesforce, since 2014

Glossary

Design Token A named design decision (color, spacing, font size) in a platform-independent format. Allows the same decision to be translated losslessly into different technical environments (CSS, iOS, Android).

Runtime (in the context of design systems) A live execution context in which a system is consumed by a program – here: a generator. Its counterpart: documentation that waits for human interpretation.

Storybook Open-source tool for developing and documenting UI components in isolation. De-facto standard for classic component libraries since around 2018.

Governance (in the design context) The ongoing decision about rules, exceptions and edge cases in a design system – as distinct from executing those rules.

---

First part of a series on how the design profession shifts when design becomes executable. Part 2: Ten Drafts. Now What? takes the perspective of product teams and product designers, Part 3: The Backlog Was Yesterday that of product management.