# The missing design layer: why AI coding agents ship UI without a judgment step

> The AI coding stack has linters, test runners, type checkers, and deployment gates. It has no design review step. This isn't an oversight — it's a hard problem. Here's why it's still unsolved and what solving it actually requires.

Source: https://www.thedesignagent.ai/field-notes/the-missing-design-layer · Concepts · 2026-05-06

Search for MCP servers available to Claude Code. You'll find tools for GitHub, Jira, Linear, Slack, Supabase, Stripe, Postgres, filesystem access, web search, code execution. You'll find tools that let agents read documentation, manage deployments, query databases, and send messages.

You won't find a design review tool. There isn't one.

This isn't an oversight in the ecosystem. It's a reflection of how much harder design judgment is to encode than the other kinds of review the stack already handles.

## What the stack can already do

The non-design parts of the quality stack are mature because they're automatable in a straightforward way. A linter checks code against rules that are explicit, deterministic, and domain-general. A type checker proves correctness against a formal specification. A test runner executes code and checks outputs against expected values. A CI pipeline gates deployment against passing checks.

These tools work because the thing they're evaluating has a clear, agreed-upon definition of "correct." Code either type-checks or it doesn't. Tests either pass or they fail. The evaluation is binary, deterministic, and doesn't require knowledge of who will use the software or what they'll be trying to do with it.

Design doesn't work that way.

## Why design is harder to automate

A well-designed interface is one that serves the person doing the job, in their domain, with their cognitive constraints, on their device, in their workflow context. There's no formal specification for "serves the person doing the job." There's no grammar that type-checks against it. There's no test suite that passes or fails against it.

This is why design review has historically required human judgment. A senior designer reviews a build not by running a checker but by understanding who the users are, what they're trying to accomplish, and whether the layout helps or hinders that. The review is a synthesis across multiple frameworks — JTBD, cognitive load theory, visual hierarchy principles, domain-specific pattern knowledge — applied to a specific artifact in a specific context.

Encoding that synthesis into something an agent can call is the hard part. The easy version is a linter — check that buttons have sufficient contrast, that interactive elements have accessible labels, that touch targets meet minimum size. Accessibility checkers do this already. But contrast ratios and label presence are necessary conditions for a good interface, not sufficient ones. A layout can pass every accessibility check and still be wrong for the job.

> **The gap:** the AI coding stack can verify that UI is technically correct. It has no tool for verifying that UI is experientially correct — that it serves the person doing the job, in the shape the job requires.

## What a real design judgment layer requires

For automated design review to be more than a linter, it needs several things that most tools don't have.

**Domain knowledge.** Design patterns that are correct in a warehouse picking station are wrong in a loan underwriting tool. Generic advice — "reduce cognitive load," "keep forms short" — is true enough to be quoted and not specific enough to be useful. A judgment layer needs to know what domain it's operating in and what that domain's cognitive requirements look like.

**User knowledge.** The evaluation has to be against a specific persona with specific constraints — not "the user" as an abstraction. A 14px font is fine in a desktop analytics tool and a problem in a warehouse handheld context. Touch target sizes that work for occasional users are too small for operators who use the interface hundreds of times per shift. Without knowing who the user is, these distinctions don't exist.

**Job knowledge.** The most fundamental design question — does this layout fit the job? — requires knowing what the job is. Not what the data is, not what the features are: what is the user actually trying to accomplish, in what sequence, with what constraints. This is JTBD at the operational level, and it's what most automated tools don't have access to.

**Pattern knowledge.** Knowing that tabs are wrong for sequential workflows and modals are wrong for batch decisions requires a body of domain-specific pattern knowledge — not just general UX principles, but knowledge of which patterns consistently fail for which jobs.

## Why this gap exists now

The tools that exist for agents today are built around data: code, documents, APIs, databases. These are structures agents can read, query, and modify with well-defined semantics.

Design judgment is about meaning — specifically, the meaning of a layout to a specific human doing a specific job. That's harder to represent as a structured query. You can't `SELECT` the extraneous load from a React component. You can't `grep` for JTBD misalignment.

The gap will close, but it requires a different kind of tool than the ones the stack has built so far. One that holds domain knowledge, user knowledge, and job knowledge as context — and applies that context to evaluate an artifact against the actual requirements of the job. That's not a linter. It's closer to a specialized reviewer that the agent calls the same way it calls a test suite.

That's what TheDesignAgent is. And right now, it's one of the only things in the space that's doing it.
