Consistency in AI Design: The Critic Loop

Getting an AI to produce a good-looking design is no longer hard. What is hard is producing that same quality a second time. You nail it once, you give the same request the next day, and something completely different comes back. In this article I explain where the inconsistency comes from and two concrete fixes for it: the independent critic loop, and turning a design you like into rules.

This article summarizes and expands on two videos by Jack Roberts: Claude Design just got 10X Better... I'm Done and Claude Design Just Solved its #1 Problem. The guidance on writing critics, the rules-file headings and the test examples are additions of this post.

Where does the inconsistency come from?

The root cause in one sentence: the model grades its own homework. It produces a design, then says "done, I did that." In reality it may have skipped half the brief, but the thing evaluating that is the same model again.

The video suggests a simple test: show it a design it produced and ask "what's wrong with this?", then ask the same question a few more times. You will most likely get a different answer each time. With no fixed standard, the model latches onto something different every round.

A quality you cannot reproduce is not worth much. If you cannot use it for a client, for a content series or for a brand, that design was an accident.

How does the critic loop work?

The fix is to take evaluation out of the producer's hands. The video calls this the "gauntlet loop" or "design loop" and credits Matt Shumer with popularizing it on X. The method works like this: you give the model a reference and a standard, the model produces the design, then a handful of independent critics with fresh context step in and test the result brutally. If something is missing, the work bounces back and the loop starts again. Where you get the standard from is what I described in the reference-based design audit.

The "fresh context" part matters. The critics do not see the production process; they see only the result and the standard. A reviewer who watched the process tends to defend the decisions it made along the way.

The skill shown in the video uses three roles:

• The brief critic: "Did you actually do what was asked?" It compares the brief's items one by one.
• The system critic: "Does this output conform to the design system?" Palette, typography, spacing rules. I covered building the system itself in the seven levels of Claude Design.
• The craft critic: Alignment, spacing, proportion, the rendered image itself.

The result is that taste turns into a checklist. That sounds cold, but it is exactly what works: you cannot reproduce something you cannot measure.

An example from the video gives a sense of what a run looks like: three failures in the first round (no logo, the color breaks the monochrome, the headline is too small), then the brand mark too small in the second, then a second accent color problem in the third... In that example it took ten rounds for the piece to settle. Once you account for three separate pairs of eyes looking at every round, it becomes clear why the output is so different.

Turning the design you like into rules

The second fix is more durable. Instead of handing over a design you like and saying "make it look like this," you break it into parts and turn it into rules.

The sequence suggested in the second video:

1. Find the design you like.
2. Measure it, don't describe it. Not "it feels spacious" but "the top spacing is 3× the body text."
3. Argue about which parts actually matter. Not every detail has to become a rule.
4. Write the rules into a file.
5. Write tests that a faulty copy could not pass.
6. Reproduce the original using nothing but your rules.

Step six is the heart of it. Everything that does not hold up when you reproduce it is a rule you forgot to write down. You add it and try again. Within a few rounds your rules file becomes genuinely complete.

The rules need concrete ratios in them: measures like the golden ratio (1.618), the 60-30-10 rule for color distribution, shadow and corner radius values, named layouts. "Make it look modern" is not a rule.

Once that file matures, you can turn it into a reusable agent skill and invoke it every time. A well-built skill asks you for the missing inputs before it starts producing: who is the subject, what is in the foreground, what is in the background.

How do you write a critic?

Whether a critic is useful depends on what you ask it. A critic that asks "is this design good?" gives you an answer you cannot use. A working critic has four parts:

• Input: the result and the standard, nothing else. Do not give it the production process, the variants that were tried, or the model's own reasoning.
• Scope: a single axis. A critic looking at both typography and hierarchy does both superficially.
• Pass criterion: it has to be binary. "Could be better" is not a result; "pass" or "fail" is a result.
• Failure format: which rule, on which element, with which measured value it was broken.

To see the difference, here are two outputs side by side:

• Weak: "The headline may be a bit large; it would be good to review the balance."
• Usable: "FAILED — typographic scale. Headline-to-body ratio is 3.4, the rule is 2.5. Element: page title."

