Patterns · states · behavior
Design Engine
Design-System Enforcement for AI-Generated Interfaces
Summary
A design governance system that gives AI practical design knowledge and enforces a product’s Design System when AI creates or updates interfaces.
It contains structured guidance on typography, color, spacing, sizing, layout, responsiveness, components, interaction, accessibility, motion, content, data, platforms, design systems, testing, and evaluation. For every task, it retrieves the relevant knowledge, limits the work to an approved scope, checks the result against the product’s rules, explains every violation, and verifies every approved change.
Overview
- A design-specialized system within a larger agentic architecture.
- Gives AI structured, practical design knowledge.
- Makes each product's Design System enforceable.
- Controls scope, approval, and change.
- Checks, explains, and verifies every result.
Role
- Product Designer and Systems Designer
- System architecture and authority model
- Structured design knowledge base
- Evaluation and verification logic
- Scope controls and approval boundaries
- Controlled-change workflow
- Visual language and system communication
Rules the model cannot ignore.
Product authority, Design Knowledge, checks, and approval surround AI-generated design.
Guidance · evidence · examples
Rule · evidence · exact location
Change · checks · recovery
The Design System defines the product. Design Engine makes its rules executable.
00. Table of Contents
Where the Engine sits inside a complete product.
02. The Engine FamilyHow specialist Engines divide responsibility around AI.
03. Before and AfterHow an existing interface was analyzed and changed inside a controlled scope.
04. What the Design Engine SolvesThe design failures it prevents in AI-generated work.
05. Design-System EnforcementHow product rules become checks the model must follow.
How authority, knowledge, control, and verification work together.
07. Design KnowledgeThe practical design guidance the system can retrieve and apply.
08. System EvidenceWhat was built, tested, and verified.
09. Human Authority and ControlWhere people review, approve, reject, or revise changes.
01. The Engine Within the System
The Engine supplies the capability.
The product turns it into something people can use.
Think of a car. An engine alone cannot be driven. The chassis, steering, brakes, controls, seats, and driver turn it into a car, while the engine determines the power, speed, and torque available to the complete vehicle. The Design Engine is that engine. The product around it is the car.
The engine provides the capability. The complete system makes that capability usable.
02. The Engine Family
Design is one responsibility inside a larger family.
Knowledge supplies context, Orchestration coordinates the work, and each specialist Engine governs a separate capability around AI.
Sources · standards · project context
Plan · route · join
Defines supported information.
Governs responses and actions.
Checks specialist artifacts.
Enforces the product system.
03. Before and After
What the Design Engine does with a redesign
The redesign of a working product shows the Design Engine at work from the brief to the live page. Every change ran inside a declared scope. Each packet of work named the files it could touch and the checks it had to pass, and the Design Engine compared the finished diff with that contract before anything was accepted, so the redesign changed the interface and nothing else.
Look at the current interface and list everything it does. Then redesign it. I want a clean interface that is easier to use, with a light and a dark mode on our Gray Neutral palette, the Ice Dark colors in dark mode and the standard colors in light mode, and our Interface Icons. The current look is not a reference, its functions are. Everything else is up to your own judgment
The Design Engine is connected to the session and reacts to the words of a design request, here redesign and interface. It first listed every function of the current page, then read its Design Knowledge for the task, the Design Engine's written set of design rules, sorted by topic, each with recommendations, values and sources. For this redesign it read ten topics, among them typography, colour and themes, spacing and density, interaction states, error prevention and accessibility. It compared them with the tracker's own design system, and every value in the new interface comes from one of the two or from a decision we recorded.
What the Design Engine added on its own
The brief did not ask for a component library, and the engine built one anyway. It moved the accepted design out of the screens into 23 component sets in the design system file, each with every interaction state, bound to the color variables of both modes, and wrote a specification from them that the code was built against.
I asked the engine why it had done that, since it was outside the brief.
These are its reasons, in its own words:
One place for the design
When the direction was accepted, the design existed only as screens, and a screen shows a button in one state at one size. The values I had to protect were spread over dozens of frames, and the next round of changes was certain to come, so any correction would have had to be made in every frame by hand. I wanted one place where a value is decided once, so I built the controls as components and turned the screens into instances of them.
Every state decided
The screens showed every control at rest and nothing else, and the design knowledge on interaction states says a control is not designed until hover, pressed, focus and disabled are decided too. Leaving that to the code would have meant deciding it without review. So I built each control with every state and laid them side by side, and that view is what showed a focus ring in the same hue as the primary button, invisible until it sat next to the other states.
Both modes at once
Two modes double the number of color pairs, and a pair that passes in light mode can fail in dark. Checking that on screens would have meant switching every frame twice. By binding every component to the variables of both modes, one sheet shows the whole set in either mode, so I could measure contrast in one pass and know that no light value had leaked into dark.
A contract for the code
Code built from screenshots drifts, because a screenshot does not say which token or which pixel value it shows. I wrote the specification from the sheet, control by control, so the stylesheet had one document to follow and the tests had the same document to check against. It also means the next product starts from the same sets instead of from scratch.
04. What the Design Engine Solves
Plausible output can still violate the product.
The Design Engine exposes the failures that appearance alone cannot settle and connects every finding to the controlling rule and evidence.
Appearance alone cannot prove conformance.
A small request expands into unrelated work.
Color, type, spacing, or geometry leaves the approved system.
Generated UI replaces established product patterns.
Loading, error, focus, empty, or disabled behavior disappears.
Responsive and interaction rules stop matching the product.
A plausible choice has no product authority or evidence.
05. Design-System Enforcement
Every request becomes an enforceable work boundary before anything changes.
The Engine locates product authority, binds the task, checks conformance, prepares an exact proposal, and verifies the approved result.
- 01AUTHORITYLoad the product system
- 02SCOPEBind the request
- 03INSPECTRead the declared surface
- 04CHECKRun conformance rules
- 05FINDExplain every violation
- 06PROPOSEDefine the exact change
- 07APPROVERequire human authority
- 08VERIFYApply, check, and record
Every stage preserves the declared task, controlling authority, evidence, and final record.
06. How the Design Engine Works
Product authority, design judgment, and controlled execution meet inside one system.
Objective rules run in code. Judgment remains connected to evidence, while every approved operation stays inside the declared scope.
Tokens · components · patterns · states
A live site without a written system is measured into tokens, components, and states first
The declared surface under review
Guidance · evidence · examples
Task lane and allowed paths
Normalized authority and artifact model
Deterministic checks and bounded judgment
Rule · evidence · location
Exact operation and recovery
Approval · change · checks
07. Design Knowledge
Design Knowledge supplies the practical guidance behind design judgment.
Its structured corpus gives AI exact access to practical guidance, supported values, responsive behavior, accessibility, evidence, confidence, and authority boundaries.
Knowledge Built for AI, Specialized for Design
The system was first built to turn complete books into structured, retrievable knowledge.
That architecture became the foundation for practical design guidance, evidence, and examples.
Book Knowledge makes conversations more informed.
Design Knowledge makes design decisions more informed.
What Design Knowledge Contains
The six volumes organize the design knowledge an AI needs to make informed decisions.
The relevant topic can then be retrieved as a complete answer.
Type, color, spacing, sizing, accessibility
Layout, grids, responsive behavior, navigation
Actions, inputs, tabs, menus, dialogs, content
States, feedback, motion, errors, recovery
Content, localization, imagery, data
Tokens, platforms, governance, evaluation
- Recommendations and reasoning
- Values and conditions
- Responsive and platform behavior
- Accessibility and exceptions
- Sources, confidence, and authority
08. System Evidence
The system is implemented, versioned, and verified.
Three releases establish the core, Controlled Apply, and Scope Firewall. Design Knowledge adds the practical corpus and its complete evaluation suite.
Design Graph · checks · reports · Design Signature
Approval · recovery · rollback · immutable records
Task lanes · exact boundaries · diff enforcement