David MonsonTalk to me

Every designer, PM and engineer moved onto the AI platform I built.

In 2026 I took SchoolAI's product org off Figma and into real code. Lightspeed reached 100% adoption, the team built 36 prototypes in its first month, and the company dropped a $45K Figma contract. Here's how I built it, and the decisions that made it stick.

Lightspeed, at SchoolAI. Head of Design. I set the direction and built it with Claude Code. 2026.

What happened.

Every designer, PM and engineer moved onto it. The team built 36 prototypes in the first month. The company dropped Figma and its $45K contract. It's still how SchoolAI builds product.

These numbers come from the system itself, as of early October 2026.

100%Of designers, PMs and engineers on it
36Prototypes in its first month
$45KFigma contract the company dropped
57 to 1Railway projects. One per prototype became one platform
The Lightspeed home screen: a grid of prototype cards from the design team, newest activity first. Owner names are blurred.

The front door. Every prototype the team built, newest first. I blurred the names.

Designers drew pictures while the product got built in code.

Our designers worked in Figma and our engineers worked in code, so every handoff lost detail and time. We'd started prototyping with Claude Code, and it was fast. It also made a new mess.

Each prototype ran in its own container, on its own Railway project. We got to about 57 of them. A running container costs money, so a prototype was set to expire after 24 hours, and any feedback went with it. Research took one path and comments took another. Nothing made anyone write down what would count as working.

In June 2026 I put two lines on the design roadmap. Share Claude prototypes. And have designers build at production level in Claude Code, so we hand engineers finished UI instead of a design artifact. Lightspeed is how those two lines got done.

A static build is a folder of files. Storing it costs pennies. So a prototype never has to die.

That one change in the math made the rest possible: permanent links, version history, comments pinned to the exact build someone was looking at, recorded research you could come back to. None of that works while a prototype disappears overnight.

Three repos, one system.

It's production software for internal users, and it holds the line that keeps unreleased design work away from competitors. So I built it to that standard.

1. Type one command/build-prototype in Claude Code, Codex or Cursor. They all read the same rules.
2. Agents build on a branchA prototype is a branch of the sandbox: our product's frontend, recreated with mock data and no backend. It never gets merged.
3. Push is publishCI builds a frozen static artifact, scans it against the design system, writes the engineering handoff and registers it. There are no drafts.
4. Lightspeed serves itEach build gets its own hostname. Comments, recording, crit and dev mode get added at serve time.
5. People reactTeammates open a link. A teacher gets a named link that expires. Everything lands in one feedback queue.
6. The agent reads it all backThrough an MCP server, so the next session starts with what people said.
20Tools on the MCP server. 18 read, 2 write
1Command anyone has to remember
10Dimensions an isolated critic scores on every brief
77Design-system scans recorded across 36 prototypes
3Repos working as one system
85Component schemas agents read before they build
9Rounds of dev mode fixes from real use
2,549Tests in the required CI gate, by September 10
One of my own prototypes on its own host. Comment mode, then dev mode. Everything around the screen is added when the page is served, so the prototype's code never changes. Mock data.
The sandbox
I had an agent click through the live product and recreate what it saw. Same design system, mock data, no backend allowed. A parity skill keeps it honest against the real product.
The registry
Every build is stored by its commit and stays forever. A bare link opens the newest build. A test link stays pinned to the build it was made from, so a study holds still.
A hostname per build
Prototype code can't read a Lightspeed session or call its API, because the browser itself won't allow it. I didn't want safety to rest on a header being right on every response.
Serve-time injection
Commenting, session recording, crit and dev mode work on every build, including old frozen ones, without touching prototype code.
Security rules
Sign-in through the company's Google Workspace. Access is checked in the handler that serves the bytes. No access means a plain 404, so nobody can confirm a prototype exists. A customer never sees the word Lightspeed.
Claude as a gate
A read-only Claude Code review checks prototype branches before they can deploy. It looks for secrets and for screens that collect sensitive data. A teammate tested it with branches built to trip it.
One Railway project
Next.js service, Postgres and an artifact bucket. Migrations run before new code takes traffic, and a failed one blocks the deploy.
Design knowledge
A repo I owned: 85 component schemas, the design rules and a product design skill. Both the sandbox and Lightspeed pin it at a tag, so agents read the same rules everywhere.
Three test gates
Type check, the full test suite against a real Postgres, then a production build. Anything added to a prototype also gets driven in headless Chrome with real mouse and key events.
Rules for agents
One short AGENTS.md that Claude Code, Codex and Cursor all read. Never merge a prototype branch. Never push to main. Design system only. Every one of those rules was broken by an agent in the week before I wrote it down. A test fails if the file names a path that no longer exists.
Decision docs
About 40 short records of why things are the way they are, each with a last-verified date. They're memory for people and for agents. A change that contradicts one has to update it in the same pull request.
A Lightspeed prototype page for a video game builder, with a cover, summary, chips for brief, Figma and design system, and a band of variants.

