Build class / The speed shop for product designers
Your judgmentAt machine speed
An eight-week build program for senior designers: stand up RollCage as your own design workbench, your taste encoded as rules, production code out the other end, and own it when you leave.
Like a framebuilding class. RollCage is yours to keep.
The Problem
AI didn't take your seat at the tableIt moved the table
Development runs at machine speed now. Prototypes in minutes. PRs in hours. Agents making interface decisions no designer ever saw.
Meanwhile designers are being told to "learn prompting" by people who have never shipped anything through a production repo. The feeds are full of confidence theater: showroom talk from people who've never had grease on their hands. The playbooks are obsolete before you finish reading them.
Here's what the whole conversation gets wrong. Speed was never the gap. Distance was. Designers already move fast; the problem is they move fast one handoff away from the software, and everything they decide has to survive the trip across that gap. Watch what actually breaks, and you'll see it every time: not a speed problem, a distance problem.
What's actually happening on the floor
- The agent builds in the dark. Design guidance never makes it to where the code gets written, so the machine guesses at what you would have decided.
- Intent dies in the handoff. What was clear in Figma gets lost on the way to implementation, and nobody notices until it ships.
- The system drifts a little further away with every iteration. Each fast pass moves the built product one more step from the one you designed.
- You see it too late to steer it. Review lands after the decisions are already in code, when correcting means rework instead of direction.
- The reasoning lives everywhere but the build. The calls that shaped the product sit in tickets, threads, and memory, nowhere near the repo where they'd actually guide the machine.
The Method
Be the driverNot the spectator
You can't make AI predictable. Nobody can, that's not the game. You drive the context, not the model. Context is everything that tells the machine where it is, what it's building, and how things are done here. It is the intelligent system you build around a chaotic engine to make the work predictable, inspectable, correctable, and cumulative. Race engines are violent, chaotic things. Finishing races is about everything you build around one.
Run that loop for a month and you have a working machine. Run it for a year and you have something better, a design codex: your judgment, made operational, torqued to spec.
When a tool changes, a model updates, or an org swaps its stack, you're not starting over. You'll know exactly what broke and exactly how to correct it. That's the difference between a driver and a spectator.
- 01
The agent makes it
A component, a page, or a working flow.
- 02
You run it
You experience it in the running product and find what's wrong.
- 03
The agent fixes it
It changes the implementation and checks it again.
- 04
The agent asks
Was that correction local, or should it become a rule?
- 05
You decide
A lasting rule is recorded only with your permission, and in your own words.
- 06
A ticket keeps the story
The goal, what was built, and what was rejected.
- 07
The next session inherits it
The next session starts from your decisions, not from zero.
Design Codex
A design asset you actually own
Your design codex is a repo. Yours. Think of it as the build sheet and shop manual for your practice, calibrated around how you actually work.
An agent starts every task with a thin slice of the world and none of your judgment. It has never seen the thousand small calls that add up to why you build things the way you do. Your codex is where that judgment gets written down, selectively, one rule at a time, until the machine can finally build like you would. Not your components copied. Your reasoning, encoded.
It runs on your judgment. It grows as you use it. It moves with you between companies, stacks, and toolchains, like a toolbox you've been seasoning for years, where every tool hangs where your hand expects it. The judgment was always yours; the codex is just where you finally wrote it down.
Your portfolio shows what you made. Your codex is how you make it: bolted down, versioned, running.
| Artifact | What it remembers |
|---|---|
| Component | An interface decision |
| Story | A visible state |
| Scenario | An operating condition |
| Recipe | The interaction behind a press |
| Test | A machine-verifiable truth |
| Rule | An approved recurring correction, in your words |
| Ticket | A goal, an outcome, or a rejected alternative |
| Provenance | How source design became code |
| Screenshot and rationale | What was observed, and why you chose it |
| Git history | Sequence, authorship, and a recoverable earlier state |
The Program
The Machine-Speed Build Class
Eight weeks. Live. Small. This is build school, not lecture hall. In eight weeks you'll build a design codex you own (Figma to generated Storybook components to agent-built, inspected, PR-ready code) and ship real components through it. You leave an operator, not a template owner.
Who it's for
- Senior designers inside AI-adopting, engineering-heavy orgs
- Design leads who need to guide agent output, not just review it
- Solo and staff designers in devtools, security, infrastructure, and complex B2B products
- Designers who are done waiting for someone to hand them the answer
How it works
You start with RollCage's example app and its matching Figma library, so you're running the full loop in week one instead of fighting your setup. Everyone runs the same reference build on RollCage (Figma MCP → your coding agent → React, TypeScript, Storybook, Vite → GitHub): one spec, so when something acts up we can all get under the same hood. From week two, your own components, tokens, and taste come in, encoded into a codex that's unmistakably yours.
- Weeks 1–2
Meet the machine
What RollCage is and how its parts fit together: a tour of the files and your first change to the example app. Then your own components and tokens come in, and provenance records how each design became code.
- Weeks 3–4
Put it under load
How RollCage validates its own work and evaluates results programmatically. Then a more mature prototype, instrumented with flows, data, and scenarios until it behaves like the real thing.
- Weeks 5–6
Test it and ship it
Product telemetry like PostHog, and synthetic user testing generated against your flows. Then publish your work, share it with your team, and set up CI so every change is checked before it merges.
- Weeks 7–8
Make it last
How the repo remembers rules, tickets, and decisions, and how to design so the next session starts from them. Then the final class.
Start Here
Good designers should be winning right now
The machine got fast. Your judgment is what makes fast good. Stop renting your relevance to whoever writes the next hype thread. Build the machine that carries your taste into everything you ship, and take it with you wherever you go.
The build class is small on purpose. Bring your judgment, we'll build the machine.
- Individual · $1,800
The build class
For a designer who wants to learn the method or sharpen it. Eight live 90-minute sessions in a cohort of ten or fewer, starting Thursday, January 14. RollCage included, with twelve months of updates and support.
Request a seat - Team pack · from $5,000
Your team, your product
For a company with two or more designers. The same eight sessions, taught in your own environment. RollCage is integrated with your product and infrastructure. Scheduled around your needs. Two seats from $5,000 with more enablement available.
Ask about a team pack
Questions
Straight answers
- When does it start?
The next build class starts Thursday, January 14. Eight weeks of live sessions, Thursdays at 5:00pm Pacific, 90 minutes each. Small on purpose. The founding cohort is underway now. A team pack is scheduled with your team and can start anytime.
- Can I do this alongside a full-time job?
Yes, it's built for working designers. One 90-minute live session a week, Thursdays at 5:00pm Pacific, plus about 2 hours of shop time on your own build. Every session includes lab time, so you're building with the group, not just listening. The loop is designed to run in the gaps of a real job, because that's where you'll run it afterward.
- What does it cost?
The build class is $1,800 a seat, with RollCage and its twelve months of updates and support included. A team pack for two designers starts at $5,000: the same eight sessions on your schedule, taught in your own environment, with RollCage integrated with your product and infrastructure.
- Is RollCage included?
Yes. Every seat includes RollCage. You install it in week one, run the whole class on it, and keep it when the class ends. It isn't on sale on its own yet.
- Will my employer pay for it?
Often, yes: many orgs have AI-enablement L&D budget waiting for exactly this. For an individual seat, reply to your acceptance email and we'll send an invoice and documentation your finance team can work with. To train a team, your company buys a team pack directly.
- What do I need to bring?
- MachineA Mac with Apple silicon, on macOS 13 Ventura or later, and an internet connection. Intel Macs and Windows aren't supported.
- Coding agentClaude Code, Codex, Gemini CLI, or Grok Build on your own account, on a plan above the standard paid tier. An API account works too, but only choose it if you already know how to watch a meter.
- FigmaYour own account. A free one works, but a paid seat is recommended: the free plan allows only three files and a handful of agent reads a month, and you'll want room for scratch projects.
- GitHubA free account, for publishing and sharing in week six.
- RollCageIncluded with your seat. A Mac app that installs its own tools and your coding agent, then sets up your workbench with the reference stack: React, TypeScript, Storybook, Vite. You install it in week one. Setup is part of the curriculum, not a prerequisite.
- EditorOptional. RollCage starts what you need, and your project is an ordinary folder you can open in any editor.
For an individual seat, one rule: personal accounts, not work accounts. A team pack runs on your company's own accounts and environment.
- I'm not technical. Is this over my head?
If you can maintain a design system, you can run this machine. You will not be writing the code. You'll be grounding, inspecting, and correcting the machine that does. That's a design skill.
- What's available after graduation?
Every good shop has the regulars: the people who show up on Saturdays, swap parts, and help each other chase down the weird noise. That's the Guild.
The tools will change again next quarter. To an operator that's not a threat. It's the sport. The Guild is where your codex keeps growing after the cohort: monthly modules that extend the machine (environments, docs sync, re-grounding RollCage on a new stack), breakage reports when platforms shift, codex reviews, and a working crew of designers who run at machine speed. Open to cohort alumni.