Back to database

Brian Lovin, Notion's AI use case

Designer / design leader at Notion

Uses AI coding tools to help design teams move faster from Figma to working prototypes, while creating custom skills and context that make development workflows easier to repeat.

The problem

What was broken before AI

Design teams often have to choose between fast static mockups and slower working prototypes. Figma can communicate layout and flow, but it does not always capture the feel of real interaction, data, loading states, edge cases, or implementation constraints. Engineers may not see the full intent until later, and designers may not discover interaction problems until the work has already moved downstream.

What changed

What the use case made possible

AI coding tools let designers push further into the prototype stage. A Figma idea can become a working artifact sooner, and custom Claude Code skills can make repeated development tasks easier to run. Instead of a one-off handoff, the design process can include more tangible artifacts: small apps, interactive states, reusable instructions, and prototypes that reveal whether the idea actually works.

Why this matters

Why this use case is worth studying

Brian’s workflow is valuable because it gives designers a more direct way to test their own ideas. The prototype does not have to be production code to be useful. It just has to be real enough for someone to click, feel, critique, and improve. AI lowers the cost of getting to that moment, which makes design feedback sharper and earlier.

Use this when

When this pattern applies

Use this pattern when a design idea needs to be clicked, tested, or felt before the team can judge it. It works especially well for interaction-heavy flows, complex states, design-system components, and moments where static Figma screens are not enough.

Exponential Builder analysis

01

Prototype the behavior, not just the screen.

AI is most useful here when it turns a visual idea into something people can click, break, and critique before engineering time is fully committed.

02

Treat states as design material.

Empty, loading, error, populated, and edge-case states often expose the real product problem; asking AI to generate them makes the design review less dependent on imagination.

03

Save the repeat work.

The custom-skills angle matters because the team gets compounding value when repeated prototype conventions, design-system rules, and handoff expectations become reusable context instead of one-off prompts.

Who this is for

Best fit

Product designers

Design engineers

Design systems teams

PMs reviewing interaction ideas

Front-end engineers partnering with design

Designers using AI coding tools

Teams that want stronger prototypes before handoff

What to avoid

Mistakes and warnings

Where this pattern can go wrong if you copy it too literally.

Do not confuse a working prototype with production-ready code.

Avoid overbuilding before the interaction has been validated.

Keep the design system visible so AI does not invent random patterns.

Do not let the prototype override design judgment just because it works.

Make sure engineers understand what is exploratory and what is intended for production.

Public workflow preview

The shape of the workflow

A high-level look at how the use case works, with the reusable pattern made clear.

01

Start with the design intent

The workflow begins in Figma or a design concept, but the goal is to test how it behaves, not only how it looks.

02

Move into a working prototype

Claude Code helps translate the idea into interactive code that can be clicked, tested, and discussed.

03

Add realistic states and constraints

The prototype can include data, loading states, empty states, and interaction details that static mocks often skip.

04

Save repeatable instructions as skills

When the same dev task comes up often, the workflow turns it into a reusable skill or instruction set.

05

Use the prototype as a better handoff

Designers and engineers can discuss the behavior from something closer to a real product surface.

Copy the pattern

The reusable idea

Pattern in one sentence

Use AI coding tools to turn design intent into small working prototypes that reveal behavior before production work begins.

Reusable idea

Brian’s workflow is a reminder that designers do not need to wait for engineering to learn from interaction. If an idea depends on motion, state, data, or behavior, use AI to make a small working version. The goal is not to become a full-time engineer. It is to make the design concrete enough that better questions show up earlier.

Steal this workflow

Design-to-prototype review recipe:

1

Choose one Figma concept where interaction matters more than polish.

2

Gather the Figma screens, key states, design-system rules, sample data, and the one behavior you need to test.

3

Ask Claude Code for a small clickable prototype with clear limits: exploratory, lightweight, and focused on the core interaction.

4

Require the states that usually get skipped: empty, loading, error, populated, and at least one awkward edge case.

5

Click through it like a user and write down what the static mock hid: confusing timing, missing affordances, bad copy, brittle data assumptions, or flows that feel heavier than expected.

6

Revise the design, then ask for a short handoff note explaining what the prototype proves, what remains unresolved, and what engineering should review.

7

If the task will repeat, turn the instructions into a reusable skill or context file so the next prototype starts with the same conventions.

Suggested prompt

“Turn this Figma design concept into a small working prototype for design review. Focus on the core interaction rather than production-ready code. Use the provided design-system rules and sample data, and include empty, loading, error, populated, and edge-case states. After building it, summarize what the prototype reveals, what still feels unresolved, and what engineering should review before implementation.”

Field notes

Get new AI use cases in your inbox

A short weekly note on how real people are using AI to save time, make money, build tools, and run their lives.

No spam. Just useful AI use cases.

Related use cases

Keep exploring nearby systems.

Browse all