Slop in a better suit | SKETCHYMEDIA™

There is a category error happening in the current conversation about AI and design.

Everyone has correctly noticed that AI-generated websites tend to look the same.

Purple gradients. Giant centred headlines. Three identical feature cards. Floating dashboard screenshots. Glowing orbs. Rounded rectangles inside more rounded rectangles. A vaguely futuristic illustration that has almost nothing to do with the product.

So a new class of tools has emerged promising to give AI “taste”.

They ban the purple gradients. They introduce serif typography. They vary the grid. They add more whitespace. They replace the three feature cards with a bento layout. They sprinkle in scroll animation and put an art-directed image behind the hero.

The result is usually better.

But it is not taste.

It is slop in a better suit.

Anti-slop is not taste

Taste Skill is a useful example.

Its framework tells an AI agent to study the brief, avoid known AI patterns, choose more varied layouts, and control visual density and motion. It contains sensible rules about typography, spacing, accessibility, and composition. It even explicitly bans some of the clichés that make generated websites instantly recognisable as generated websites.

That is valuable.

But it is better described as a design linter.

It catches obvious tells. It prevents some poor decisions. It gives the model a larger catalogue of accepted patterns to choose from.

What it cannot do is answer the most important question:

Why should this particular product look and behave this particular way?

An asymmetric hero is not a creative direction.

A serif font is not a creative direction.

A sticky-stack animation is not a creative direction.

A tasteful colour palette is not a creative direction.

They are ingredients.

Taste is deciding which ingredients belong together, which ones must be rejected, and what larger idea they are all serving.

A prettier default is still a default

A lot of supposedly tasteful AI design is simply the same underlying website architecture with a more expensive skin.

The generic SaaS layout remains intact:

Navigation. Hero. Social proof. Feature cards. Big generated image. Testimonials. Pricing. CTA.

The purple gradient becomes an editorial photograph.

The glowing orb becomes a beautifully rendered 3D object.

The generic dashboard mock-up becomes a generated brand image.

But the thinking underneath it has not changed.

The image is doing all the work while the page beneath it remains structurally anonymous.

It looks designed at first glance. But it could still belong to almost anything.

That is the test people are missing:

Could I replace the logo, copy, and screenshots and use this design for an entirely different company?

When the answer is yes, the work may have style, but it does not yet have authorship.

And interchangeable design is still slop, even when it is beautifully typeset.

Taste begins with an organising idea

Taste is not a collection of visual preferences.

Taste is the ability to recognise the right organising idea and make hundreds of decisions serve it.

It is deciding:

what the product should feel like
which parts of its story deserve emphasis
what visual metaphor belongs uniquely to it
what should move and why
what must be removed
where consistency matters
where tension or surprise is necessary
which conventions should be preserved
which conventions should be rejected

The individual choices might be small. A line. A rhythm. A transition. A type treatment. A particular kind of spacing.

But they all originate from the same thought.

Taste is not simply aesthetic preference. It is judgment applied in context.

The Tankly example

Tankly is an aquarium app I built for iOS and web. Fishkeeping is a data problem dressed up as a hobby, and Tankly exists to make an invisible ecosystem legible before it fails.

These three screens tell the whole story of this article.

The first screen is raw AI output. It is not technically broken. It has cards, parameters, hierarchy, a tab bar. It looks like software. That is the problem. It could be any monitoring app for anything.

The second screen is what a skill gets you. Cleaner typography. A considered layout. A proper focal point. Clarity. This is genuinely useful, and it is exactly what a design linter should do: refine, clean up, remove the tells.

But it is still assembled from ingredients. Nothing on that screen belongs uniquely to this product.

The third screen is where taste enters, and it did not come from a prompt.

The idea was that the tank itself should be the interface. Not a photo of a tank. Not an icon of a fish. The actual living object at the centre of the product, rendered with real dimension.

So I spent hours building custom tanks and custom illustrations. Hundreds of them. And when I placed them into the screen, I animated the water surface, so the object does not just sit there. It behaves like water.

That is what gives the app a visual dimension no other aquarium app has.

AI supplied the foundation. The skill supplied the refinement and the clarity.

But the idea, and the execution of the idea, is where the taste lives.

AI, on its own, would never have arrived there.

The emerging role of the design engineer

The design engineer of the AI era is not simply the person who takes an AI-generated interface and makes it prettier.

They are the person who defines the world the AI is allowed to create inside.

They turn product strategy into visual grammar.

They decide that a product should behave like an instrument, an archive, a workshop, a field guide, a control room, or something that has never existed before.

Then they make that direction executable through:

layout systems
components
typography
interaction rules
motion behaviour
visual motifs
design tokens
implementation constraints

The old model separated the person who imagined the interface from the person who built it.

AI is collapsing that boundary.

