Build it into the line
Factories learned decades ago that you can’t add quality at the end of the line. You have to build it into the line. The same goes for design in a software factory. When product is built continuously, a review at the end is just a queue with good intentions.
We’re building a design platform that supports every workflow that delivers product: in the components, in the coding agents, and in our software factory. The goal is the best designer sitting next to you while you work, not a reviewer waiting at the end. The judgment is already in the room when the decision gets made.
People ask whether agents can have taste. They can, when a designer with taste gives it to them. That’s why we think designers only get bigger from here: we used to shape the screens we could touch, now we shape the system behind every screen. Nothing gets made by accident, and nothing is a random act of AI.
Why we had to
There are two of us. AI let everyone at Integral build, and our old hand-off couldn’t keep up: every screen waited for us in Figma before an engineer touched code. Some people kept waiting, so we became the bottleneck. Everyone else stopped waiting. They briefed their agents off a Figma screenshot and shipped whatever came out, off-brand and off-system.
Figma stopped being the truth
Engineers had stopped studying our Figma files. They fed the screens to their agents and told the agents what to build. We kept drawing pixel-perfect screens for every use case we could think of, and the drawing itself was what slowed us down. Worse, the intention never survived the trip. An agent can read a screenshot. It can’t read why we drew it that way.
So we moved design into code, where the agents already work. The repository, the design system and GitHub are the source of truth now. Figma stays as a sketchbook for testing ideas fast.
How the platform works
The platform has three layers, and all three load into the coding agent every builder already uses. Each one answers a different question: component specs say what to use, Design Atlas says how a page should work and look, and design-brainstorm says how to decide.
A builder asks for a feature. The agent reads the spec before it picks a component, checks the atlas before it touches a page, and runs the brainstorm before it writes any UI. Our judgment is in every session, whether or not anyone thinks to ask us.
Giving every component a brain
Our Storybook used to mirror Figma: components with no documentation, no reasoning, and barely any use. We audited it, cleaned up the components and variants, then added what was missing. Every component now ships with a spec that tells an agent when to use it, when not to, and how to decide. We researched how to write these so they fit the way Integral builds. Here is part of the spec for Button:
Decision flowchart
├── Navigates? → Link, or Button asChild + Link (tertiary)
├── Opens an action menu? → DropdownMenuTrigger asChild + Button
├── Single most important action? → primary (only one)
├── Destructive / hard to undo? → destructive + secondary cancel
├── Cancel / back / dismiss? → secondary
└── Else → secondary or tertiary
Agent checklist
1. Max one primary per view or dialog.
2. Destructive means `destructive`, never `danger`.
3. Cancel and back are always an explicit `secondary`.
4. No invented variants, no raw styled <button>.
Without a spec, ask an agent the same question twice and you get two answers. With one, the agent follows our reasoning instead of inventing its own.
Design Atlas
Specs cover components, and pages needed the same. Engineers already had Code Atlas: a self-updating wiki that tells agents what a repository does and how the system should behave. We built Design Atlas next to it: our principles, how each page should look and work, and the patterns behind those decisions. It’s never finished. Without one shared account of how a page should work, every builder ends up with their own version of the product.
The design-brainstorm
Specs and the atlas give the agent knowledge. The brainstorm gives it our judgment. It starts from the Linear issue, not from a questionnaire.
The agent reads the issue, checks whether a prototype already exists, and picks a route: explore when the direction is still open, implement when it is already decided. It asks only what it can’t work out, usually how many directions to explore. In explore, every direction appears in rough form within five minutes, built from real components; the builder keeps, changes, replaces or drops each one. Implement skips that and goes straight to the build.
Either way, it builds a high-fidelity prototype per kept direction, with real components, real states and a deployed preview. Then it spars the way we would: a recommendation, the riskiest assumption, a concrete alternative, one question. Explorations converge there. A polish pass finishes spacing, alignment and states, and the PR and Linear issue carry what we learned, what’s decided, what’s open, and what to check after release.
Every session ends with a hypothesis about the people who will use it, not just a screen. Our main stakeholders, the tax and payroll operators, sit one floor below us, so we can test that hypothesis the same week.
No sign-off. On purpose.
Nobody waits for a designer to approve their work. Builders ship. That can look like design stepped out of the way. Design moved to where the decisions get made.
A sign-off only ever inspected the output. What we care about is the intent: that we make things for humans, that we think through the ergonomics of every decision, and that each release gives people another reason to choose us. Those values don’t live in a review queue. They live in the principles the platform encodes (the specs, the atlas, the brainstorm) that shape a feature before the first line of UI exists. An approval stamped on top would only put the queue back.
So we moved our own work to the part of the line that shapes everything else. Every week, engineering and design sit down with what was built. We annotate feedback directly in the Vercel prototypes and polish the strongest work ourselves. Every miss we find goes back into the platform as a new rule in a spec or a new pattern in the atlas. We fix the line, not the screen. The same mistake shouldn’t ship twice.
Checking screens was always the smallest part of the job. Defining what quality means here is the biggest part, and now it compounds. Every pixel still has to justify its existence. We’re the ones who decide what justified means, and the platform carries that judgment into every build after.
Where this stands
This is a bet, and we’re early. Without a sign-off, some imperfect work reaches production before we see it. What we watch is whether we teach the platform faster than the mistakes repeat. So far, fewer prototypes need a redesign by the time we look, and more arrive close to done. Whether that holds as the line speeds up is the question we’re working on now.