
CCDS: a design team that moved into the code
Our designers and product managers now build in the running product and ship through the same review as engineers. Here is what they had to learn, and what they invented once they got there.
- Role
- Architecture, components and the prototyping workflow
- Year
- 2026
- Built with
- TypeScript, React, Vite, Design tokens, Retrieval and citations, AI agents
Let me tell you about a team that agreed to be beginners again.
For years, design worked the way it works almost everywhere. Designers drew the screen, engineers rebuilt it in code, and the rebuild is where the time went. It's also where the details went missing: what the keyboard does, what a screen reader says, how the page behaves on a phone.
So we paid for every design twice. Once to draw it, and once to build it.
CCDS is how the team stopped paying the second time. It's a sandbox that runs on anybody's laptop, built on the real component library and the real ClearCo tokens, with mock data. What a designer makes in it is made of the same material as the product, so there's nothing to rebuild.
The tool was the easy part, though. The hard part was a team willing to work the way software gets built.
Working like engineers
Think about what we asked for. Designers and product managers now work the way engineers do. Each prototype starts on its own short-lived branch and joins the rest through a pull request.
Before anything merges, checks run on it: accessibility rules, token rules and tests. The review is the same gate engineers go through. So the person who picked a gray that fails contrast hears about it in the minute they picked it, not from an auditor a year later.
- 1SandboxRead the rulesPeople and coding agents read the design rules, accessibility standard and voice first.
- 2SandboxBuild on the real systemThe product's own components and tokens, with mock data.
- 3ReviewOpen a pull requestOn a short-lived branch, like any engineer.Accessibility, token and test checks
- 4ProductShipKeyboard, focus, structure and contrast came with the components.
- 5SandboxFix it at the sourceWhat a designer finds downstream comes back as a pull request.
That's a lot to ask of senior people. Code review leaves a record with your name on it, and a critique in a room doesn't. The team did it anyway, in public. There's more on what that asked of them.
They didn't just adopt the process, either. They changed it. An earlier setup kept each prototype on a branch that never merged, and it quietly hid part of the app. So the team retired it and moved everything onto the main line.
And they were honest about what was hard. The commands were learnable. Knowing when to merge, when to open a pull request and how big one should be was not. That part is getting written guidance, because no script can judge it.
Designing with code
Once the work lived in code, the rules could live there too.
Components use named tokens, never raw colors. A build fails if a token is missing, if a value drifts, or if the docs name something that doesn't exist. A rule that fails a build survives a deadline. A rule in a wiki doesn't.
Starting a page is one command. It writes the page, its route and its menu entry together, so none of the three gets forgotten.
The design language, the accessibility standard, the voice and the component specs live in the repository as plain markdown. The team reads them, and so do the coding agents they work with. If the answer to "is this allowed" is a person, the answer is unavailable most of the time. In a file, it's always there.
Thinking outside the box
Here's the part nobody planned. Once design lived in the running product, the team stopped drawing what code could show, and started inventing.
A static flow needs a separate drawing for every role, every customer and every state. So the team built a review bar that switches all of them on one working screen: the persona, the customer, the viewer's relationship to the person on screen, and the state of the data.
Comments and UX notes sit on the screen they're about. One button hides the bar, and the prototype can go in front of a customer the same day.
Each customer brings its own brand, so theming starts from one color. Pick an accent and CCDS builds the whole scale, then checks contrast as you go. On ClearCo's copper, it warns that black text reaches 4.25 to 1. That's fine for large text, but not for body copy, and the person choosing finds out before anyone ships it.
An assistant answers questions about the system itself, only from its reference pages and with citations back to them. If the answer isn't there, it says so instead of inventing a component.
Even privacy became a test. The test data includes people who asked to be erased, as real records would. A check reads every piece of text a model could be handed, and fails if an erased name appears. It holds hashes of those names, never the names, so it can't leak what it guards.
Where this leaves us
So what did the team get for all this?
The first version took two weeks, built with a coding agent. Two days after its first demo, someone else forked it into their own repository without being asked. Today many people merge into it, and it holds seventeen working prototypes across hiring, learning, goals, succession and settings.
Design and the product stopped being two copies of the same idea. That's also why we're letting Figma go: the work already moved into the running product. And because the system now makes so many of the decisions, accessibility has to live in it.
None of this is finished. But none of it would exist if a design team hadn't agreed to be beginners in public, and then kept going until they were inventing things.
Gallery

About the drawing
The drawing for this piece was chosen, not generated. Generated in November 2026 in the house style from a brief about building a phone out of toy bricks, and chosen by hand from four tries. Kept as supplied so the pipeline never redraws it from the brief. Every other drawing here is generated from a written brief.
The line under the drawing marked “Meant to show” is written by a person, not the model. A generated drawing keeps what is large and loses what is small, so the detail that decides who someone is can go missing, and a picture only reaches people who can see it. Where the drawing and that line disagree, the line is the intent.
Or press ←the left arrow and →the right arrow.