One prototyper, about ten engineering teams

The bottleneck was me

Across the Workbench program I prototyped for about ten engineering teams. Each team rebuilt my screens in its own environment. When a button or a status label had to change, the request came back to me. One prototyper can't keep up with ten teams, and the engineers were the ones left waiting.

In July a platform lead asked for a UI library in its own repository. I treated the ask as a reuse problem. The components already existed. What engineers lacked was a standard way to pull them into their own builds. I scoped the first version to one pilot team and left new visual components and a low-code bridge out of scope.

The program's architecture proposal went further. It would have required every module joining the Workbench to use a shared UI package. The workshop that discussed it recorded no outcome, so I don't count that requirement as adopted.

The audit kept asking the same question

In May, a brand audit kept flagging tinted badges, uppercase labels, and color pairs the guide did not list. The product styles translated a print brand into dense software. The audit needed to distinguish a deliberate product pattern from a mistake.

I weighed three rules. Letting the guide win everywhere would turn each existing component into a pending exception. Splitting by audience did not help: most screens served both stakeholders and people doing the work.

Then tighten the rules that mattered

A default rule is where review starts. In July I reversed three things it had let through. Labels went back to sentence case. A gradient loading effect became a solid pulse. Every text size below 10 pixels moved up to a 10-pixel floor. Each change was small, and in each one the brand rule or legibility was right and the code was wrong.

The first app on the tokens was a regulated review

Before a speaker is paid to present, someone has to check their specialty and tier, because those set the fee. In April an engineer building a fair-market-value review tool asked me for a front end. The tool used an AI agent to classify a speaker's specialty and tier from their CV, and reviewers needed to see the evidence behind each call before a fee was set.

I built the front end on the shared tokens through a generated theme file, with no styles of its own. It ran as eight review steps from upload to recommendation, later grouped into four stages around the reviewer's decisions. I prepared the handoff: a written developer package and a verification script. The old prototype stayed as a reference only, and the app ran on one checked-in sample record. Connecting production data was the build team's next step.

A reference by the next morning

In early July engineers needed a component reference by the next morning so they could build their own workflow screens without asking me to adjust each element. I made a standalone HTML reference that opened directly and printed to PDF, with labels, states and style references beside each component.

On 2 July one engineer reported integrating my shared UI package into the budgeting work. Another confirmed receiving the reference and using it in his own environment. Backend connections were separate from this UI work.

What the system held at handover

In mid-July I merged three sources into one repository: the brand guideline extraction, the Workbench components and an older component bundle. It held 294 design tokens and 127 React components, 26 of them core controls such as buttons, fields and badges.

Brand rules ran as checks. A linter, a test that failed the build when generated tokens drifted from their source, and a documentation coverage check all ran in one verify command. Most people producing screens with AI tools would never read a guideline, so the checks had to catch drift for them.

The system kept a design-debt register, and a row closed on evidence, not a tick. Dark-theme colours stayed hand-maintained, so a test was added that fails when one drifts from its token, and a value was changed on purpose to prove the test caught it. Text smaller than a 10-pixel floor counted as a defect and moved up to it. At the last count 60 of the register's 65 rows were resolved. One open row noted that the verify command still ran no accessibility tests.

What engineers used, and what remains unknown

In July the adoption dashboard had nothing to read, because no analytics source sat behind it. I redefined adoption as something the repository could count: places in the code that used the shared tokens. The count was two, both inside the repository. I'd rather show that number than a funnel.

Outside the repository the record holds one app in April and two engineers in July. I have no usage data after July, and nothing on record shows the August packages arrived.

Check the file someone receives

My July handoffs taught me to write down which behaviors worked, which were simulated, and which connections were missing. Stakeholders had seen a version without the source-review controls I had built, and we traced the gap to version integration. An export check taught the same lesson from the other side. Three checks passed while the downloaded slide file was missing its images and logo, because none of them opened the file.