Concepts

Why there's no UX linter (and what it would take to build one)

ESLint catches code that violates rules. There's no equivalent for UI that violates design principles. The reason isn't that nobody tried — it's that design correctness isn't rule-shaped.

ESLint runs on every save. It catches unused variables, missing dependencies in useEffect, components that violate accessibility rules. It's fast, deterministic, and deeply integrated into every serious development workflow. The output is binary: a violation or not.

There's no equivalent for UX. No tool that runs on every build and catches: tabs used for a sequential workflow, a dashboard built for a deciding job, a modal on a batch-decision row. The accessibility parts of a linter come closest — contrast ratios, missing ARIA labels, insufficient touch targets — but these are the hygiene baseline, not the judgment layer.

The absence isn't surprising once you understand why linters work and why UX judgment doesn't share the same properties.

Why linters work

A linter works because the rules it enforces are:

Deterministic. A missing alt attribute either exists or it doesn't. An onClick without a corresponding keyboard event either has one or it doesn't. The check is computable from the code alone.

Context-independent. An unused variable is an unused variable in any program. A missing dependency in useEffect is always a bug. The rule applies without needing to know what the software is for or who will use it.

Formally specifiable. The rules can be written down precisely enough that a computer can check them. "Every image element must have an alt attribute" is machine-checkable. "The layout should serve the user's job" is not.

Most design principles fail on all three counts. "Reduce cognitive load" is not deterministic — cognitive load depends on who the user is, what their expertise level is, and what the domain requires. "Don't bury the primary action" is not context-independent — the primary action depends on the job, and what's primary in one workflow is secondary in another. "Match the layout to the workflow" is not formally specifiable without knowing what the workflow is.

The core problem: a linter checks code against rules. A design judgment tool has to check UI against meaning — the meaning of the layout to a specific user doing a specific job. Meaning isn't rule-shaped.

What the accessible parts of a linter actually check

It's worth being precise about what accessibility linters do and don't catch, because they're often cited as "the closest thing to a UX linter."

Accessibility linters check for WCAG compliance on dimensions that are formally specifiable: contrast ratios above a threshold, interactive elements with accessible names, ARIA roles used correctly, focus order that follows DOM order. These are necessary conditions for an accessible interface.

They don't check whether the interface is actually usable by the people it's supposed to serve. A form with perfect ARIA labels and sufficient contrast can be unusable for a user with low working memory capacity if it presents twelve fields that need to be filled before submission. The accessibility linter would pass it. A design review would not.

The formally checkable accessibility rules represent roughly the bottom 20% of what makes a UI good or bad. They're the floor, not the ceiling.

What a real design check would need to know

To catch the kinds of design failures agents commonly produce — dashboard for a deciding job, tabs for a sequential workflow, modal on a batch-decision row — a tool would need to know:

What the job is. A tool that doesn't know whether the user is deciding or monitoring can't distinguish a dashboard from a decision surface. Both are valid layouts; the question is which one fits the job.

Who the user is. A tool that doesn't know the user's cognitive profile can't evaluate whether the extraneous load is tolerable or fatal. In a warehouse picking context, extraneous load compounds into real throughput loss. In a deliberation context, the same amount of friction is acceptable.

What domain patterns apply. A tool that doesn't have domain-specific pattern knowledge can't flag that tabs are wrong for fulfillment workflows while being appropriate for settings pages. Generic "avoid tabs" advice is wrong; domain-specific "tabs are wrong for sequential jobs" is right.

This is why design judgment requires context that a traditional linter doesn't have. The check isn't against a rule; it's against a job-specific standard that varies by domain, by user, and by the nature of the task.

What building toward it looks like

The path toward automated design judgment is not more rules. It's richer context.

If a tool knows the domain, the persona, and the job — and has accumulated knowledge of which patterns fail for which combinations of those three things — it can make job-specific evaluations that go beyond formal rules. This is closer to a specialized reviewer than a linter: it has expertise the agent doesn't, and it applies that expertise to a specific context.

The difference from a linter is that the tool has to learn what the product is, who uses it, and what they're trying to do. That learning happens at the first call, when discovery builds the project profile. Every evaluation after that is grounded in that context.

That's not a linter. It's something new. And it's why the design judgment layer has taken this long to exist.