Most UX focuses on the screen users touch.
I redesigned the system that builds the screen.
An org-wide agentic UX execution pipeline that eliminated frontend build time, enforced design system and accessibility compliance at the code layer, and redefined what UX ships into a room — from prototypes to near production-ready systems.
Every sprint began by re-explaining what everyone already knew.
PMs translating vision into tickets. Designers maintaining consistency across silos. Engineers interpreting Figma under sprint pressure. QA chasing inconsistencies caused by divergent implementation. The delivery experience was broken — for everyone in it.
✕ Sprint churn from mid-cycle drift
Requirements evolved during implementation. Engineers rebuilt. Designers re-explained. Nobody shipped on time.
✕ Frontend inconsistency across teams
22 domains. Each team optimising locally. Same component, different behaviour. QA couldn't keep up.
✕ Accessibility as a retrofit
WCAG compliance discovered in audits, not built at generation. Every fix was expensive and late.
✕ Knowledge wasn't machine-consumable
Design rules, domain logic, edge cases — scattered across heads. Every sprint re-explained what everyone already knew.
AI quality is a context
architecture problem.
Not a prompts problem.
Most AI-assisted workflows obsess over prompts. I focused on structured organisational intelligence. If I could structure everything the organisation already knew into a form a system could navigate, the pipeline wouldn't just generate faster code — it would generate correct code. Code that already understood the guardrails, the patterns, the edge cases, and the accessibility requirements before a developer looked at it.
Structure what lives in
people's heads — before
the machine can act.
This was the hardest UX work in the project. Teams had never needed to share their knowledge in one place before. Synthesising it required understanding the organisation holistically — architecturally, operationally, and as a user research exercise on the people who built the software.
Four layers. Each one earns its keep. Each one governed.
Steering Layer
Design principles as system behaviour
74 org-level guardrails. UX heuristics, design system rules, WCAG 2.1 AA enforcement, persona context — loaded on every task. Not a prompt. A persistent operating context.
Intelligence Layer
Reusable, referenceable design memory
Versioned personas, UX patterns (data table, forms, consult), workflows (approval, bulk actions), component contracts, global UX rules. A new feature inherits accessibility, keyboard nav, error states, and i18n by reference.
Domain Layer
22 banking domains as structured knowledge
Each domain carries its own architecture, dependency flows, and feature references. Knowledge that previously lived only in people's heads — synthesised into machine-consumable structure.
Feature Pack Layer
What developers actually receive
Every Jira ticket becomes a structured feature pack — production-ready Angular code, accessibility audit, i18n completeness, edge cases enumerated, design handoff docs. The developer downloads, connects the backend, and ships.
22 banking domains. Every one modelled.
Each domain folder carries its own domain.json, architectural diagrams, dependency flows, and feature references. For high-complexity domains, I authored separate architecture and product knowledge documents the system loaded only when working in that context.
Enterprise AI without governance is enterprise risk.
We stopped entering reviews with static prototypes.
- PM Vision → Feature Sheet → Figma
- Dev interprets under sprint pressure
- Clarification loops
- Rework cycles
- Accessibility discovered in audit
- Sprint drift
- PM Vision → Structured Context
- Jira MCP → Feature Pack scaffolded
- Edge cases + A11y + code generated
- Runtime preview + auto validation
- UX sign-off → Git push
- Developer plugs backend → ships
We entered reviews with working systems capable of evolving in real time. Product vision could be presented with unprecedented clarity — requirements already refined against functioning interfaces.
The pipeline amplified precision.
It did not replace judgment.
- Frontend UI code generation
- Edge case enumeration
- WCAG 2.1 AA validation
- i18n completeness checks
- Design system compliance
- Handoff documentation
- Consistency enforcement across all teams
- Backend integration & architecture review
- Business validation & sign-off
- UX refinement & emotional design
- Trust-sensitive workflow design
- QA & production review
- Strategic problem framing
- User research & insight synthesis
What designers became responsible for was the quality of intent — how clearly we could articulate user needs, system behaviour, and edge cases.
Adoption is harder than invention.
Phase 1 · Proof of Concept
Validated that generated code could meet production standards and that the architecture could scale across domains.
Phase 2 · Co-validation
Partnered with lead product owners on live feature work. Then with PMs as a vision-to-insight translator for engineering communities.
Phase 3 · Org-wide (Mar 2025)
Adopted across all teams after launch presentation. Design guardrails merged into community guardrail layer — machine-enforced across every developer's environment.
We stopped shipping prototypes into rooms.
We started shipping systems.
Systems thinking > screen design
As AI accelerates implementation, UX work moves upward — delivery frameworks, intent architecture, trust design, organisational alignment.
Adoption > invention
The pipeline existed for months before org-wide adoption. The harder design work was convincing teams to use it — POCs, co-validation, and showing value on real feature work.
Governance is a feature
Preventing hallucinations required sustained governance — structured guardrails, automated validation, runtime preview, human review at every push. Not a constraint. A feature.
The new bottleneck is intent
Implementation speed is no longer the constraint. The bottleneck is the ability to understand what users need, structure that intent, and align organisations around it before code is written.