The most valuable design engineers will be able to form the idea, prototype it, encode it, and then direct multiple agents to expand it without diluting it.

They will not design every screen.

They will design the language from which the screens are generated.

AI can execute taste. It cannot reliably originate it.

This does not mean AI has no role in creative direction.

AI is extremely useful for exploration. It can produce variations, find references, test compositions, build animation prototypes, and rapidly express an established visual system.

But generation is not judgment.

AI can generate options.

It can increasingly recognise patterns.

It can learn what you usually approve or reject.

But it still needs somebody to determine whether the work is relevant, ownable, culturally aware, and worthy of existing.

That is taste.

How we can force AI down a better path

A universal “taste prompt” is probably the wrong goal.

A generic model cannot possess everyone’s taste simultaneously. The more universally acceptable its output becomes, the more likely it is to converge on another polished average.

The real opportunity is to build a system that allows a human to:

establish a distinct creative direction
encode that direction into executable rules
make every AI agent work consistently within it
detect when generated output is drifting back towards the average

The system should not merely remove bad defaults.

It should generate and preserve core tasteful elements.

Those elements are not fonts, gradients, cards, or fashionable layouts. They are the decisions that give a design authorship.

1. Begin with product truth, not visual style

Before the system generates a page, it must understand the product.

It should extract:

What does this product uniquely do?
What invisible thing does it make visible?
What tension is it resolving?
What does the user gain emotionally, practically, or socially?
What behaviour, object, environment, or system could become its visual metaphor?
What does the category normally look like?
Which conventions are useful?
Which conventions have become clichés?
What must this product never be mistaken for?

For Tankly, this might produce:

A living ecosystem made legible before it fails.

That sentence is more useful than:

Calm, glassy, premium hobby app.

The first contains an idea.

The second contains styling instructions.

2. Create a taste kernel

Every project should have a small set of foundational decisions that all later design work must inherit.

This is the taste kernel.

It should contain:

Product truth

The core idea the design must express.

Point of view

What the product believes about its category and the world around it.

Central metaphor

The object, system, or behaviour that gives the visual world its logic.

Emotional target

What the experience should make the user feel: in control, curious, reassured, powerful, precise, playful, or something else.

Tension

The deliberate contrast that keeps the design from becoming bland.

Examples:

precise but human
technical but warm
dense but legible
restrained but kinetic
serious but not corporate

Signature behaviour

One interaction or motion principle that belongs to the product.

Anti-direction

What the product must never become.

The taste kernel is the part that cannot be replaced by a list of accepted UI patterns.

It gives every later choice a reason to exist.

3. Force genuinely different creative territories

The agent should propose three to five mutually exclusive worlds, not five variations of the same hero section.

For Tankly, those territories might be:

The living specimen

The tank itself is the interface: a dimensional object at the centre of every screen, with the data orbiting it.

The water lab

Chemistry as precision instrumentation. Readings, ranges, gauges, and calibrated intervals.

The field journal

A naturalist’s record. Observations, sketches, and entries accumulating over time.

The glass room

The whole app behaves like an aquarium: glassy surfaces, depth, light passing through layers.

Each territory must define its own:

organising idea
visual metaphor
spatial logic
typography
colour behaviour
material treatment
motion rules
image strategy
interaction behaviour
forbidden patterns

No code should be generated until one territory is selected.

This is where human judgment remains essential.

The system can expand the possibility space. The human chooses which world is worth building.

4. Generate primitives before pages

Current AI design works backwards.

It selects a familiar page skeleton and decorates it afterwards.

A better system should first create the project’s visual vocabulary:

line behaviour
grid logic
edge treatment
shape language
type relationships
image treatment
depth rules
spacing rhythm
motion curves
transition behaviour
icon language
data-display logic
states for quiet, active, loading, and complete

These are the core tasteful elements.

They should be derived from the taste kernel rather than selected from a generic component library.

Only after the primitives are approved should the system assemble pages.

The page is an expression of the language.

It is not the language itself.

5. Make every decorative element earn its place

The system should require provenance for every distinctive design decision.

For each motif, animation, image treatment, or unusual layout, the agent should be able to answer:

What product truth does this express?
What user behaviour does this support?
Why does it belong to this brand?
What would be lost if it were removed?
Could this same idea be used unchanged for an unrelated company?

If an element exists only because it “looks premium”, it is a candidate for removal.

This does not mean every detail has to be literal.

Tasteful work can be abstract, emotional, and expressive.

But it should not be arbitrary.

6. Encode the direction into the repository

A practical implementation could look like this:

/design-direction
  PRODUCT_TRUTH.md
  TASTE_KERNEL.md
  CATEGORY_CLICHES.md
  CREATIVE_TERRITORIES.md
  CREATIVE_DIRECTION.md
  VISUAL_GRAMMAR.md
  MOTION_GRAMMAR.md
  CONTENT_GRAMMAR.md
  ANTI_REFERENCES.md
  DESIGN_EVALS.yaml

  /references
  /anti-references
  /approved-screenshots
  /primitives
  /motion-tests