A prototype's home. What it is, whether it has a brief, whether it's clean against the design system, and every variant. The teacher and district in the mock data are made up.

An agent in your terminal can read all of it.

All the feedback was already in Postgres and on a screen. But the agent in a designer's terminal couldn't reach it, so the designer had to paste it in. I wanted anyone to be able to ask Claude "what's the latest feedback?" and get crit, comments and tests back from any prototype.

I chose MCP over a command-line tool for one reason. Claude Code, Codex and Cursor all speak it, and all three read a config file committed to the repo. Register the server once, and every session anyone starts can already see the feedback.

Then I added the part I care about most. Lots of feedback is poor, and I didn't want agents building on all of it. So the tool that writes a fix brief refuses to run until a person has recorded their choices.

1. Open a session"Since your last push: 4 comments, 1 crit, 2 test sessions. Want me to work through those first?" One line, then it waits.
2. Get one listget_feedback merges comments, crit findings, design flags and test notes into one numbered list.
3. The owner decides"1 to 5 yes, 6 no, 7 tweak it, 8 to 10 yes." That's the real example I wrote into the spec.
4. Record itrecord_decisions saves the choice, with the person's name on it.
5. Only then, a briefget_fix_brief covers only what was taken. Ask early and it says to record decisions first.
6. Fix and pushThe agent works from that brief. The push goes live, and the next round of feedback starts.
This prototype
What was built, what testers and reviewers said, the handoff, and how far the code strays from the design system.
Every prototype
Where builds keep going wrong across the whole registry, and what designers flagged that the scanner can't see.
The design system
What a screen should be, read from the same knowledge the sandbox builds against.
Two writes, on purpose
Both record a person's judgment. No tool can post a comment, make a share link or publish. Those are things a person does with their name on them.
Full transcripts
Tools return all the words from a session. A 140-character excerpt is fine for a person scanning a list. It's how a model turns eight sessions into eight opening remarks.
Honest about gaps
Every list says how many it returned out of how many. A build with no report answers "not analyzed," never zero, because zero is a claim about the code.
Locked down
A credential minted from a browser you're already signed into, so nobody copies a token around. Guest tokens and browser cookies are refused. Suspended accounts are rechecked on every call. 120 calls a minute per person.
Notion as the brain
Briefs and product work live in Notion, in a shared product briefs database, and agents connect to it. They also connect to a custom app we built that holds company goals and priorities for the year and the quarter, and check work against it.

Then I made the agents argue with us.

Most of what goes wrong with a prototype goes wrong before any code exists. Nobody wrote a brief. Nobody argued about the problem. Six weeks later there's a demo, everyone nods, and no one can say if it worked because nothing was ever claimed.

So I wrote a set of adversarial skills that push hard on the problem, the solution, the customer and the business value. They come before the build, and they refuse to write code while they run. Every push borrows a real test from a well-known operator or investor, and says whose test it is, so a PM takes the second push seriously.

