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.
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.

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.
/build-prototype in Claude Code, Codex or Cursor. They all read the same rules.- 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.mdthat 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.
- Claude CodeBuilt the platform and every prototype
- Codex, CursorSame rules, same skills, same MCP config
- Claude APIPulls crit findings out of transcripts
- MCPStateless server over HTTP
- Next.js 16, React 19App, API and every runtime host
- RailwayHosting, deploys, health checks
- PostgresRegistry, comments, scans, scores
- Object storageFrozen builds, keyed by commit
- rrwebSession recording and live crit
- DeepgramEvery recording becomes searchable words
- @sai/uiThe design system, built by our engineers
- GitHub ActionsBuild, scan, publish, security gate
- NotionThe product brain
- HexReal metric charts inside brief reviews
- Google WorkspaceSign-in for staff
- Headless ChromeBrowser harness with real input

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.
get_feedback merges comments, crit findings, design flags and test notes into one numbered list.record_decisions saves the choice, with the person's name on it.get_fix_brief covers only what was taken. Ask early and it says to record decisions first.- 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.
/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./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.

- 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, 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.

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-prototypeopens 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.
36 screens from what the team built, circling the home screen they all live on. Mock data throughout. I blurred students' and colleagues' names.










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
- I can't give you a before-and-after on time to a testable prototype, because I didn't measure it before we started. I'd fix that first next time.
- The brief scores barely got going. When I last checked, 3 prototypes had a score and none had both a baseline and a later reading. The platform's Metrics page said so at the top, and it marked the rest of its numbers as invented placeholders.
- The first crit design was wrong and it took a public failure to prove it. The second one still broke in ten places on its first real run.
- The app got slow fast. The most-visited page was shipping the whole registry twice on every render, 3.4 MB in my test rig. At one point we were also deploying every 17 minutes onto cold containers. Three fixes followed, and the first one cut that page by 90%.
- Before I required CI, two pull requests merged cleanly and broke
mainfor an hour with no warning. CI is required now, and it takes about 12 minutes. - Builds showed up with no owner, or the wrong one, because of how Git identities and our own button worked. It took three separate fixes.
- Agents broke every rule I hadn't written down yet.
- A prototype is still a recreation of the frontend, so an engineer still rebuilds it. The handoff contract was an opt-in pilot, and the tool that would import a prototype into production wasn't built. It needs engineering's refactor and read access to their repo. This is the biggest gap left.
- The self-healing stops at the build. The loop that would read themes across all prototypes and improve the skills and docs by itself was deliberately left for later.
- As of late September, crit findings were waiting on a production API key. A credential can hold up a feature as easily as code can.
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.
- 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






