This becomes a project-specific constitution.

Every coding agent, design agent, and image-generation agent reads it before producing work.

The purpose is not to prescribe every pixel.

It is to stop agents from reverting to the average whenever they encounter an ambiguous decision.

7. Separate invention from execution

The system should have distinct phases.

Phase one: discovery

Understand the product, category, audience, and strategic tension.

Phase two: territory creation

Generate genuinely different creative directions.

Phase three: selection

A human chooses, combines, or rejects the territories.

Phase four: grammar creation

Turn the selected direction into primitives, rules, and signature behaviours.

Phase five: execution

Generate pages, components, imagery, and motion inside that grammar.

Phase six: critique

Render the result and test whether it still expresses the original idea.

Most AI workflows collapse all six phases into a single instruction:

Build me a beautiful website for X.

That almost guarantees a polished average.

8. Use visual evaluation, not just code rules

The system must render the actual result and critique what it sees.

A codebase can comply perfectly with a design file and still produce something generic.

Useful evaluations include:

The content-swap test

Could the same design sell an unrelated product after changing its logo and copy?

The provenance test

Can every distinctive motif be traced back to the product, brand, audience, or strategy?

The wallpaper test

Is the creativity confined to one generated image sitting inside an otherwise generic page?

The skeleton test

If all images and colours are removed, is the underlying composition still distinctive?

The repetition test

Is the system coherent, or has every section repeated the same cards, borders, and radii?

The ownable-decision test

Is there at least one compositional, visual, or interactive idea a user might remember later?

The direction test

Can the whole design be explained with one organising thought rather than a list of style adjectives?

The drift test

Has the current output moved away from the approved territory and back towards common AI defaults?

These should be treated like design tests.

A build that fails them should not ship, even if the code is clean.

9. Build anti-pattern detection into the loop

A taste system should recognise when an agent has fallen back on familiar shortcuts.

Examples:

generic centred SaaS hero
arbitrary purple or blue glow
decorative grid with no relationship to the product
three equal feature cards
oversized generated image doing all the brand work
repeated pills and rounded panels
motion added without narrative purpose
“premium” serif introduced without conceptual reason
every section using the same composition
visual references copied too literally
layouts that are fashionable but interchangeable

The system should not merely ban these patterns globally.

Sometimes a centred hero or a three-column grid is exactly right.

The question is whether the choice follows from the direction or from model habit.

10. Give the AI a project-specific taste memory

A real system would learn from:

work the designer approves
work the designer rejects
references they save
anti-references they flag
annotations explaining why
repeated corrections made during projects
examples of successful tension, rhythm, motion, and composition
decisions that were deliberately removed

The important asset is not the image library alone.

It is the reasoning attached to it.

A reference without an explanation encourages imitation.

A reference with an explanation teaches judgment.

For example:

Use this reference for its contrast between rigid structure and playful motion. Do not copy its colour palette, typography, or page layout.

Over time, the system builds a model of the designer’s decisions rather than merely a mood board of their favourite visuals.

11. Use adversarial critique agents

One agent should create.

Another should attack the result.

The critique agent should be instructed to find:

interchangeable sections
borrowed visual language
decorative elements with no provenance
places where the design has become too safe
parts that look generated
unnecessary polish hiding weak structure
contradictions between product truth and visual behaviour
repeated patterns that weaken memorability

A third agent can then revise the work, but it should not be allowed to solve every problem by adding more decoration.

Sometimes the correct revision is subtraction.

Sometimes it is structural.

Sometimes it requires returning to the creative territory rather than tweaking the component.

12. Keep the human at the highest-leverage decisions

The purpose of the system is not to remove the designer.

It is to move the designer away from repetitive production and towards the decisions that define the work.

The human should own:

the product truth
the strategic tension
territory selection
the central metaphor
the taste kernel
signature behaviours
final judgment

The AI can own:

variation
implementation
consistency
propagation
adaptation
documentation
regression checking

That is a far more realistic model than asking AI to become tasteful in the abstract.

The real product opportunity

The defensible proposition is not:

Give your AI good taste.

It is:

Turn your creative direction into an executable system every AI agent has to obey.

An anti-slop framework can be useful within that system.

It can raise the floor.

But it cannot create the ceiling.

The larger system has to enforce a sequence of:

truth → tension → territories → human selection → taste kernel → primitives → implementation → visual audit

That is how we move from styling to authorship.

The human still supplies the judgment.

The machine makes that judgment durable, scalable, and much harder to accidentally sand back into the average.

AI produces the pages. The design engineer authors the language.