Designers Are Now Governance Engineers — They Just Don't Have the Title

Adobe just demoed a website that writes itself.

Project Page Turner, unveiled in April 2026 at Adobe’s AI Summit, generates a personalized brand page in under 100 milliseconds. Full page in under a second. The model assembles every visitor’s experience from AEM Assets and AEM Sites in real time. Paolo Mottadelli, the Adobe engineering director who built it, predicts a future where “training the website is like training a human.”

Read that line again. The brand surface is now an LLM output. The promise your company makes to a stranger on the internet is now decided by a model, in less time than a blink, with no human in the loop.

So who governs what it says?

The answer used to be obvious. The brand team wrote a guideline. The marketing team enforced it. The design team designed within it. Three groups, one document, slow drift.

That answer no longer holds. When the page generates itself in 100 milliseconds, no human is sitting between the model and the visitor. The brand promise is a runtime artifact. And the only place to enforce it is the constraint layer the agent reads before it generates.

That constraint layer is the design system. Which means the people building it are no longer designers. They are governance engineers. They just do not have the title yet.

Adobe Made the Brand Surface a Model Output

Look at what Page Turner actually does. It applies “a new indexing layer that makes both [AEM Assets and AEM Sites] rapidly accessible to a fast LLM, allowing it to assemble a personalized page on the fly.” Brands provide “brand guidelines, product knowledge, and content rules. All of this goes into instructing it on what to recommend and when, similar to how you’d brief a new employee on company policy.”

That last clause is the one to dwell on. Brand guidelines are no longer documents humans read. They are inputs the model consumes at inference time. If the guidelines are vague, the output is vague. If they live in a PDF on SharePoint, they do not exist.

Brand consistency just became a runtime governance problem — the same kind engineering wrestled with for autonomous agents in 2024 and 2025. We argued before that design systems are governance infrastructure. Adobe just demonstrated why: the alternative is a hallucinated brand.

Smashing Magazine: Designers Now Ship Code

While the brand surface mutates at the model layer, the production layer is shifting too. Carrie Webster’s piece in Smashing Magazine documents what she calls “the UX designer’s nightmare” — a market that, in early 2026, “abruptly settled” the should-designers-code debate “not through a consensus of our craft, but through the brute force of job requirements.”

Her data points are blunt. UX, UI, and Product Design roles are projected to grow 16 percent through 2034 against 3 percent for traditional graphic design. “Design skills” recently became “the #1 most in-demand capability, even ahead of coding and cloud infrastructure.” Seventy-three percent of designers now treat AI as a primary collaborator. Recruiters want someone “who can also prompt a React component into existence and push it to a repository.”

Webster’s worry — the competence trap, “averagely competent at both” rather than excellent at one — is real. But it does not undo the structural shift. Designers are now responsible for what ships, not just what gets handed off. They own the runtime, not just the artifact. We have seen this collapse coming: when designers code again, the org chart moves with them.

The org chart has not moved yet. The job description has.

Marie Claire Dean: The Behaviour Becomes the Interface

If Adobe shows the surface mutating and Smashing shows the production layer shifting, Marie Claire Dean’s essay names what is happening underneath. “Once products possess agency, the interface stops being the primary surface. The behaviour becomes the interface.”

Her reframe of the designer’s job is the cleanest I have read this year:

“We used to design what users click, and now we design how they delegate. We used to define flows, and now we define boundaries. We used to specify screens, and now we specify how a system interprets intent, resolves ambiguity, asks for clarification, and recovers from mistakes.”

Read that as a job description. Boundaries. Intent interpretation. Ambiguity resolution. Clarification thresholds. Error recovery. Every one of those is a governance decision dressed in design language. When a designer specifies “the agent should ask before sending an email over $500,” that is not a UX flow. That is a policy. It just happens to live in a Figma file instead of a compliance document.

Dean calls the new material “behaviour in time” instead of “pixels in space.” The design surface moves from layout to delegation. From affordance to alignment. From hierarchy to oversight. None of those are aesthetic choices. They are governance choices that happen to be made by people whose job title still says “designer.”

Figma Console MCP: Governance Encoded as Metadata

The fourth piece closes the loop. The Learning Agentic Design Systems experiment, published in April 2026, walks through a bidirectional Figma-to-code workflow built on TJ Pitre’s Figma Console MCP and Cristian Morales Achiardi’s AI component metadata skills. Designers generate components, generate variables, generate React code, and — most importantly — generate metadata.

The metadata is the governance.

Quoting the author directly: “You as a system designer are no longer just designing a component, you are designing the rules with which AI is allowed to use the component… as a design system maintainer you need to learn how to encode governance using structured data.”

Translate that. The output of design work is no longer a Figma frame. It is a JSON file that tells every downstream agent — Cursor, Claude Code, Antigravity, whatever ships next quarter — exactly when, where, and how a component may be used. The frame is the artifact humans review. The metadata is the artifact agents obey.

This is the same pattern we documented in content operations when style guides moved into CLAUDE.md files. A style guide in a PDF is a suggestion. A style guide encoded into agent context is a constraint. Design systems just took the same step.

The Title Has Not Caught Up

Stack the four together. Adobe makes the brand surface a model output. Smashing shows the production layer collapsing onto the designer. Dean reframes the work as behaviour design. Figma Console MCP makes the governance machine-readable.

The job description is now: define the rules, encode them as structured data, ship them into runtime, and own the consequences when the agent gets it wrong. That is not design. That is governance engineering with a Figma license attached.

Engineering already lives this way — Cloudflare’s Workers AI Gateway, Anthropic’s policy primitives, Datadog’s agent observability. Marketing and design have nothing comparable. The governance work is the same. The instrumentation gap is enormous.

What design leaders should do this quarter is small and specific. First, audit how brand guidelines are currently consumed by AI tools. If they live in PDFs, they are not constraints — they are decoration. Second, identify which design system components are now generated, modified, or referenced by agents, and write metadata for those first. Third, decide who in the design org owns the runtime artifact, not just the Figma file. That person is now a governance engineer. Pay them like one.

The org chart will catch up eventually. The work is already here.

This analysis synthesizes Adobe Project Page Turner coverage (Apr 2026), Smashing Magazine’s Production-Ready Becomes Design Deliverable (Apr 2026), Marie Claire Dean’s Your UX Skills Were Built for One Kind of Intelligence (Apr 2026), and Learning Agentic Design Systems (Apr 2026).

Victorino Group helps design and engineering leaders build the governance tooling that crosses both functions. Let’s talk.