Your rules
The agent guidance that encodes how you make interface decisions.
Speed Shop / Living Design Codex
Your judgmentAt machine-speed
AI-assisted teams ship faster than designers can review, redline, or hand off. You can watch it happen — or you can build the machine that carries your intent into every change.
Machine-Speed Designs is a speed shop for designers. We help you build a living design codex — an operating system of rules, patterns, taste, and decision history that drives AI agents, catches drift, and gets sharper every time you run it.
It lives in your repo. It runs on your judgment. It goes where you go.
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.
The tools will keep changing. The models will keep changing. A static playbook decays.
What doesn't decay is a designer who can run the machine — and fix it when it breaks.
What's actually happening on the floor
- Agents build from incomplete or missing design guidance — so they guess.
- Design intent survives the Figma file and dies in implementation.
- Interface systems drift a little more with every fast iteration.
- Review happens after the fact, if it happens at all.
- The decisions that shaped the product live in tickets, threads, and somebody's memory.
- Everything a designer builds to fix it belongs to their employer the day they leave.
The Method
A deterministic loop around a probabilistic engine
You can't make AI predictable. Nobody can — that's not the game. The game is building a system around it that makes the work predictable: inspectable, correctable, 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 an operator and a passenger.
- 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
The first 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.
It grows with every project. It compounds across your career. It moves with you between companies, stacks, and toolchains — like a toolbox you've been seasoning for fifteen years.
Designers have never had this before. Your portfolio shows what you made. Your codex is how you think — 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.
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 — and 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.
Alumni
The Guild
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.
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 year — 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.
Founder
Built by a designer who builds machines
Alex Sulgrove15+ yearsCybersecurity / Cloud Infrastructure / SecOps / Attack Surface Management
I'm Alex Sulgrove, founder of Machine-Speed Designs.
15+ years designing software where the systems are dense and the stakes are real — cybersecurity, cloud infrastructure, SecOps — at Hewlett Packard Enterprise, LogRhythm, Lacework, Automox, and Inspectiv. I've led UX teams, run solo design functions, and shipped inside engineering-heavy orgs my whole career. Masters in HCI/d from Indiana University, BS in Informatics.
Most recently I spent a year building an AI design-to-code rig — Figma, Claude Code, Figma MCP, React, TypeScript, Storybook, GitHub — and connected it to a live development environment, where it produced passing PRs in the production repo of a professional cybersecurity company.
The machine thing isn't a brand. Before software, my family built national retail stores across 28 states — and I ran that business for two years before walking away to study design. I also co-built and co-drove car #4526, a 4500-class rig, to a 12th-place finish at the 2014 King of the Hammers Everyman Challenge. Construction and desert racing teach the same lesson, at different RPM:
The drawings are not the building. The dyno sheet is not the race. Figma is not the product.
Machines don't reward intentions. They reward the builder who grounds them, inspects them, and fixes what breaks. Design at machine speed works exactly the same way — and the designer should be the one holding the wrench.
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 seat