Skip to main content

Hiro Fukushima

Back to Portfolio

Design Engine

Design-System Enforcement for AI-Generated Interfaces

Product Design
AI Systems
AIProduct DesignDesign SystemsEvaluation

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
Design Engine connects product authority and Design Knowledge to enforceable checks, controlled changes, and verified interface results.

Rules the model cannot ignore.

Product authority, Design Knowledge, checks, and approval surround AI-generated design.

PRODUCT AUTHORITY
DESIGN SYSTEMTokens and components

Patterns · states · behavior

KNOWLEDGEDesign intelligence

Guidance · evidence · examples

ENFORCEMENT LAYER
DESIGN ENGINEEnforce the system
ScopeCheckControlVerify
GOVERNED RESULT
FINDINGSExplain every violation

Rule · evidence · exact location

VERIFICATIONRecord the approved result

Change · checks · recovery

The Design System defines the product. Design Engine makes its rules executable.

00. Table of Contents

01. The Engine Within the System

Where the Engine sits inside a complete product.

02. The Engine Family

How specialist Engines divide responsibility around AI.

03. Before and After

How an existing interface was analyzed and changed inside a controlled scope.

04. What the Design Engine Solves

The design failures it prevents in AI-generated work.

05. Design-System Enforcement

How product rules become checks the model must follow.

06. How the Design Engine Works

How authority, knowledge, control, and verification work together.

07. Design Knowledge

The practical design guidance the system can retrieve and apply.

08. System Evidence

What was built, tested, and verified.

09. Human Authority and Control

Where 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.

A car engine surrounded by the chassis, steering, brakes, controls, cabin, and driver required to make its power usable.

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.

Knowledge and Orchestration connect to four specialist Engines, with Design Engine highlighted as the system responsible for design conformance.
SHARED KNOWLEDGEKnowledge Engine

Sources · standards · project context

COORDINATIONOrchestration Engine

Plan · route · join

Specialist Engines
TrustContent Engine

Defines supported information.

PermissionConversation Engine

Governs responses and actions.

CorrectnessVerification Engine

Checks specialist artifacts.

ConformanceDesign Engine

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.

Before and after Job Tracker interface comparison showing an analyzed and controlled design change.
Before
After
Prompt

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.

The Job Tracker component sheet in light and dark mode, with every control in all of its interaction states.
Light
Dark

I asked the engine why it had done that, since it was outside the brief.
These are its reasons, in its own words:

Response

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.

Six classes of design failure surround an AI-generated interface that appears plausible but is not governed by the product system.
AI-GENERATED INTERFACEPlausible output

Appearance alone cannot prove conformance.

01
Scope drift

A small request expands into unrelated work.

02
Wrong tokens

Color, type, spacing, or geometry leaves the approved system.

03
Invented components

Generated UI replaces established product patterns.

04
Missing states

Loading, error, focus, empty, or disabled behavior disappears.

05
Broken behavior

Responsive and interaction rules stop matching the product.

06
Unsupported decisions

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.

Eight stages move a design request from product authority through scope, conformance checks, approval, controlled application, and verification.
  1. 01AUTHORITYLoad the product system
  2. 02SCOPEBind the request
  3. 03INSPECTRead the declared surface
  4. 04CHECKRun conformance rules
  5. 05FINDExplain every violation
  6. 06PROPOSEDefine the exact change
  7. 07APPROVERequire human authority
  8. 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.

Design Engine architecture from product authority and current artifacts through the Design Graph, checking, proposals, approved changes, and verification records.
01 · AUTHORITY
Product Design System

Tokens · components · patterns · states

Extracted system

A live site without a written system is measured into tokens, components, and states first

Current design and code

The declared surface under review

Design Knowledge

Guidance · evidence · examples

02 · ENGINE
Scope Firewall

Task lane and allowed paths

Design Graph

Normalized authority and artifact model

Conformance

Deterministic checks and bounded judgment

03 · CONTROLLED RESULT
Explainable findings

Rule · evidence · location

Bounded proposal

Exact operation and recovery

Verified record

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 KNOWLEDGEConversation intelligence
SOURCES19 complete books
PREPARATIONStructured and evaluated corpus
RETRIEVALExact source passages
More informed conversation
DESIGN KNOWLEDGEDesign intelligence
SOURCESResearch · standards · evidence
PREPARATIONStructured and evaluated design corpus
RETRIEVALExact topics and rules
More informed design decision
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.

01
Foundations

Type, color, spacing, sizing, accessibility

02
Structure

Layout, grids, responsive behavior, navigation

03
Components

Actions, inputs, tabs, menus, dialogs, content

04
Behavior

States, feedback, motion, errors, recovery

05
Communication

Content, localization, imagery, data

06
Systems

Tokens, platforms, governance, evaluation

DESIGN KNOWLEDGEPractical design intelligence
30 topics67 examples41 active sources
EXACT RETRIEVALComplete topic answer
  • 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.

Verified Design Engine evidence across three releases, atomic rules, Design Knowledge, and passing tests.
V1.0Read-only core

Design Graph · checks · reports · Design Signature

V1.1Controlled Apply

Approval · recovery · rollback · immutable records

V1.2Scope Firewall

Task lanes · exact boundaries · diff enforcement

36atomic sources
8knowledge packs
60enforceable rules
30practical topics
67mapped examples
274passing tests
VERIFICATION274 automated tests passed across 52 test files

Type checking, linting, and the production build also pass.

09. Human Authority and Control

The Engine enforces the system. A person controls the change.

Analysis and proposal remain separate from mutation. Controlled Apply executes the approved operation and records the verified result.

Design Engine inspects and proposes, human authority approves or rejects, and Controlled Apply performs only the approved operation before verification.
DESIGN ENGINEInspect and propose
  • Bind scope
  • Run checks
  • Explain findings
  • Define exact operation
DECISION BOUNDARYHuman Authority
ApproveRejectRevise
CONTROLLED APPLYChange and verify
  • Authenticate operation
  • Lock source state
  • Apply approved change
  • Verify and record
The Design System defines the product, the Engine enforces it, and human authority controls the change.