BaselineAn isolated critic scores the idea as stated, before any workshop, and says the three worst dimensions out loud.
/write-briefEleven forcing questions: the customer's sentence, evidence, why now, a hypothesis that can be wrong, the riskiest assumption and its cheapest test, a pre-mortem.
/review-briefOne sitting. The problem, then the metrics with real Hex charts, then a walk through the idea as fifteen different people: teachers, students, admins and the engineer who'd receive it.
Build, with an auditA separate agent with no build context reviews the screen. More on that below.
/analyze-resultsReads the sessions, the comments and the number against the brief's own target and failure line. Then it scores again.
/executive-product-reviewTurns an exec meeting transcript into a numbered list with a recommendation and a cost on each item. It builds nothing until the owner picks.
The critic wasn't in the room
The facilitator has been arguing for twenty minutes and is the last one who can judge the page. So a fresh agent scores it 0 to 10 on problem clarity, evidence, persona, a falsifiable hypothesis, metric rigor, riskiest assumption, scope, why now, the pre-mortem and writing.
A score travels with its baseline
A lone number reads as a grade on the writer. Before and after is a statement about what the workshop did. So no screen shows one without the other, and nothing ranks people by it.
"A score that only ever goes up measures nothing"
That's from my own design doc. I wrote down what would prove this wrong: baselines drifting down to game the delta, or no brief ever falling across two quarters. In that second case, delete the score.
Falls show in amber
A red chip on someone who added a section this morning teaches them to stop running the critic. That costs you the measurement and fixes nothing.
A bad score never blocks a build
An agent wrote that JSON, not the designer. Stopping someone's push over a score card punishes the wrong person. The bad reading gets dropped and counted.

Every build gets checked against the design system.

Agents write fast and drift fast. So every build runs the design system's analyzer against what changed and attaches a report: a chip beside the brief, a count on each variant, a page of every violation, and the same data over MCP. One button copies a fix prompt for Claude.

The self-healing part happens during the build. A separate agent with no build context reviews the diff in three passes: is this the right model for the person, does the screen hold up to a crit, does it match the system. Every finding goes back and gets fixed, then a fresh agent audits again. It stops at three passes and tells the owner what's left. That isolation matters, because the agent that took a shortcut has already talked itself into it.

I also record every scan, so we can see themes across prototypes. A mistake in nine prototypes is a documentation problem. The same count in one is a branch. Read these numbers as a starting baseline from one month.

Design system dashboard: 77 scans recorded, 36 prototypes covered, 3,975 violations on latest builds, 65 median per latest build, 14% first-pass rate, with a stacked chart of violations per week. A report for one build: 229 violations in 27 of 48 changed files, with chips by rule, and a blue button reading Copy fix prompt for Claude. Where it fails: violations by type and by category, each with a count of prototypes.
Top messages from the analyzer. The top one is Overrides visual styling on a design system component, 2,282 times across 30 prototypes.
The analyzer's exact words, with how often each came up.
Style overrides: 2,282 across 30 prototypes
The most common mistake by far. Agents kept restyling components instead of using them. That's a skill and documentation fix, and now I could see it.
14% clean on the first scan
5 of 36. This is how often a build arrives clean, and it's the number I'd push hardest on next.
Flags for what scanners can't see
A screen can pass every rule and still use the wrong component. So a designer can flag an element where they're already pointing at it, and those flags reach agents too.

Then I went after everything we still needed Figma for.

A team won't leave a tool because you tell them to. They leave when the new one does the job. Designers needed to inspect and measure. Engineers needed the spec. Everyone needed to look at the same thing together. Once all of that lived in Lightspeed, there was no reason to keep paying for it, and the company dropped Figma and its $45K contract.

