This week on How I AI: The internal AI tool that's transforming how Stripe designs products (Protodash at Stripe)
Lenny's Newsletter / Owen Williams ยท ? ยท 2026-05-09 Reader ๐ฅ๏ธ
AI SlopAgent Context Files (CLAUDE.md / AGENTS.md)MCP (Model Context Protocol)Non-Engineers Building
Internal AI prototyping tools that embed a company's own design system produce dramatically higher-fidelity results than generic AI tools, and when made accessible to non-engineers (designers, PMs), they shift organizational culture from document-based proposals to working demos โ enabling faster exploration, better cross-functional communication, and more-informed design decisions.
practical ยท podcast episode summary with key takeaways โ newsletter format distilling a long-form interview into structured insights โ Primary source is the How I AI podcast interview with Owen Williams (Stripe design manager). The newsletter provides a curated summary with 7 explicit takeaways.
Structure
| Part | Role |
|---|---|
| Problem frame: generic AI tools produce 'blurple slop' | Establishes why off-the-shelf AI design tools fail at companies with strong design systems โ they lack company-specific context and produce uncanny-valley output. |
| Origin story: from Cursor rules to Protodash | Traces the pragmatic evolution from a bundle of Cursor rules and React components to a full browser-based prototyping platform. |
| Surprise adoption: PMs as power users | Describes how PMs adopted the tool unexpectedly, changing the designer-PM dynamic from gatekeeping to collaboration. |
| Code-based prototyping advantages over Figma | Argues that prototyping in code (with data) enables exploration of edge cases (zero states, different business models) that static design tools cannot efficiently represent. |
| Internal tooling philosophy | Generalizes from Protodash to a broader claim that the most valuable tools match company-specific culture and workflows, and that AI makes building such tools newly feasible. |
| Practitioner heuristics for AI-assisted work | Offers two concrete rules: be specific in initial prompts, and abandon sunk-cost sessions early (slash-clear and restart). |
Key terms
- Protodash Non-Engineers Building
Stripe's internal AI prototyping tool that lets designers and PMs generate clickable, production-quality prototypes from the company's own design system (Sail) using AI code generation. - blurple slop AI Slop
The low-fidelity, uncanny-valley output produced by generic AI design tools (like v0) that don't know a company's design system โ wrong nav, wrong fonts, mismatched components in generic Tailwind. - Sail
Stripe's internal design system, exposed to AI via an MCP server so that code generation uses real components rather than imagining approximations. - demos not memos Non-Engineers Building
The cultural shift Owen advocates: instead of writing documents proposing product ideas, build working prototypes that teams can interact with directly. - Cursor rules Agent Context Files (CLAUDE.md / AGENTS.md)
Instruction files that teach the AI code editor how to use a specific project โ which components to use, when to check the MCP server, how to handle the design system. The foundational layer of Protodash. - MCP server (for Sail) MCP (Model Context Protocol)
A Model Context Protocol server that provides AI tools with structured access to Stripe's design system components, enabling high-fidelity code generation.
Propositions
- explicitcontestedGeneric AI design/prototyping tools produce low-quality output ('blurple slop') because they lack knowledge of company-specific design systems.conf: highcontradictsDesign at the Speed of AI ยท p8 โ Stripe's experience that generic AI design tools produce low-quality 'blurple slop' directly disputes the claim that generically generated UI is production-ready.
- explicitdevelopedEmbedding a company's design system into AI tooling (via MCP, Cursor rules, bundled components) produces dramatically higher-fidelity prototypes.conf: highrefinesDesign at the Speed of AI ยท p1 โ Adds the condition under which AI-generated UI becomes usable at quality: the company's design system must be embedded in the tooling (MCP, rules, bundled components).extends โMeta Open-Sources Astryx, Its Agent-Ready React Design System ยท p2 โ Protodash achieves high-fidelity AI prototyping by embedding an existing design system into external AI tooling (an MCP server, Cursor rules, bundled components); Astryx inverts the pattern โ the design system itself ships native CLI/MCP interfaces, making agent-facing tooling part of the product rather than a separately maintained integration layer.
- explicitAI tools eliminate the terminal-fear barrier that previously prevented designers from working in code.conf: high
- explicitPMs using prototyping tools improves (rather than undermines) designer-PM relationships.conf: high
- explicitCode-based prototypes with real data enable exploration of edge cases and states that are impractical to represent in Figma.conf: high
- implicitAI has made building company-specific internal tools newly feasible by lowering the staffing cost.conf: high
- explicitThe sunk-cost fallacy is a major antipattern in AI-assisted work โ starting fresh is often faster than debugging a deteriorated context.conf: high
- implicitWorking prototypes are more persuasive than written proposals for securing design resources and stakeholder buy-in.conf: medium
Arguments
Companies with strong design systems should build internal AI prototyping tools rather than using generic ones.
Explicit premises:
- Generic AI tools don't know your design system and produce 'blurple slop'
- Stripe has a high quality bar and a well-defined design system (Sail)
- Embedding the design system via MCP + Cursor rules produces prototypes that look correct
Implicit premises:
- The quality bar for internal prototypes must match the company's shipping standard to be useful in design reviews
- The cost of building and maintaining an internal tool is now lower than the accumulated cost of cleaning up generic AI output
Lowering the barrier to prototyping transforms organizational decision-making from document-driven to demo-driven.
Explicit premises:
- Protodash lowered the barrier so designers only need 'npm run dev'
- PMs became surprise power users
- Conversations shifted from staffing questions to design quality discussions
Implicit premises:
- The previous cost of prototyping was high enough that many ideas were never prototyped
- People make better decisions when they can interact with a working thing rather than read about it
Code-based prototyping is superior to static design prototyping for exploring edge cases.
Explicit premises:
- Dashboards have many states: zero, low-volume, high-volume, different business models
- Getting all those states into Figma was 'a mess'
- In code you can 'just toggle between them'
Implicit premises:
- Edge case exploration is a critical part of good design that is often skipped due to tooling friction
- The value of code-based prototypes scales with product complexity
Narratives
- Owen observed designers in design reviews struggling with v0-generated prototypes that looked wrong (wrong nav, wrong fonts, mismatched components), leading him to build Protodash to solve the 'blurple slop' problem.
โ Origin narrative โ personal frustration driving a tool that solves a real, observed problem - Protodash evolved from a bundle of Cursor rules and React components into a full browser-based platform, with the explicit goal of requiring designers to know only 'npm run dev' and nothing else.
โ Technical evolution narrative โ shows pragmatic, iterative approach to internal tooling - Owen's initial nervousness about PMs using Protodash ('Oh my goodness, PMs designing') transformed into enthusiasm as PM adoption improved cross-functional collaboration rather than undermining designers.
โ Reversal narrative โ challenges the assumption that democratizing design tools threatens designers
Questions addressed
- โ
Why do generic AI design tools fail at companies with mature design systems?
They lack knowledge of company-specific components, producing 'blurple slop' โ uncanny-valley output that fails quality bars. - โ
How can a company embed its design system into AI-assisted prototyping?
Bundle design system components, create an MCP server for the design system, and write extensive Cursor rules that teach the AI when and how to use the system. - โ
What happens when non-designers (PMs) get access to high-fidelity prototyping tools?
Counter to initial fears, it improves collaboration โ PMs build correctly-styled explorations, communicate better with designers, and advocate for design resources with working demos. - โ
What are effective heuristics for working with AI coding tools?
Be specific in initial prompts; abandon deteriorating sessions early (slash-clear and restart) rather than falling into sunk-cost debugging.
Gaps
- incompleteNo discussion of maintenance burden. Protodash depends on Cursor rules, an MCP server for Sail, and bundled components โ all of which must track a living design system. The article does not address the ongoing cost of keeping these synchronized.
- unaddressedNo evidence beyond Stripe. The argument generalizes from a single company with an unusually mature design system, high quality bar, and engineering-heavy culture. It is unclear whether the approach transfers to companies with less-formalized design systems.
- unaddressedThe 'demos not memos' framing does not address when prototyping is premature โ situations where the strategic question is whether to build at all, not what to build. Prototypes can anchor thinking on implementation details too early.
- incompleteNo discussion of prototype fidelity confusion. When prototypes look production-quality, stakeholders may mistake them for shippable code, creating misaligned expectations about engineering effort still required.
- unaddressedThe newsletter is a curated summary of a podcast interview, meaning the extraction is working from a secondary source. Nuance, caveats, and context from the original conversation may be lost in summarization.
Closes gaps elsewhere
- Design at the Speed of AI ยท g2 โ Answers what happens to design quality/coherence when UI is generated: fidelity collapses to 'slop' unless the company design system is embedded (via MCP, Cursor rules, bundled components).
Related documents
- AI Is Changing Software Engineering. The Fundamentals Still Matter.
- Audit your Agent files
- Building AI Agents For The Enterprise
- Claude Code: Best practices for agentic coding
- How Claude Code works in large codebases: Best practices and where to start
- Design at the Speed of AI
- The Founder's Playbook: Building An AI-Native Startup
- How Anthropic Teams Use Claude Code
- JobRunr Introduces ClawRunr, an Open-Source Java AI Agent
- Just Talk To It - the no-bs Way of Agentic Engineering