# Automating Design Quality in the Dark Factory

## Executive summary

The presentation details how to automate design quality in a 'Dark Factory' environment, moving beyond relying on human designers as a bottleneck. Drawing parallels from manufacturing principles (like Toyota's Just-In-Time system and Kanban), the speaker advocates for embedding design quality checks into the development lifecycle. This involves surfacing unwritten 'composition rules' by manually redoing AI-generated work, and then codifying these rules into advisory checks within CI, code review, and scheduled maintenance loops.

## Key takeaways

- The Bottleneck Problem: As AI agents increase output volume, the traditional process of having a single designer review all work becomes a severe bottleneck. This manual review process is costly and slows down development (00:05:03).
- Manufacturing Lessons for Software: Modern manufacturing, traced back to Toyota, emphasizes building quality into the line (JIT system) rather than fixing defects at the end. This principle applies to software, where early detection of defects is cheaper and prevents rework (00:01:59).
- The Role of Composition Rules: Design systems and design tokens are insufficient because they only enforce component usage. The true challenge is 'composition'—the judgment of what elements belong on a screen, where they sit, and what should be omitted for clarity. These unwritten rules must be surfaced (00:07:56).
- Automating Quality Gates: Design quality can be automated by implementing advisory checks across the lifecycle: 1) CI checks (e.g., enforcing design tokens over raw hex values), 2) Code Review (mining PR comments for recurring rules), and 3) Weekly Maintenance Loops (finding subtle, compounding issues like inconsistent spelling or color usage over time) (00:13:19).

## Technical details

- Software Factory Scaling: The development process scales from a single developer on a laptop to a small team using shared tools, and finally to a 'factory' utilizing agents for high-volume, rapid output (00:00:00).
- Kanban/JIT Principle: The Just-In-Time (JIT) system, originating from Toyota, dictates that nothing moves or gets built until it is explicitly requested, minimizing waste and stored 'top stock' (00:01:59).
- Advisory Checks and Exceptions: Checks should be advisory, not blocking, to allow for necessary exceptions (e.g., special launch pages). This approach uses the exceptions themselves as a signal to improve the underlying rules and skills (00:13:19).
- Skill Codification: Rules are mined from human commentary (PR comments, agent logs) and codified into 'skills' that can be loaded into the factory, ensuring consistency across different non-dev domains (e.g., marketing, GTM) (00:13:19).

## Practical implications

- To surface unwritten design rules, manually redo agent-generated work (e.g., in Figma) and use a diffing process to identify key differences and patterns.
- Implement automated quality gates (CI, code review, maintenance loops) to catch subtle, compounding errors (e.g., inconsistent spelling, color usage) before they are shipped.
- When developing new skills, use existing PR comments and agent logs as a source of truth to codify common, consistent instructions, rather than relying solely on documentation.
- For build teams, treat design and documentation as code: use automated checks to enforce standards across all outputs, regardless of the discipline (design, writing, engineering).

## Topics

Build Engineering, AI Agents, CI/CD, Design Systems, DevOps, Kanban, Software Architecture, Design Tokens, Tessl, AI DevCon London 2027

Source: https://www.youtube.com/watch?v=v4ginEfjk4g
