← All work

AI-Native Delivery · Change Leadership · Current work

Moving a UX team to AI-native delivery

Static UX/UI handoffs were slowing delivery and forcing engineers to pixel-match design intent. I'm leading my team's shift to an AI-native, front-end-integrated workflow — pairing Figma Make for iterative design with AWS Kiro for build, pushed through engineering's own CI/CD into a UX-specific sandbox for review. It's already cut design revision cycles by 30%+.

🔒 Some specifics are generalized to respect confidentiality. Happy to walk through the details in conversation.

Role
Manager of Product Design — leading the transformation
Status
In progress · piloting → rollout
Stack
Figma Make · AWS Kiro · GitLab · existing CI/CD
Early result
Revision cycles −30%+

The opportunity

My team designs for 8+ enterprise identity products, and like most teams, we delivered UX as static handoffs — wireframes and high-fidelity mockups that engineering then had to interpret and pixel-match. That handoff was a bottleneck: slow, dependent on developers to carry design fidelity, and expensive to iterate on for complex features. AI-native tooling opened a door — but only if someone built the foundation to walk through it safely.

The challenge

Adopting AI tools isn't the hard part; integrating them into how real teams ship is. To make an AI-native workflow stick across multiple product teams, I had to:

  • Understand each team's existing development pipeline and CI/CD.
  • Introduce new tooling without disrupting engineering's standard flow.
  • Keep AI-generated UX consistent with our design system.
  • Give engineering a trustworthy way to review AI-built front-end code.

None of that works without doing the groundwork first.

How I'm leading it

So I built the foundation:

  • Secured access to AWS Kiro for myself and my team, and became a leading internal adopter.
  • Convened engineering leaders to understand their pipelines — learning GitLab, AWS, and each team's CI/CD from the people who run them.
  • Learned each team's workflow, then defined a strategy and adjusted it as I went.
  • Set up UX sandbox servers integrated into each team's existing CI/CD — leveraging pipelines they already trust, but adding a new UX-specific sandbox endpoint where AI-built code can be reviewed by engineering.
  • Introduced Figma Make for iterative, stakeholder-facing design on complex features.
  • Authored design-system steering so the code we generate is scalable, on-brand, and consistent.
  • Mirrored the dev process — clean branches, Jira tickets, merging our branch into the dev branch — so UX plugs into engineering's world rather than running parallel to it.

The result is a repeatable workflow that runs from the first design decision all the way to reviewed, merged code:

Entry depends on whether a static design already exists

Existing Figma design Start from the static design or mockup
No design yet Figma Make — rapid idea testing in-file
  1. 1
    Inputs: Figma design + steering docs
  2. 2
    Kiro generates the code

    AI builds the feature against the design-system steering.

  3. 3
    Feature branch

    Created off the UX-feature prefix.

  4. 4
    CI/CD checks
  5. 5
    Sandbox deploy

    A reviewable, feature-branch-prefixed space.

  6. 6
    Engineering review

Branch strategy

Standard path Merge the UX branch into dev, hook up APIs / lambdas, then to main.
Small ticket Merge directly to main.
Not viable Kill the feature branch.
Result ~30% fewer design iterations — iteration now looks like code review, handled in Kiro.

Because the design intent already arrives as code, engineering no longer has to pixel-match — and the Figma Make files feed Kiro better inputs, which means better code reaching developers.

Early results

It's working, and it's still maturing. So far:

  • Design revision cycles are down 30%+.
  • Three designers have adopted the workflow, with broader rollout in progress.
  • Developer time is reduced — engineering receives cleaner, design-system-aligned front-end code instead of static mockups to rebuild.

We're still refining the handoff to make it seamless — but the direction is set, and the foundation is in place.

What it shows

Innovation only happens once the foundation exists. The AI tools were available to anyone — the leverage came from understanding the pipelines, earning engineering's trust, and building the steering and sandboxes that let a team adopt them safely.

Next project →