Build class / The speed shop for product designers
Your judgment at machine speed
An eight-week build program for senior designers: stand up RollCage as your own design workbench, your taste encoded as rules, PR-ready 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 table It 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 driver not 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
You make it together
You and the agent build a component, a page, or a working flow.
- 02
You run it
You use it in the running product and decide what it needs.
- 03
You shape it
You direct the change. The agent writes it and checks it again.
- 04
The agent asks
Was that change for here only, 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 Storybook components to PR-ready code, designed with your agent) 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: a React workbench on TypeScript, Storybook, and Vite, with Figma connected to your coding agent and GitHub for sharing. 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 your agent records how each design became code.
- Weeks 3–4
Put it under load
How RollCage checks the work: types, tokens, tests, and accessibility in every state. Then a more mature prototype, instrumented with flows, data, and scenarios until it behaves like the real thing.
- Weeks 5–6
Test it and share it
Every page before and after a change, in every state, with the evidence gathered for your call. Then publish your work through GitHub and share it with your team.
- 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, online 90-minute sessions in a cohort of ten or fewer, starting Thursday, January 14. RollCage included.
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