---
title: "Scaling code prototyping and AI workflows across a design org"
description: "How to help a whole design team adopt code-based and AI-assisted prototyping: starter kits, teaching, guardrails, and how to keep quality high as more designers build."
url: "https://mikestilling.com/guides/scaling-prototyping-in-a-design-org/"
date: "2026-11-22"
author: "Mike Stilling"
---

> AI-generated from Mike Stilling's work, notes, and writing.

# Scaling code prototyping across a design org

Beyond project work, Mike Stilling helps scale AI and code-based prototyping workflows across Stripe's design org, and mentors designers through Stripe's formal mentorship program. One product designer wrote that Mike's guide to AI "was a lifesaver" when it all felt overwhelming. This guide covers how to help a whole team, not just yourself, get good at building.

## The short answer

**Make the first working prototype easy, then make good prototypes the norm.** Most designers aren't held back by ability. They're held back by setup, uncertainty about where to start, and fear of breaking things. Remove those, give people good foundations, and share what works.

## Why it matters for a design org

A single designer who prototypes in code is useful. A team that can do it changes how the whole org works:

- **Better decisions, faster.** Working prototypes settle debates that static mocks drag out. At Stripe, a product marketer said one of Mike's prototypes "was instrumental in gaining leadership approval."
- **Fewer lost details.** A full-stack engineer noted that Mike created "full on working demos that show all behaviors clearly," and that projects would have stagnated without them.
- **More realistic design.** Designers who build understand what's cheap, what's expensive, and what's impossible.
- **Better AI products.** When the product includes AI, prototypes with real models are the only honest way to design it. See [designing AI experiences](https://mikestilling.com/guides/designing-ai-experiences/).

## Lower the barrier to start

Setup is where most people quit. Make it as close to zero as you can:

- **A starter project.** One repository that already runs, with the team's fonts, colors, and common components wired up. Designers should be editing a real page within minutes, not configuring tools.
- **A short setup guide.** Exactly what to install, in what order, with screenshots. The [prototyping in code](https://mikestilling.com/guides/prototyping-in-code-for-designers/) guide covers a typical Mac setup.
- **Easy sharing.** Every prototype should be easy to put on a link that anyone can open. A prototype nobody can see doesn't change any decisions.
- **A place to ask.** A shared channel where "this is probably a dumb question" is welcome.

## Teach by building

People learn this by doing, not by watching:

1. **Hands-on sessions over lectures.** Everyone leaves with something working.
2. **Real tasks.** Have people rebuild a piece of something they're actually designing, not a toy example.
3. **Teach the vocabulary.** Designers prompt AI tools better when they can describe layout in code terms, like "2-column grid, 16px gap, vertically centered." A little HTML and CSS goes a long way. See [designing in code with Tailwind](https://mikestilling.com/guides/designing-in-code-with-tailwind/).
4. **Pair people up.** Pair confident builders with newer ones. Mentorship scales better than documentation alone.
5. **Celebrate examples.** Share prototypes that moved a decision forward, so people can see what good looks like.

## Keep quality high

More people building can mean more mess. A few guardrails help:

- **Build on real foundations.** Prototypes that use the team's actual components and tokens look right and are easier for engineering to understand.
- **Review the output.** AI tools are fast and confident, and sometimes wrong. Teach people to check what was generated, especially accessibility and edge cases.
- **Be clear about the purpose.** A prototype is for learning and deciding. It shouldn't quietly become production code.
- **Keep it simple.** Fewer dependencies and plain, readable code make prototypes easier for everyone to pick up and change.

**AI is a multiplier, and a thousand times nothing is still nothing.** The goal isn't more prototypes. It's better decisions.

## Working with engineering

Code prototyping works best as a partnership with engineering, not a way around it:

- **Agree on expectations.** Engineers should know what a prototype is meant to show and what it isn't.
- **Share early.** A prototype is a great way to raise feasibility questions before anything is committed.
- **Learn their constraints.** The more designers understand the real codebase, the more realistic their prototypes become. A Stripe design engineer said that Mike's front-end knowledge "creates a working relationship rooted in empathy between disciplines." That's the outcome to aim for across the whole team.

## Frequently asked questions

### Should every designer on a team prototype in code?

Not every designer needs to, but every designer should be able to when an idea depends on interaction, state, real data, or AI output. The goal is to remove barriers so the option is there, not to replace other tools.

### How do you get a design team started with AI prototyping?

Start with a starter project that already works, a short setup guide, and a few small, real tasks. Run hands-on sessions instead of lectures, and make it easy to ask for help. People learn fastest when they ship something real in the first hour.

### How do you keep code prototypes from turning into AI slop?

Give people good foundations to build on, like the team's real components and tokens. Teach them to review what the AI produced, share good examples, and be clear that a prototype is for learning and deciding, not something to ship as is.

### How do code prototypes fit with engineering?

A prototype is a precise, working description of intent. It helps engineers understand behavior and edge cases before they start, and it surfaces feasibility questions early. Agree with engineering on how prototypes are shared and what's expected of them.