Dev mode on a prototype. A card is selected, and a side panel shows the component name, Copy JSX and Copy for agent buttons, the layers tree, layout values and code.
Dev mode, on any build with Option+Shift+D. Component, layers, layout, source, Copy JSX and Copy for agent.
Dev mode, nine rounds
I studied Figma's gestures and Chrome's inspector, then used it on real prototypes and kept reporting what broke. "Dev mode is struggling to select components." "I'm seeing all sorts of decimals." Each round got reproduced in a real browser and fixed.
"The developers are saying they want, like, copy JSX"
So I showed it to engineers and listened. Copy JSX came from that. So did hiding library internals in the tree, which came from the engineer who owned the design system package.
Tokens first
Every value shows the design token before the raw number, so a designer's intent reads in an engineer's words.
Copy for agent
A self-contained prompt for whichever agent you have open. It replaced editor buttons that took three rounds of plumbing and did nothing anyone wanted, so I deleted them.
The handoff contract
Every screen is three files: a pure view, a typed contract listing every state it can be in, and a mock container. An engineer replaces the container. The view doesn't change. The build writes a handoff document, with a button to copy it for engineering.
Part of a prototype page: an empty test section that says nobody outside SchoolAI has seen this yet, an activity section, and a handoff section with a Copy for engineering button.
Empty states say what's true. "Nobody outside SchoolAI has seen this yet."

My first crit tool failed in front of the team.

We do design crit often, and I wanted it inside the platform. The first version copied the presenter's clicks onto everyone else's browser. It demoed well. In a real crit, people landed on different screens, menus didn't open, and clicks hit the wrong thing.

The design itself was wrong. A prototype has its own timers, animations and layout, and everyone's window is a different size, so one missed click puts someone off for good.

So I threw out the model. The presenter's browser is now the only one that changes anything. Everyone else watches a live stream of it, with a comment layer on top. We ran a real crit on the new version on September 17, and it failed in ten places at once. We reproduced each one in a two-browser test harness and fixed it. The model held.

One queue
A crit is thirty comments in twenty minutes from a room of people. It goes in the same queue as research and comments. The database already knew who was staff and who was a guest, so I didn't need a separate path.
Every recording gets words
Crits, research sessions and voice notes all get transcribed with timings. You can click a line to jump there, or search what people said.
Findings, with Claude
Claude reads a crit transcript and pulls out each ask, question and decision, who said it, and what their cursor was over at that moment. My note on it: "do NOT just auto-apply and fix." The designer gets a list and chooses.
Live tests
A named link that expires, a confidentiality gate, then camera, microphone and screen recording. Each tool can be turned off when a test runs through an outside research platform.

How a whole org actually moved.

Adoption is the job. Nobody cares about your platform until it's the easy way to do their work, so I kept taking steps away.

I started with people who had the pain
My own design team, already building in Claude and stuck with prototypes that expired.
The org already had practice
In January 2026, I'd owned an eight-week push across all of product, design and engineering. One goal was learning Claude Code as a team.
Setup is one command
A start page gives you one command that clones the sandbox and signs your agent in, for Claude Code, Codex or Cursor. You approve in the browser you're already signed into. There's no token to copy.
One command to remember
There used to be eleven steps in a line, and people don't work in lines. Now /build-prototype opens a menu and runs the right path. You can jump ahead, but you never have to.
Looking takes nothing
A colleague opens the link. Teammates don't need a grant, a seat or a setup.
I moved the rituals
Crit and research happen on Lightspeed. Once your team's reviews live somewhere, you're there too.
Engineers got a reason
A prototype became the best reference they had, and dev mode gave them the component tree and the code. Handoff stopped being a picture to rebuild from.
PMs got a reason
The brief workshop runs in Claude and writes to Notion, where they already worked. PMs built on the platform too.
Complaints got fixed fast
When a designer said it was "loading SUPER slow," I had an audit done with real measurements, and three fixes followed. People keep using a tool that listens.
People kept the credit
An agent never owns a prototype. Ownership always goes to the person. Nothing ranks anyone. Nobody has a reason to fear the data.
Figma went last
The contract ended after the team had moved, so nobody lost a tool they still needed.

What people built on it.

36 prototypes in the first month, and most weren't mine. At the start of October, five of them were. That's what I wanted. The platform was my work. The prototypes belonged to the team. All of these are explorations with mock data, so don't read them as shipped features.

The Lightspeed home screen, a grid of the team's prototypes. Colleagues' names are blurred.

36 screens from what the team built, circling the home screen they all live on. Mock data throughout. I blurred students' and colleagues' names.

