Built to be picked up
Design agents and skills that each run on their own, and a brain that keeps every run. A designer, a team or a client's pipeline can take one without taking the rest.
- Result
- Four units running unchanged in client pipelines, Restaurant Brands International among them.
- Role
- Individual contributor and mentor
- Team
- Each unit began with a designer on the team. I built two and reworked every one to the same contract.
- Units
- Seven so far. Each is tested on its own before it joins.
- Timeline
- May 2026 to now
- Runs in
- Claude Code, VS Code Copilot, any pipeline
A pipeline only works where it was wired
Every team builds its own flow, in its own tools, for its own client.
- Take
- A wired pipeline: Taken whole, or not at all.
- A self-contained unit: Take one. Leave the rest.
- Fail
- A wired pipeline: One broken step stops every step after it.
- A self-contained unit: A failure stays inside the unit that failed.
- Run
- A wired pipeline: Built for one editor, one runner.
- A self-contained unit: Runs in Claude Code, Copilot, or any pipeline that can hand it files.
- Remember
- A wired pipeline: Why a choice was made leaves with the person.
- A self-contained unit: Run inside Design Factory, every run is filed with the brain by itself, decisions and their why included.
So we built parts.Notapipeline.
Seven units so far · a gap between every pair · nothing joins them
Four rules keep every unit alone
I worked through every unit with the designer who started it, until it met these four rules.
- Imports nothingA unit never calls another unit and never shares memory with one.
- Says what it needsIts needs are written on its label, for people and tools to read. Nothing is wired in.
- Comes out cleanlyAdd one or remove one and no other unit notices.
- Has one doorInside can be a whole pipeline: the design-system generator runs eleven steps. Outside, it is one command.
A tool checks every unit's label and contract. A unit without them fails.
Every unit carries a label like this one, the designer's, trimmed to five of its lines.
- use_when: You are starting from a brief and have no visual direction yet …
- The guide below is built from these labels. It routes on this line, and the check tool fails any unit without one.
- inputs: [design brief, personas, architecture, requirements, domain]
- needs: []
- Nothing to install before it runs.
- produces: visual-direction.md, mood boards, tokens.json, components.md
- hosts: [claude, copilot]
- The same unit, in either editor.
Eleven agents became one unit
The design-system generator arrived as eleven numbered agents and an orchestrator. I moved them inside one unit with one door, so a team takes the whole generator as one part.
Anything can feed a unit, if the files fit
A unit's contract lists every file it reads and writes. The designer unit writes the files the prototyper reads, but so can a person, a Figma export or another team's tool.
Start from what you have, leave with one unit
Seven units so far, each with one job and its own version, each tested on its own before it joins.
In the Design Factory repo, /df:start asks the same question, checks what the unit needs and hands you its command. It never runs a unit for you, or chains two together.
Restaurant Brands International
Burger King · Popeyes · Tim Hortons · Firehouse SubsClients have been impressed and have gone on to adopt agentic pipelines across their own product and software lifecycles. RBI is one of them.
Each client gets its own pipeline, from the same parts
At EPAM we assemble a custom agentic pipeline for each client's use case. Four units have gone in unchanged so far: the design-system generator, figma-to-code, the designer and the accessibility audit.
The same rule, applied to memory
The brain began as a colleague's tool for another job. I made it stand alone and run in any pipeline, like a unit. It files every run, every decision and its why, by itself, whenever a unit runs in Design Factory.
People change. The record does not.
It covers the day a project changes hands. The next designer opens the same project and finds every decision the last one made, with its why. Nothing has to be written up at the door, because it was filed as it happened.
“Required designer tokens and components were initially missing, so the user authorized designer refinement before handoff. A separate immutable designer run completed Round 2 and its outputs were explicitly copied into this run’s inputs.”
An agent can only suggest
When an agent infers a decision from a run, it is kept as a suggestion and never handed to another agent as true. It counts once a person confirms it.
Parts outlast pipelines.
Each unit runs alone. The brain keeps what they decide.