Marcelo Paiva

A man in thick black-rimmed glasses holds a slab of studded toy building bricks up in both hands, just under his eyes.Meant to show: A product starts as parts you can hold: the same studded pieces for everyone, before any screen exists.

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.

  1. 1SandboxRead the rulesPeople and coding agents read the design rules, accessibility standard and voice first.
  2. 2SandboxBuild on the real systemThe product's own components and tokens, with mock data.
  3. 3ReviewOpen a pull requestOn a short-lived branch, like any engineer.Accessibility, token and test checks
  4. 4ProductShipKeyboard, focus, structure and contrast came with the components.
  5. 5SandboxFix it at the sourceWhat a designer finds downstream comes back as a pull request.
Designers and product managers build on the real system, pass the same review as engineers, and send what they find back to the source.

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.

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.

About this drawing

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.

A case study

This is a report on one project, read straight down in one column: a drawing, what the problem was, and what I did about it.

From top to bottom

  1. At the top, the site header: my name, which goes home, then links to Writing, Work, Signal, Tools and Resume, then Settings, where you choose the drawings, light or dark, and movement.
  2. The case study’s drawing, its title and a one-paragraph summary. Some have a link to the project itself.
  3. The case study, in sections with their own headings, with screenshots along the way.
  4. Some have a gallery of screenshots at the end. Each opens larger, in a viewer you can step through.
  5. About the drawing: how the drawing was made, and the colors it was drawn with.
  6. Links to the newer and older case study. The left and right arrow keys go there too.
  7. At the bottom, the footer: a note on how this site is built, links to Illustrations, Pens, Concepts and Accessibility, this Describe this page button, then GitHub, LinkedIn and email.

What you can do here

Read how the project went.