skip to content
Navid Mesbah
فا
← Back

Can We Teach AI Agents Taste?

/ 9 min read

Fast, Confident, and Ugly

Ask a coding agent to build a settings page and you’ll get one in a minute. It will work. The buttons will do things. The forms will validate. And very often it will be quietly wrong: spacing that drifts from section to section, three slightly different grays that nobody chose on purpose, a hierarchy where everything shouts at the same volume, icons from two different families, motion that is technically smooth but feels nervous.

The agent has no idea. It can’t see what it made, and even when it can, it doesn’t know what “good” means. It optimized for “does it work,” and it succeeded. Nobody asked it whether the result was beautiful, clear, or calm, and it wouldn’t know how to answer if they had.

That gap is what I’ve been working on at Charsook: a design-judgment layer for AI agents. A way for an agent to look at what it built and know, with some reliability, whether it’s actually good.

Why This Matters More Every Month

A year ago, this was a minor problem. Agents built prototypes, and designers polished them. The designer was the judgment layer.

But the volume has changed. When agents can produce dozens of screens, components, and animations in a day, no human can review every pixel. Either quality drops, or judgment has to scale somehow. I don’t think the answer is to remove designers. I think the answer is to give agents enough judgment to catch the obvious mistakes, so that human designers can spend their attention on the subtle ones, the ones that require real taste.

There’s also a broader cultural concern. If most interfaces in the world are generated by agents optimizing only for function, the world’s software will drift toward a kind of competent ugliness. Everything will work and nothing will feel cared for. I find that future depressing, and I think it’s avoidable.

Why Taste Feels Unteachable

Designers often say taste can’t be explained. “You just know.” I partly disagree.

Much of what we call taste is a large set of small, learnable judgments. Alignment: do things that should line up actually line up? Rhythm: is the spacing consistent enough that the eye can relax? Contrast: is the most important thing the most visible thing? Restraint: is there anything here that doesn’t need to be? Consistency: does this screen feel like it belongs with the others? Timing: does this motion take exactly as long as it needs to, and no longer?

We learned these judgments slowly, through years of looking at good work, making bad work, and having someone with more experience point out the difference. That’s still learning, even if it doesn’t feel like following rules.

What can’t be reduced to rules is context. The same tight spacing that’s elegant in a data table is suffocating in a reading view. The same bold color that’s perfect for a call to action is aggressive on a warning about deleting data. The same fast transition that feels snappy in a productivity tool feels cold in an app for children. Good taste isn’t a fixed set of preferences; it’s sensitivity to what a particular situation needs.

So the goal isn’t a checklist. Checklists produce the kind of design that passes every guideline and still feels lifeless. The goal is a critic that can look at a result in context and say what’s wrong, why, and what to do about it.

Lessons From Teaching Humans

Before building anything, I spent time thinking about how design judgment is taught to people. I’ve spent years as a teaching assistant and coach in math and computer science, and mentored designers informally, and a few patterns stood out.

People learn taste through comparison more than through rules. Show someone two versions side by side, one good and one slightly off, and ask which is better and why. Over time, the “why” becomes vocabulary, and vocabulary becomes perception.

Good feedback is specific. “This feels cluttered” is less useful than “these three secondary actions compete with the primary one; try demoting two of them to a menu.” The second version teaches something transferable.

Context changes everything. A critique that ignores the purpose of a design is noise. You have to know who it’s for and what it’s trying to do.

These became the design principles for our system.

How We’re Building It

The approach at Charsook has three parts.

First, rendering. The agent’s output has to be seen, not just read as code. Code tells you what was intended; the render tells you what actually happened. We render interfaces at several sizes, in light and dark themes, with real content of realistic length, including the long names and empty states that real users produce. For motion, we capture frames over time, because many motion problems only exist between frames: an element that briefly overlaps another, an easing curve that overshoots, a stagger that makes the eye jump backward.

