I've been thinking a lot about what it means to "design" something.
For most of web design's history, the answer was obvious: you drew boxes, picked colors, arranged text, tweaked spacing. Then you did it again for mobile. Then again for tablet. Then you wrote CSS until 2am because Safari decided your flexbox should render differently than everyone else's.
That model is dying. Not dead—dying. And watching it happen is strange.
When the work becomes describing what you want
Here's what changed: the bottleneck moved. It used to be execution—turning ideas into pixels into code. Now it's articulation. Can you describe what you need clearly enough that a system can generate it?
This sounds simple until you try it. "Make me a landing page" produces garbage. "Make me a SaaS landing page with social proof above the fold, three-column feature comparison, and a pricing table that emphasizes the middle tier" produces something you can actually use.
The skill isn't drawing anymore. It's knowing what to ask for.
Most designers I talk to find this threatening. They're not wrong to feel that way. When you've spent years mastering tools, watching those tools become irrelevant is uncomfortable. But I think they're focused on the wrong threat.
The real question isn't whether automation can replace the mechanical parts of design—of course it can. The question is whether it can replace taste.
What machines are genuinely good at
Pattern matching, obviously. Feed a system ten thousand e-commerce sites and it learns that product images work better large, that trust badges matter near checkout buttons, that color psychology isn't mysticism when you have conversion data at scale.
This terrifies junior designers who just learned those same patterns. It should excite senior ones. Because once the patterns are automated, the only competitive advantage is going beyond the patterns.
Consistency at scale is another win. Try maintaining perfect 8px spacing across a hundred-page site by hand. Now imagine doing it while someone else on your team is also making changes. Now imagine you have a deadline.
Automated systems don't get tired. They don't forget to check the mobile breakpoint. They don't accidentally use #333333 in one place and #333 in another and rgb(51, 51, 51) in a third because you've been staring at code for six hours.
This is unglamorous work. Nobody got into design because they love checking contrast ratios. Automation handles the busywork. That's the entire point.
The architecture underneath
Component-based generation is the only approach that actually works. Monolithic page generation sounds appealing until you need to change something. Then you're regenerating entire layouts because you wanted to tweak a button.
Components compose. You build navigation, hero sections, feature grids, testimonial blocks, pricing tables, footers. Each one handles its own responsive behavior, accessibility, performance. Then you combine them intelligently based on what the page needs to accomplish.
This requires design systems, which means decisions. What's your spacing scale? Which fonts? How many semantic color tokens? How do buttons behave on hover, focus, active states? What's the animation timing function?
These decisions don't go away with automation. They move upstream. You're encoding judgment into a system that then applies that judgment consistently. This is harder than it sounds.
Semantic understanding is where it gets interesting. A good system knows that "hero section" implies large text, prominent CTA, possibly background imagery or video. It knows "pricing table" means comparison, emphasis on a recommended option, clear feature differentiation. It knows "testimonial grid" needs faces, quotes, and usually some credential or company logo for credibility.
You can hand-code these patterns. Or you can teach a system the patterns and generate variations infinitely. The second approach scales better.
Who this actually helps
Small businesses obviously. The bakery doesn't need a custom design. They need something clean that shows their menu, takes orders, and doesn't look like 1998. Automated design gives them the 80% solution for a fraction of the cost.
But startups are more interesting to me. The ability to test messaging fast changes what you can experiment with. Instead of bikeshedding your hero copy for weeks, spin up five variants and see what resonates. Kill the losers. Iterate the winners. Move.
Agencies use this to handle the boring projects faster, which frees capacity for interesting work. A five-page brochure site doesn't need three designers and a developer. Automate it, deliver fast, charge appropriately, use the margin to fund weird experimental projects.
Enterprises need consistency at scale. When you have fifty product marketers creating campaign pages, automation is the difference between brand chaos and coherent experience. Give them constraints. Let them move fast within those constraints.
Where humans still matter (and probably always will)
Strategy is ours. What are we building? Why? For whom? What's the goal? How do we measure success? Machines can optimize toward a metric. They can't tell you if you picked the right metric.
Taste is ours. When the automated system generates three layout options and they're all technically correct—good hierarchy, proper contrast, semantic HTML—which one feels right? That judgment is human. Maybe it always will be.
Edge cases are ours by definition. The 80/20 rule applies here. Automation handles the common cases beautifully. The weird client request, the unusual interaction pattern, the experimental idea nobody's tried before—these need human attention.
User research is ours. You can automate A/B testing. You can't automate understanding why someone bounced. Machines see correlations. Humans find causes.
What's actually coming
Personalization at scale is inevitable. Not the creepy "we tracked you across seventeen sites" personalization. The useful kind: "This visitor cares about security features based on behavior, show them security-focused content above the fold."
Every visitor gets a subtly different experience optimized for their context and needs. This is technically feasible now. It'll be commonplace soon.
Multivariate testing becomes automatic. The system generates layout variants continuously, measures what works, kills what doesn't, compounds wins. Your site evolves without you thinking about it.
This makes some designers uncomfortable. "My beautiful design!" they say. But sites aren't art. They're tools. If a less beautiful version converts better, ship the less beautiful version.
Generative exploration changes the creative process. Instead of iterating one design through twenty versions, generate twenty starting points instantly. Pick the most promising. Refine from there. This compresses the early exploration phase from days to minutes.
The messy middle we're in right now
We're between paradigms, which means everything's awkward. Half the industry is clinging to the old model—full control, pixel-perfect mockups, design systems as documentation. The other half is experimenting with generation, automation, AI-assisted workflows.
Neither side has it figured out yet.
The old model doesn't scale to modern product velocity. The new model doesn't handle edge cases or brand differentiation well. We need both. The question is what the interface looks like between them.
My guess: design becomes more like programming. You work at higher abstraction levels. You define systems, specify constraints, describe intent. The mechanical execution happens automatically. Your value is in the architecture and taste, not the pixel-pushing.
This isn't the future. It's now. The tools exist. People are using them. The question is whether you're adapting or waiting for permission.
I don't know if this is better. But it's definitely different. And it's happening whether we're ready or not.