Brian Lovin: Code Prototypes Over Figma for AI Design
Designers must prototype AI interfaces directly in code to grasp real behaviors, as Figma mocks fail to capture agentic workflows—Brian Lovin's Notion playbook.
Prototyping AI Means Building Agent Harnesses, Not Figma Mockups
Brian Lovin, a designer at Notion, shares how his skepticism of AI evaporated after joining in January 2025. Assigned to "app builder"—an ambitious project to let AI generate custom apps inside Notion using databases, charts, and agents—he initially mocked interfaces in Figma. Reality hit fast: models were slow, error-prone, and needed clarifying questions, making static designs useless.
"From that moment on, it's just changed the whole way you work. Like as soon as you realize you can't design half of this stuff in Figma, what you're really designing is the harness for the agent to do longer things and verify its own work."
He built an internal "prototype playground": a shared codebase with Notion-like components (sidebar, buttons) using AI SDKs like Vercel's for structured outputs and tool execution. Designers test models, simulate Notion environments, and iterate. Fidelity varies—low for quick ideas, high-fidelity recreations (e.g., Will Dawson's inline AI editor with slash commands and real-time updates) to prove concepts. Now, 10-20% of the team prototypes in production codebases, enabled by AI-legible infrastructure like skill files and CI pipelines.
This shift exposed agent evolution: Notion rewrote its harness three times in a year, simplifying to script-writing and search. Brian predicts more changes—skills and long prompts may obsolete soon. Designers push current model limits, shipping "vibe-coded slop" betting on upgrades, while early adopters tolerate imperfections.
Workflow Evolution: From Pixels to Deploy Previews
Notion's design process adapts every six months. Brian's offsite preview (October 2024) impressed with rapid high-fidelity Figma prototypes from feature mashups (e.g., AI + chat vs. formulas + permissions). Post-onboarding, collaboration moved from Figma links to deploy previews or playground pokes—duplicate prototypes, yoink interactions.
Tools flipped expectations: Go-wide explorations use Conductor in Paper; details happen in code. AI sucks at pixel-perfect finish, so Brian codes polish manually. Figma persists for 2D sketches, TLDraw for whiteboarding, but code dominates interactive AI flows like voice feedback (pinned for better models).
Team density accelerates learning: in-person crits, engineer brain-dumps on model diffs. Brian restarted Cursor for coding after a break, pairing with Conductor. Frontend experiments include Agentation and Dialkit for rapid components.
"I think that's probably a good place to be right now as a designer is really understanding what's possible, trying to push the edges even if it sucks and you get stuck."
Shiori: Hands-On AI Bookmarking Without Magic
Brian's side project, Shiori (shiori.sh), tests AI limits. Users describe needs (e.g., "track design tools, tag by category"); AI generates a tailored bookmark manager with search, tags, and Notion-like views—no code required.
Built with Claude, it highlights non-magical AI: iterative prompting, error-handling, user verification. Brian emphasizes transparency—show agent steps to build trust. Early users (e.g., Max Schoening's "nerd snipes") refine it. Trade-off: fast MVPs vs. polish; AI enables solo shipping what once needed teams.
This mirrors Notion's shipped slices: app builder became Notion Agent, custom agents, workers (host code for agents).
Blurring Roles: Designers as Fluid Builders
AI blurs designer/PM/engineer lines. Brian warns against title obsession: "Our obsession with titles is what will screw people over... These things are going away. Like all this stuff is getting very, very blurry. It's getting very, very easy to move between those disciplines."
Stay relevant by fluidly switching mediums, absorbing trajectories (not snapshots), and questioning core products—like issue trackers reimagining roles (nod to Karri Saarinen). At AI-forward Notion, everyone tinkers; barriers drop as codebases AI-optimize.
"In the same way, it would be crazy for a company that did issue tracking or note taking to not take a hard look at themselves in the mirror... It would be crazy for designers today to not be doing the same thing."
Key Takeaways
- Build a prototyping playground: Shared codebase with app-like components to test AI behaviors beyond Figma.
- Prototype in production code for high-fidelity AI interactions; start low-barrier with Cursor/Conductor.
- Design agent harnesses (scripts, search, verification) over perfect UIs—expect 6-month rewrites.
- Use AI for go-wide (Paper/Conductor), code for polish; tolerate slop from early adopters.
- Ship side projects like Shiori to experiment: Prompt iteratively, expose agent reasoning.
- Ignore titles; fluidly move between design/code/PM as AI blurs boundaries.
- Push model edges, learn from engineers, bet on trajectories over current quality.
- Collaborate via deploy previews; yoink from peers' prototypes.