Results for a review game: 81% class mastery, mastery by standard, and the questions missed most.
Video game builder. A teacher turns a unit into a review game and sees results by standard. Mine.
A worksheet's insights page: class average of 79%, results by outcome, and written insights.
Worksheet loop. Print it, scan it back, get insights. I started it, a designer took it furthest.
A Today landing page for a teacher, with recently launched activities and a Create something section.
A Today home for teachers, from the same loop.
Assessment results: a chart of student performance, questions sorted by difficulty, and what's worth your time.
Assessment results, by question and by student. Built with a designer on the team.
A productive struggle map placing students, shown as initials, in four quadrants, beside summaries of their answers.
Pulse Check. A homeroom check-in with a map of productive struggle. Built with a designer. Initials are made up.
A unit builder for The Water Cycle, with a learning destination, journey balance and a draft unit.
Unit journeys. A teacher's builder with a 19-format activity library. Built with a teammate.
A student home called Backpack, with classes, personal files, a schedule and upcoming work.
Student Backpack, a home for a student's classes and work. A designer's.
A Space editor with an AI chat bubble that asks what the teacher wants to change.
Space editor chat. Say a change in plain words, and the right field gets rewritten, with undo. A designer's.
A single sheet asking what do you want to create, with Space, quiz, presentation, flashcards, exit ticket, mind map and podcast.
Flattened Create. One sheet instead of a multi-step flow. Mine.
A Discover page arranged around this week's subjects from the teacher's own curriculum.
Personalized Discover, ordered by what a teacher is teaching this week. Mine.

Also on the registry: a paced curriculum builder, settings rebuilt as one nested sheet, launching a Space to a rostered class, file uploads and named sources, sources inside chat, a web trigger for the AI Notetaker, a what's-new spotlight, a safety alert drilldown for districts, and a thinking state for Dot.

It moved quickly.

June 2026
Roadmap: share Claude prototypes, and have designers build at production level.
Mid-August
Team prototypes start on the sandbox. The plan for going live gets written.
August 24
One feedback queue, instead of separate paths for research and comments.
September
Live at its own address, with sign-in and DNS. CI becomes required.
September 9
Brief scores recorded on the prototype page.
September 15
"There should be no drafts." A build is current the moment it exists.
September 17
Design-system reports, the performance audit, and a real crit on the rebuilt version, which failed in ten places.
Late September
MCP reaches 20 tools. Feedback review ships, with the owner's choice required.
By October 1
Crit fixes landed. Everyone follows a live stream of the presenter's screen.

What went wrong

How I'd run this at another company.

You don't need my code. You need the same few moves, in the right order. I'd build it with your people, in your repos, and they'd own it when I'm done.

1. Find the wasteSit with the teams. Count what's real, like our 57 Railway projects. Take baselines before anything changes, starting with time from idea to testable prototype.
2. Recreate your frontendLet an agent click through your product and rebuild it with mock data. Now anyone can build on something real, safely.
3. Write down your standardsYour design rules and component schemas, in a form agents can read. Add a rule each time an agent breaks one.
4. Make permanence freeStatic builds, a hostname per build, one registry, real sign-in. Security comes in on day one.
5. One commandRun setup and build from one command, and let the skills ask the hard questions. Adversarial review belongs before the code.
6. Close the loop with MCPGive the agent your feedback, your docs, your goals and your numbers. Make a person choose what gets acted on.
7. Move the ritualsHold reviews and research there. Then give engineers something they'll ask for by name.
8. Then cut the old toolOnly after people have moved. Measure who's using it, and report the numbers that don't flatter you too.
What I'd do earlier
Get engineering to commit to a shared frontend, so the view file that a designer builds can be the one that ships. Require CI from the first day. Batch deploys. Run a real crit in week one, before the demo convinces you.
What I'd keep exactly
A person chooses what gets built from feedback. Scores never rank people. Agents can read nearly everything and write almost nothing.
Who did what
I led the design team, set the direction and built the platform with coding agents. Engineers built the design system package. An engineer set up DNS, certificates and credentials. Designers shaped it by using it every day.

I can do this with your team.

If you want your whole org building with AI, in real software, I'd start by sitting with the people doing the work.

Start a conversation