Your rules
The agent guidance that encodes how you make interface decisions.
Speed Shop / Living Design Codex
Your judgmentAt machine speed
An eight-week build program for senior designers: stand up your own AI design rig, your taste encoded as rules, production code out the other end, and own it when you leave.
Like a framebuilding class. The rig is yours to keep.
Living Design CodexOperator Mode
CoreDesign Judgment
Rules
Patterns
Taste
Agent Output
Decision History
GroundInspectEncode
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 living 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
Ground the machine
Give agents real context: your interface system, your intent, your constraints, your examples.
- 02
Let it run
Agents generate; you don't babysit.
- 03
Put it on the dyno
Structured inspection surfaces: generated Storybook stories where every state is visible and drift has nowhere to hide.
- 04
Read the failure
The missing rule. The wrong assumption. The taste call the machine couldn't make. Name it precisely.
- 05
Encode the fix
Every correction becomes a rule, an example, a constraint in your codex. Nothing gets fixed twice.
- 06
Run it again
The machine gets sharper. Your judgment gets leverage.
Living Design Codex
A design asset you actually own
Your living 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.
Your patterns
Components, states, and interaction models expressed so machines can build with them.
Your taste
Examples, critiques, and corrections that teach the system what good looks like to you.
Your decision history
What changed, why, and what the evidence was.
Proof
This isn't a theoryIt shipped
I spent a year building this method independently (my own rig, my own repos, my own rules) and then connected it to a live development environment, where it produced passing PRs in the production repo of a professional cybersecurity company.
Not a demo. Not a sandbox video. An independently built machine, rolled into someone else's codebase, meeting production review standards. Built in the garage, finished on someone else's track.
That's the whole thesis proven in one motion: a living design codex you build and own can travel into a real engineering environment and hold up. Everything in the program comes from that experience: where agents drift, what guidance actually holds, what inspection catches, and how a codex matures without seizing into an unmaintainable pile of rules.
Full walkthroughs inside the program use Machine-Speed Designs' own repos and demo environment, the same rig, shown end to end.
The Program
The Machine-Speed Founding Cohort
Eight weeks. Live. Small. This is build school, not lecture hall. In eight weeks you'll build a living 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 the Machine-Speed Wireframe System, a Figma design system pre-tuned for agent consumption, so you're running the full loop in week one instead of fighting your setup. Everyone runs the same reference build (Figma MCP → Claude Code → React, TypeScript, Storybook, Vite → GitHub): one spec, so when something acts up we can all get under the same hood. In the back half, the training wheels come off: your components, your tokens, your taste, encoded into a codex that's unmistakably yours.
Weeks 1-2: Meet the machine
How agents actually work (context, tokens, why they forget your design system mid-build) and how Figma's knobs translate into requirements a machine can build from.
Weeks 3-4: Run the loop
Agent attempts, dyno-style inspection, reading what drifted, then encoding every correction and watching the same machine produce better work because you made it smarter.
Weeks 5-6: Your build
Your components enter the machine. Full variant and state coverage, generated Storybook stories, and the taste layer: the rules only a designer can write.
Weeks 7-8: Race trim
Inspection discipline, design-authored PRs, decision logs, plus breakage drills, where things fail the way reality fails them and you learn to read exactly what let go and which rule fixes it.
Graduation: a full loop, run unassisted, on a component you've never touched. Same bar I held myself to before I trusted my machine near a production repo.
What you leave with: a living design codex in your own repo, the operating skill to keep it running through tool and model churn, and a crew of designers building alongside you.
The founding run is live and deliberately small: you get the method straight from the person who built it, and your reps shape the program everyone after you gets. A self-paced version with weekly office hours follows; founding members get it included.
The founding cohort starts Thursday, September 3. Live sessions Thursdays at 5:00pm Pacific, 90 minutes, every one with lab time so we all get under the hood together.
Founder
Built by a designer who builds machines
I'm Alex Sulgrove, founder of Machine-Speed Designs.
I've spent 15+ years designing software where the systems are dense and the stakes are real: cybersecurity, cloud infrastructure, SecOps. I've led UX teams, run solo design functions, and shipped inside engineering-heavy orgs the whole time.
I also build machines. That's my Jeep up there, my first car, and I've been rebuilding it most of my life: bolt-ons, then mechanical work, then cutting into the frame with a plasma torch. Nearly every system has been replaced. One of the only original parts left is the steering column, and that's not an accident. The whole machine has changed around the place where the driver holds on.
That instinct got serious in 2014, when I co-built and co-drove car #4526 to a 12th-place finish at the King of the Hammers Everyman Challenge. Nothing teaches mechanical sympathy like driving 70 mph over terrain that's trying to break you.
A machine only rewards the builder who grounds it, inspects it, and fixes what breaks. That lesson is under everything I do, and the rig I built (the one that shipped into a real production repo) came straight out of it.
So here's what I'm actually offering. I'm not teaching you to drive my machine. I'm teaching you to build your own and keep your hands on the wheel, because the tools will change a hundred more times and the one part that shouldn't is you.
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 founding cohort is small on purpose. Bring your judgment, we'll build the machine.
Request a founding seatQuestions
Straight answers
- When does it start?
The founding cohort starts Thursday, September 3. Eight weeks of live sessions, Thursdays at 5:00pm Pacific, 90 minutes each. Small on purpose.
- 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?
$800 for the founding cohort, and founding members get the self-paced version included when it ships. This is the lowest the price will ever be; your reps shape the program everyone after you gets.
- Will my employer pay for it?
Often, yes: many orgs have AI-enablement L&D budget waiting for exactly this. Reply to your acceptance email and we'll send an invoice and documentation your finance team can work with.
- What do I need to bring?
- MachineA Mac is easiest. Windows works too, through WSL (the Windows Subsystem for Linux). Plus an internet connection.
- ClaudeMax 5x is the recommended subscription. An API account can be used, but only choose it if you already know how to watch a meter.
- FigmaA full paid seat plus the desktop app.
- GitHubA free account.
- EditorVS Code or anything that works with Claude Code. The terminal alone is fine.
- Everything elseReact, TypeScript, Storybook, Vite, the whole reference stack comes pre-configured in the cohort repo template. You clone it in week one. Setup is part of the curriculum, not a prerequisite.
One rule: personal accounts, not work accounts.
- 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 (synthetic user testing with Playwright, API mocking, CI and environments, docs sync, re-grounding your rig 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.