Roy Design OS (RDOS)

What This Actually Is

Design work rarely fails for lack of ideas. It fails when context gets lost — research scatters, decisions get forgotten, the same arguments keep coming back. That's the problem I built RDOS to hold.

It's not an AI tool that designs for you — I never relied on tools to do that, only on understanding the problem. It's almost the opposite: a design decision system, built from 15 years of practice and taken out of my head into something I can run, check, and improve.

The moments that need judgment stay mine. Every major step stops at a gate. The AI gathers and structures the context. I make the call. The call becomes the context for the next step.

That's the whole philosophy. AI keeps getting better at generating answers; what stays valuable is knowing which decision to make, which tradeoff matters, which mistake is fatal.

RDOS wasn't built to automate design. It was built to keep context intact, judgment sharp, and the decisions that matter in human hands.

Where It Started

It started as toil. On a research-heavy product, I was running test after test — and losing hours to the same mechanical work: matching each recorded answer back to a question the platform never labeled, pasting it under the right participant, across four variants. The thinking was the real work; the transcription was just overhead. So I got the machine to do it — first with prompts, then as something that didn't break every time the project changed.

The System

RDOS is a master briefing plus seven modular skills, run on Claude Code. Each one owns a single stage — setup, notetaking, synthesis, context, variants, refinement, prototype — and each runs on its own or end to end. The AI runs the line. I hold the gates.

There are three gates, and they're the core of the system: after synthesis — which findings to act on; after variants — which direction; after refinement — ready to build? AI prepares the context up to each gate. The decision is mine.

What keeps the AI honest is written into the skills themselves. It never invents a constraint that isn't in the research. It never reshapes a participant's words — and flags what it's unsure of instead of guessing. Every design variant has to trace back to a specific finding; it can't wander off the evidence. These rules aren't decoration — they're my judgment, written into the system, so it stays a first-draft machine and never quietly takes over the decisions.

A Real Run

To know whether RDOS was my method and not just that project's method, I ran it on a completely different problem — the same domain as my Walmart work: grocery substitutions. When an item's out of stock, which of a customer's groceries can be swapped, and which can't? I tested three ways to structure that screen — a tabbed split, an accordion, a filtered list — nine participants, same nine tasks.

From raw transcripts, the system did its work and stopped at the first gate. Notetaking matched every answer back to its task and flagged what it wasn't sure of. Synthesis validated each hypothesis and surfaced one finding nobody had hypothesized: the Tab layout won, the Filter failed — but across all three, people stumbled on the same word. "Ineligible" was named for the system's data model, not the decision the customer was making. The question they were actually asking was simpler: which of my items get replaced, and which won't?

That finding wasn't in the test plan. It came out of the evidence — which is the point. I made the call on what to act on, the system built the brief, and the run continued: variants tied to findings, a refined design, a working prototype. You can walk the whole thing below — hub, notes, synthesis, variants, refined design, prototype. Don't take my word for it; touch it.

The Moment That Proves the Point

Then the system did exactly what the gates are there to catch.

At the variants gate, the first direction came back clean — and quietly wrong. It had split the items into more categories, with a count bolted on to make up for it. At first glance, reasonable. Except that was the Filter pattern — the one the research had just failed. The model didn't know that mattered. It hadn't sat in the sessions. I had.

So I did the only thing the gate is there for. I named the constraint — don't reintroduce category multiplication; that's what Filter failed on — and fed it back. The next version dropped category navigation entirely: one flat list, a live count that never hides.

That's the whole argument in one move. The AI was fast and fluent and about to walk us back into a rejected idea. Catching it didn't take more AI. It took someone who knew which mistake was fatal. That's the job I keep.

Reflection

In my TikTok case I drew a line between a feature and a backbone — a feature solves one screen, a backbone holds an experience up. RDOS is a backbone. Not a thing that makes one design; a system that holds up how I make all of them.

It also settled something I'd been unsure about for a while. AI is a remarkable first-draft machine — fast, thorough, tireless. But a first draft isn't a decision. Knowing which finding to trust, which tradeoff to take, which mistake is fatal — that didn't get easier when the drafts got faster. If anything it got more valuable, because now it's the scarce part.

So RDOS was never about automating the design. It was about automating everything around it — so the hours go to the judgment, and the deciding stays mine.