The Conversation Became the Prototype

For most of my career, the process looked something like this:

Meeting → Requirements → Design → Review → Revision → Handoff → Development

Weeks or months could pass before an idea became something real.

Over the last year, my team has been experimenting with a different model.

And honestly, I don't think we're just changing the workflow.

I think we're changing the artifact.

For decades we've passed artifacts between teams.

Requirements documents.

Wireframes.

Mockups.

Specifications.

Tickets.

Prototypes.

Each one created to bridge the gap between people, teams, and systems that couldn't communicate with each other.

Now, for the first time, I'm seeing those boundaries start to collapse.

We built a custom Figma plugin that exports structured JSON directly into GitLab Duo. Initially, the goal was simple: reduce the friction between design and development.

Instead of creating endless specs and handoff documentation, we wanted to generate front-end code directly from our Design System.

The results were immediate.

Higher design fidelity.

Less rework.

Fewer interpretation issues.

Faster delivery.

What surprised me was what happened next.

We realized we didn't always need a design.

We could start with context.

Business goals.

Customer needs.

Research insights.

Requirements.

Constraints.

Design System rules.

In some meetings, we can discuss a problem and generate production-ready front-end experiences before anyone even opens Figma.

The conversation becomes the prototype.

That shift has been bigger than any AI-generated screen I've seen.

Because once your design system becomes connected to AI, it stops being a library.

It becomes an active participant.

It can generate code.

Review content.

Audit accessibility.

Identify edge cases.

Create documentation.

Support development handoff.

Challenge assumptions.

And because everything exists as code, we can iterate in minutes instead of days.

We've built skills that review experiences against our content standards and suggest improvements.

Skills that audit accessibility and identify issues before development ever sees them.

Skills that surface edge cases and missing states that are easy to overlook.

Skills that generate pull requests and delivery documentation.

What used to be manual reviews across multiple teams now happens continuously.

But the most interesting work isn't happening in design.

It's happening at the boundaries.

The moment AI starts connecting research, design, engineering, content, accessibility, and delivery, it begins crossing traditional organizational lines.

That's where things get exciting.

And if I'm being honest, that's where things start making people uncomfortable.

Especially in large, regulated organizations.

I've spent the last year pushing into those spaces.

Not because AI can replace expertise.

Because it can connect expertise.

The biggest opportunities I've found aren't in generating screens.

They're in removing the friction between people who are trying to solve the same problem.

The area I'm most excited about is research.

Over the years we've accumulated an enormous amount of customer research, behavioral insights, usability findings, and personas.

We're now using that foundation to create synthetic persona simulations that can evaluate experiences thousands of times before they ever reach customers.

Not to replace research.

To extend it.

To pressure test ideas.

To uncover blind spots.

To identify issues while they're still cheap to fix.

The result isn't just speed.

It's confidence.

We're spending less time producing artifacts and more time improving outcomes.

Less time managing handoffs and more time solving customer problems.

For the first time in my career, I'm seeing design, development, research, and delivery operate as a connected system instead of a series of disconnected steps.

AI isn't just helping us work faster.

It's helping us remove entire categories of work that existed because our tools, teams, and processes couldn't communicate with each other.

And I think we're only scratching the surface.

The future of design may not be another screen.

It may be the systems that create, test, validate, improve, and evolve those screens before anyone ever sees them.