AI Can Build Almost Any Design Now. So What Is Design Worth?

Sameer Shaik — Wed, 12 Aug 2026 10:20:20 +0000

A few years ago, if you wanted a website with a unique interaction, a complex animation, or an unusual visual style, there was a good chance you needed someone who knew exactly how to build it.

Today, that's changing fast.

Show an AI a screenshot and it can recreate the layout.

Describe an interaction and it can write the React code.

Ask for a WebGL effect and it can generate the implementation.

Give it a reference from a website and, with enough iteration, you can get surprisingly close.

So I started wondering:

If AI can build almost any design, what actually makes a design valuable anymore?

The cost of execution is falling

This is probably one of the biggest changes happening in frontend development.

Previously, the gap between:

"I have an idea"

and

"I have a working implementation"

was enormous.

You needed design skills, frontend skills, animation knowledge, debugging, responsive layouts, browser knowledge, and a lot of time.

AI is shrinking that gap.

A developer can now describe a complex interaction and get a working React implementation in minutes.

The same thing is happening with layouts, animations, typography, interactions and even WebGL.

Implementation is becoming less expensive.

And I think that changes what we should care about.

But "possible" doesn't mean "good"

AI can generate a thousand different landing pages.

That doesn't mean we need a thousand landing pages.

It can create gradients.

It can create glassmorphism.

It can put everything inside rounded cards.

It can create a huge centered headline with a statistic underneath.

It can make something that looks impressive in a screenshot.

But a screenshot isn't a product.

A design has to answer questions.

Why is this interaction here?

Why does this animation happen?

Why does the user need to wait?

Why does this section exist?

Why this typography?

Why this layout?

Those decisions are still difficult.

In fact, I think they're becoming more important.

The new bottleneck is taste

When everyone has access to the same AI models, the advantage isn't necessarily who can generate the most code.

It's who knows what to ask for.

And more importantly, who knows what to remove.

Two developers can use exactly the same AI model and get completely different products.

One might generate another generic SaaS landing page.

The other might create something with a completely different visual language, unusual interactions, strong typography and a reason behind every movement.

The difference isn't the model.

It's the person directing it.

AI makes experimentation incredibly cheap

This is the part I find most exciting.

Before AI, trying an unusual idea had a cost.

You might think:

"This interaction would be cool, but it would take me two days to build."

So you don't build it.

Now you can try it.

Maybe it works.

Maybe it looks terrible.

Maybe the animation is unnecessary.

Maybe the interaction completely changes the feeling of the page.

But you can find out much faster.

That means we can experiment more.

Instead of spending most of our time implementing the first idea, we can explore five different ideas and choose the one that actually feels right.

AI doesn't just make building faster.

It makes experimentation cheaper.

This is why I'm building Zepa

This is also the idea behind Zepa, an open-source collection of React and Next.js UI components, motion systems, and interactive experiences.

While building Zepa, I've been experimenting with scroll-driven interfaces, animated hero sections, WebGL experiences, custom interactions and other patterns that are interesting to actually use — not just interesting to look at in a screenshot.

Some components are inspired by existing experiences. Others are built from scratch.

The point isn't simply to create another collection of buttons and cards.

It's to explore what becomes possible when the distance between an idea and a working interface gets smaller.

You can explore the collection at zepa.design.

The screenshot is becoming the starting point

A designer might find an interaction they love on a website.

A developer might see a beautiful hero section.

Someone might see an animation on social media or a WebGL experiment.

Previously, that inspiration could remain just inspiration.

Now you can take the idea, describe it to an AI, generate an implementation, change it, break it, rebuild it and eventually turn it into something completely different.

The distance between inspiration and implementation is becoming incredibly small.

That changes how we build.

So what happens to component libraries?

If AI can generate a button, card, navbar or hero section in seconds, simply having a collection of components isn't enough.

The interesting question becomes:

Which components are actually worth using?

Which interactions feel good?

Which animations are worth the performance cost?

Which patterns work across different products?

Which experiences are worth preserving?

Which ideas are interesting enough to remix?

That's why I'm increasingly interested in curation and experiences, rather than simply producing more components.

The goal isn't to have the biggest folder of UI code.

It's to discover things worth building.

The designer isn't disappearing

I don't think AI is killing design.

I think it's changing the job.

When implementation was expensive, knowing how to implement something was a huge part of the value.

As implementation becomes cheaper, other skills become more valuable:

Taste.

Direction.

Product thinking.

Understanding users.

Knowing what to build.

Knowing what not to build.

And perhaps most importantly:

Knowing when something feels right.

AI can generate the possibilities.

We still have to choose between them.

The next era of the web might be more interesting

For years, the web has converged toward a handful of familiar patterns.

Hero.

Navbar.

Cards.

Testimonials.

Pricing.

Footer.

Repeat.

AI could make this worse by generating the same patterns even faster.

Or it could make the opposite possible.

If implementation becomes cheap enough, developers can afford to experiment with ideas that would previously have been too expensive to build.

More strange interfaces.

More playful interactions.

More visual experimentation.

More personal products.

More things that don't look like every other SaaS website.

That's the direction I find exciting.

AI can build almost anything.

Now we have to become better at deciding what is worth building.

And that's what I'm exploring with Zepa.

DEV Community: Sameer Shaik