Preparing Enterprise UX for Agentic Product Development

Overview

AI-assisted design is moving beyond generating copy, summarizing research, or creating isolated interface concepts. The more consequential shift is toward agents that can participate directly in product-development workflows: interpreting design context, proposing experiences, generating interface artifacts, and increasingly helping translate those artifacts into working code or prototypes.

I began preparing the UX practice for that environment by focusing less on individual AI features and more on what agents would need to operate responsibly inside an enterprise product workflow.

The goal was to explore how AI could reduce production effort while improving how quickly the UX team could model and evaluate possible customer interactions.

Within tools such as Figma, emerging LLM capabilities create opportunities to generate interface concepts, explore interaction paths, and produce more complete prototypes earlier in the design process. Instead of manually building every possible state or journey, designers may be able to use agents to accelerate exploration and move more quickly toward realistic experiences that can be reviewed with stakeholders and customers.

The important question was not simply whether AI could produce an interface. It was whether it could do so using the right customer / persona context, design-system rules, accessibility requirements, and product constraints of the platform.

The challenge

Faster production does not automatically produce better experiences.

AI can amplify whatever system it is given. If requirements are incomplete, design patterns are inconsistent from the start, or governance is poorly documented, an agent can reproduce those problems at greater speed within the tool.

That makes context a critical part of the architecture. An agent needs to understand which standards are authoritative, which design-system components should be reused, what accessibility requirements apply, and where human judgment is still required throughout the process.

Agent context architecture in four columns. Inputs — product knowledge, the shared system of tokens, components, interaction patterns, accessibility and content standards, and execution context such as the current task, constraints, decision history and approved references — combine into a local UX agent context. The agent outputs proposed interactions, interface artifacts and prototypes or code, which go to human review: designer review, stakeholder review and validation. A continuous-learning loop feeds corrections back into the inputs. Tagline: useful generation depends on authoritative context. — Agent context architecture — what an agent must receive before it can generate useful product work.

Enterprise tooling created another constraint. AI products cannot simply be introduced into workflows involving company information, customer data, or intellectual property without appropriate security and governance review. Approval processes that operate over months rather than weeks can significantly slow experimentation within these tools.

Token consumption also emerged as an operational consideration. Keeping large amounts of design-system and product context available to an agent can improve output quality, but it can also increase cost. Context therefore has to become both useful and efficient within the process.

My role

I set the direction for how the UX team could investigate agent-assisted workflows without treating AI output as an autonomous design decision.

I focused the proof of concept on roles, artifacts, review ownership, and quality standards. We examined where an agent could safely accelerate work while preserving designer and stakeholder responsibility for the resulting customer experience.

The work remains exploratory, but the initial findings suggest that meaningful portions of interface production and interaction modeling can be accelerated when sufficient context is available to the agent.

Key decisions

Decision 01

Structure the context before scaling generation

I prioritized customer knowledge, design-system constraints, accessibility standards, product requirements, and decision history as inputs the agent should be able to reference.

The objective was to reduce guessing. Agent quality depends heavily on whether the system can distinguish reusable product rules from temporary instructions submitted in the base prompt.

Better agent output begins with better structured product context within the tool.

Decision 02

Keep judgment and accountability human

AI-generated work was treated as a proposal inside the UX workflow rather than a completed design decision set in stone.

Designers and stakeholders remain responsible for evaluating whether an interaction solves the correct problem, follows system standards, addresses accessibility, and represents an acceptable customer experience.

Generation can be automated more aggressively than judgment. Keep the designer in the loop!

Three columns of responsibility. The human decides: problem definition, customer evidence, priorities, constraints and the quality threshold. The agent may produce: variants, interaction states, layouts, prototypes and initial code. The human validates: customer fit, accessibility, system compliance, tradeoffs and final approval. An evidence and learning loop connects validation back to decisions. Tagline: automate production, preserve accountability. — Human versus agent responsibilities — what agents may generate, and what designers and stakeholders continue to decide, validate and approve.

The solution

We began revising design structures and working practices so reusable guidance could be consumed consistently by both people and AI tools.

In parallel, we requested controlled access to enterprise-approved AI capabilities within the design environment so the team could test practical use cases, understand token consumption, identify correction and review effort, and compare AI-assisted workflows with existing production methods.

Five-step governed workflow: define the customer problem, requirements and success criteria; provide context from the design system, accessibility, product rules and prior decisions; generate interactions, interface states and prototypes or code; review through designer judgment, stakeholder review and compliance; and learn through corrections, reusable guidance and context optimization, which loop back as reusable context. The whole workflow sits on enterprise governance: security, approved tools, traceability and token management. Tagline: the workflow improves when corrections become reusable context. — The governed loop from product context through agent production, human review, validation and system learning.

The purpose of the POC is not simply to prove that an agent can create screens faster. It is to determine whether an agent can operate inside a governed product system without introducing more inconsistency than it removes with every generation.

Impact

The final impact is still being measured.

Early experimentation indicates that agents inside the design workflow can reduce production effort and accelerate the exploration of interactions and interface states. The larger opportunity may be reducing how much repetitive production work designers need to perform as the system matures.

The next challenge is standardization: defining a repeatable process that provides agents with enough design-system and product context to produce useful work while minimizing unnecessary token usage and maintaining clear human review.

Agentic product development ultimately changes more than the tools UX teams use. It changes what design teams need to make explicit.

Customer knowledge, design rules, accessibility requirements, governance, and decision ownership increasingly become part of the infrastructure that enables both people and agents to build coherent products.

Because of confidentiality requirements, this case study cannot show the actual design system, brand identities, or proprietary implementation details. Impact metrics have also been omitted, so the examples focus on the strategy, architecture, operating model, and design decisions behind the work.