The second is an instruction you can act on directly; the first is a new debate. Once you force your critics to write in the second form, the number of rounds in the loop drops too, because every round closes with a concrete fix.

One more rule: the critic should not propose a fix, only a diagnosis. The producer does the fixing. Put diagnosis and solution in the same place and the critic starts defending its own solution, losing its independence.

What belongs in the rules file?

Your rules file should be made of concrete values. Headings worth filling in:

• Typographic scale: headline and body sizes, the ratio between them, line height, letter spacing.
• Spacing scale: a single base value and its multiples. A 4- or 8-based scale on its own prevents most of the messiness.
• Color ratios: how much of the surface each color covers. The 60-30-10 approach is a good starting point.
• Elevation scale: how many layers there are and what the shadow value of each one is.
• Corner radius: how many distinct values are in use. More than two needs a justification.
• Motion: entry and exit durations, and the easing curve you use.

"Make it look modern" is not a rule. The test for a rule is this: can two different people read it and arrive at the same result?

How do you write a test a faulty copy cannot pass?

This is the most skipped step in the process and the most decisive one. A test means a check that definitively catches a broken rule.

Three types of test do the job in practice:

1. Measurement test: "Body text line height must be between 1.5 and 1.7." Outside that range, it fails.
2. Count test: "No more than two different corner radii on a page."
3. Presence test: "Each section must have exactly one primary call to action."

Here is how to know whether a test is any good: deliberately prepare a broken version and see whether the test catches it. If it does not, you wrote a wish, not a test.

What does this loop cost?

This is where I have to be honest, because the method has a price. A multi-step critic loop can burn millions of tokens on a single job — in the video's examples, a single job came in at roughly 2 to 3 million tokens.

The way to bring the cost down is to split the work: hand the critics off to smaller, cheaper models and keep the actual production on the strong model. In one of the video's examples, about 730,000 tokens ran on Haiku and 1.19 million on Sonnet, so the load did not all land on the most expensive model. That split pulls the cost down.

As the video stresses too: don't use this loop on every job. For a one-off image it is a waste. Where it pays off is on things you will use again and again: templates, key pages, content series formats, brand assets. Content series formats are exactly where motion graphics and icon automation pays off too. It costs you once and then you use it a hundred times for free.

When should you not use it?

• When you do not yet know what you want. The loop will not clarify a vague standard; it will just repeat the vagueness expensively.
• When the work itself is still exploratory. Try a few cheap, fast directions first and open the loop once the direction is clear.
• When the standard is purely subjective. "I want to like it" is not something a critic can test.

Let me add one more thing: you decide when to stop the loop. Once improvement slows down from round to round, going further is just burning tokens.

In short

Inconsistency is not caused by the model lacking ability, it is caused by evaluation sitting in the same place as production. Separate the evaluation — with independent critics or with written rules — and your design goes from an accident to a system. Just account for the cost, and save this heavy machinery for work you will reuse.

Frequently Asked Questions

Does the critic loop replace a design system?

No, they solve different problems. A design system fixes what you produce; the critic loop checks whether what was produced conforms to it. The best result comes from having both.

Can I use this when writing code too?

Yes, the logic is the same. Adding a review step with fresh context, independent of the model that produced the work, helps on the code side as well. The difference is that code already has tests — there the test suite does most of the critic's job.

How many critics are enough?

The method in the video uses three roles, which is a reasonable starting point. Fewer roles can leave a blind spot; more of them raise the cost and make it likelier that the critics repeat each other's findings.

How long should the rules file be?

Long enough to pass the reproduction test. Length is not the goal; the standard is whether you can rebuild the original by reading the rules.

Source

• Jack Roberts, Claude Design just got 10X Better... I'm Done (YouTube, August 2026): the independent critic loop, the three critic roles, the round-by-round example and the token costs.
• Jack Roberts, Claude Design Just Solved its #1 Problem (YouTube, August 2026): measuring a design you like and turning it into a rules file and a reusable skill.

Model names, token counts and tool features change quickly; measure the cost on your own project with a small trial run.