Second, critique models. Given the render and the intent, the critic produces specific feedback. The intent matters enormously. “A calm onboarding screen for first-time editors” and “a dense control panel for power users” should be judged by completely different standards.

The feedback we push for is concrete and fixable. The primary action competes with the secondary one. The easing on this transition overshoots by too much for a calm interface. These two cards don’t share a baseline. This text is too long for its container at phone width. The empty state gives no hint about what to do next.

Vague feedback like “improve the visual hierarchy” is useless to an agent. It will make random changes and call it an improvement. Specific feedback can be acted on, and, importantly, verified: after the agent fixes the baseline, the critic can check whether the baselines now align.

Third, visual evals. We maintain a fixed set of design tasks with pairwise human judgments about which result is better. When we change the critic, we measure whether it agrees with good designers more or less often than before. Without this, we’d have no idea whether the critic was improving or just changing its opinions.

The Loop

Put together, the loop looks like this. An agent builds something. The system renders it. The critic looks at it in context and writes specific notes. The agent revises. The critic checks again. When the critic has nothing important left to say, or when it’s unsure, the result goes to a human.

It sounds mechanical, and in a way it is. But the effect is surprisingly human. It’s very similar to how a junior designer works with a senior one: make something, get specific notes, revise, repeat. The difference is that the loop can run many times in minutes, so by the time a human sees the work, the obvious mistakes are gone.

What I’ve Learned So Far

Critics are better at catching problems than at proposing beauty. That’s fine. Most bad interfaces aren’t bad because they lack brilliance; they’re bad because of twenty small mistakes. Removing those mistakes gets you surprisingly far. A screen with nothing wrong is not automatically great, but it’s usually decent, and decent is a big step up from what agents produce by default.

Motion is harder than layout. A layout can be judged from a still frame. Motion needs time, and the difference between “smooth” and “alive” is subtle. Our work on Deep Motion helps here, because we’ve spent a long time thinking about what makes movement feel intentional: anticipation before a big move, follow-through after it, staggering related elements so the eye can track them.

Consistency is a system property. It’s not enough to judge one screen. A button can be perfect on its own and wrong next to the other buttons in the product. We had to give the critic memory of the product’s existing patterns, so it can say “this doesn’t match how we do it elsewhere.”

The critic must be humble. When it isn’t sure, it should say so and leave the call to a human. An overconfident critic is worse than none, because it trains agents to optimize for its quirks. Some of our most important work has been teaching the critic to express uncertainty honestly.

Taste has cultural dimensions. Building for Persian-speaking users, I’ve seen that some design conventions don’t transfer. Right-to-left layouts, Persian typography, and different expectations about density and ornament all affect what “good” means. A critic trained only on Western design norms will give bad advice for a large part of the world.

The Risk of Homogeneity

There’s a real danger I think about often. If every agent uses the same critic, will every interface start to look the same?

It’s a fair worry. Design systems already push products toward similarity, and AI could accelerate that. A world where every app has the same rounded corners, the same gradients, and the same spacing scale would be efficient and boring.

My current answer is that the critic should judge craft, not style. It should notice misalignment, inconsistency, poor contrast, and confusing hierarchy, which are failures in any style. It should not impose a particular aesthetic. A brutalist interface and a soft, playful one can both be well-crafted. The critic’s job is to help each be the best version of itself, not to turn them into each other.

Achieving that in practice is hard, and I don’t claim we’ve solved it. But it’s the principle we design against.

Why It Matters

As more software is built by agents, the floor rises: things will work. The ceiling is set by judgment.

I’d like agents to reach for the ceiling, and that starts with teaching them to notice when they’ve missed it. Not to replace the designers who define what great looks like, but to make sure their standards reach every screen, even the ones no designer has time to look at.

If we get this right, the age of AI-built software won’t be an age of competent ugliness. It could be the first time that care for craft scales as fast as the software itself.