Impeccable for Claude: Fixing the "AI Slop" Problem in UI Design

Ask an AI coding assistant to build a dashboard or landing page, and you already know what you're getting.

Inter font. Purple-to-blue gradient in the hero. Rounded cards nested inside more rounded cards. Muted gray text on colorful backgrounds. Maybe some oversized icons.

It works. It just looks like everything else.

Designers have started calling this "AI slop" — not broken design, but design so statistically average it disappears. Impeccable for Claude is an attempt to fix that.

Built by former Google engineer Paul Bakaus, Impeccable is an open-source Claude skill that introduces actual design judgment into the generation pipeline. Instead of producing whatever pattern appears most frequently in training data, Claude gets access to structured design principles, a command system for iteration, and explicit rules about what to avoid.

The difference in output is real enough to be worth paying attention to.

What It Is

Impeccable installs as a skill for Claude and changes how the model handles front-end design decisions. It covers seven areas: typography systems, color and contrast, spatial layout, motion design, interaction states, responsive behavior, and UX writing. Each has reference material Claude can draw from instead of defaulting to pattern mimicry.

The command system is where it becomes genuinely useful day-to-day:

/impeccable audit — checks accessibility, responsiveness, structure
/impeccable critique — reviews hierarchy and design cohesion
/impeccable polish — final refinement pass
/impeccable bolder — pushes a safe design into more distinctive territory
/impeccable quieter — reduces visual noise
/impeccable distill — strips unnecessary complexity

Instead of regenerating from scratch when something feels off, you can be specific about what to fix. That changes how iteration feels. It becomes a conversation rather than a lottery.

The Problem It's Solving

Claude could always generate functional front-end code. The limitation was never technical. It was that Claude, like every major language model, learned from enormous amounts of publicly available design — which mostly means it learned what's common. And what's common on the web is usually the safest, least interesting version of any idea.

So every AI-generated interface looked vaguely like the last one. Same layout bones. Same color logic. Same spacing decisions.

What Impeccable adds is constraint. Experienced designers know things like: not every section needs a card, not every modern UI needs a gradient, centered layouts are often the lazy choice. These aren't rules you can easily summarize in a prompt. They're the accumulated judgment of people who've built a lot of things and noticed what stops working.

Impeccable tries to encode that.

The anti-pattern system is probably its most useful feature — not because telling Claude what to do is hard, but because telling it what not to do is surprisingly effective at changing output. It interrupts the habitual tendencies.

Why This Matters

The honest version: Impeccable is still early. It won't turn a mediocre design brief into something great, and it doesn't solve the underlying problem of language models optimizing for average.

But it demonstrates something worth taking seriously. The bottleneck in AI-generated UI isn't compute or model size. It's design knowledge. Give the model better constraints and better vocabulary, and the output shifts. Not always dramatically, but reliably enough to matter.

The command system also changes how non-designers can work with the tool. Saying "make this look better" produces generic results. Saying "/impeccable bolder" or "/impeccable distill" produces something more directed — because the instruction is precise, and precision is what separates useful AI output from noise.

For teams using Claude for UI prototyping, it's worth trying. For solo designers, the audit and critique commands alone speed up review cycles. For developers who need generated UI that doesn't require complete visual reconstruction before shipping, it changes the calculus on what's actually usable.

The era of purple gradients and recycled SaaS skeletons doesn't end here. But this is a reasonable step toward design tools that understand what they're building rather than just mimicking what they've seen.

What still reads as AI-generated?

A few transitions between sections feel a bit too tidy — every paragraph wraps up cleanly before the next starts
"The honest version" opener could be more integrated rather than signposted
The closing is still a touch conclusory ("doesn't end here... reasonable step")
The command list reads like a spec sheet in an otherwise conversational piece

The Actual Problem

Every AI-generated interface looked vaguely like the last one. Same layout bones. Same color logic. Same spacing decisions.

What Impeccable adds is constraint. Experienced designers carry knowledge that's hard to summarize in a prompt: not every section needs a card, not every modern UI needs a gradient, centering everything is often just the lazy choice. These are the accumulated instincts of people who've shipped a lot of things and noticed what stops working.

The anti-pattern system is probably the most useful piece. Telling Claude what not to do turns out to be surprisingly effective at changing output — it interrupts the habitual tendencies instead of just layering new instructions on top of old ones.

What It Actually Changes

This is still early. It won't rescue a vague design brief, and it doesn't solve the underlying problem of models optimizing toward average.

But it does demonstrate something real: the bottleneck in AI-generated UI isn't compute or model size. It's design knowledge. Give the model better constraints, and the output shifts. Not always dramatically, but reliably enough to matter.

For non-designers, the command vocabulary helps too. "Make this look better" produces generic results. "/impeccable bolder" produces something directed. The instruction is precise, and precision is what separates useful AI output from noise.

For teams doing UI prototyping with Claude, it's worth trying. For developers who need generated interfaces that don't require complete visual reconstruction before shipping — it changes what's actually usable. The audit and critique commands alone cut down review cycles.

There will still be purple gradients. But the gap between AI-generated and designer-made UI is narrower with this than without it, and that's a more honest claim than most design tools make.

4A For Information

Main menu

Pages