Generation used to be the bottleneck. You would sketch three directions, maybe five if the deadline let you, and the hard part was getting from blank canvas to something on screen.
That part is basically free now.
Ask Lovable or any AI prototyping tool for fifty variations of an onboarding flow and you will have them before your coffee is done. Different layouts, different copy, different hierarchy. All functional. Most of them defensible in a critique. (If you want to see how real products handle that kind of volume, the Lovable onboarding teardown on AI UX Playground walks through what actually shipped.)
So what is the bottleneck now?
Not making things. Choosing between them.
Framer - The best code-free tool for designers to create beautiful websites. Use our special promotion code: partner25proyearly to get 3 months free yearly Pro subscription.
Anything AI — Turn your words into mobile apps and sites with great taste.
SoloFounder.fyi — AI is supercharging solo creators. 162+ curated tools to launch, market, and run your one-person business.
I have started calling this decision clarity: the ability to look at ten plausible options and know, quickly and for real reasons, which one is right.
Not which one is prettiest. Not which one you saw first. Which one actually serves the user’s intent, fits the product’s voice, and will not fall apart in week three of production.
This sounds obvious when you say it out loud. It is not obvious in practice.
Most of us were trained for the opposite problem. Design school, design crit, design Twitter: all of it optimized for generation. Come up with the idea. Defend the idea. Iterate on the idea. Nobody taught a class called “How To Pick.”
Now picking is the job.
That shift shows up everywhere. Products that generate multiple outputs need UI that supports comparison, not just creation. Patterns like Variation Picker, Regeneration Carousel, and Output Comparison View exist because the hard part is no longer “can we make another version?” It is “which version should we ship?”
When you generate something yourself, you understand why it exists. Every line has a reason, even a bad one. You can defend it because you lived inside the decision that produced it.
AI output does not come with that history. You are handed a finished thing with no trace of the reasoning, and you have to reverse-engineer whether the reasoning would have been any good.
That is a different cognitive task entirely. Closer to editing than to authorship. Closer to critique than to craft.
And critique, real critique, is a skill you build by doing it badly for a few years first. There is no shortcut. Which is exactly why it is suddenly valuable: it cannot be generated alongside the options it is supposed to judge.
This is the uncomfortable flip I wrote about in The Week I Realized I Was Learning the Wrong Thing. The tools got faster. The fundamentals that matter did not change. Trust, craft, and decision quality still separate work that ships from work that demos well.
If you want a structured starting point for critique itself, the Design Critique skill on the site covers formats, feedback types, and how to run a session without it turning into taste warfare.
When I am staring at a wall of AI-generated variants, I run through four questions, in this order:
1. Intent match. Does this solve the actual problem, or does it just look like a solution to a problem in this general category? AI is excellent at producing plausible-looking answers to slightly wrong questions.
2. Voice fit. Could this have shipped from any product, or could it only have shipped from yours? If you cannot tell which company made it without the logo, that is a flag, not a feature. This is where design system discipline and product-specific teardowns matter. Compare how ChatGPT and Claude make different bets in the same surface area.
3. Failure surface. Where does this break? Empty states, slow networks, a user who ignores the happy path entirely. Generated output is usually optimized for the demo case, not the messy one. Error Recovery Strategies and empty-state patterns are good reminders of what AI tends to skip.
4. What I would defend in six months. Not what is clever today. What you would still stand behind once the novelty wears off and it is just part of the product.
None of these are new design questions. What is new is doing them at volume, fast, across dozens of options instead of three.
The best AI products do not just generate more. They build decision infrastructure around the output.
Response Refinement gives users a vocabulary for iteration without retyping the whole prompt. Human in the Loop and Approval Workflows treat judgment as a first-class step, not an afterthought. The Trust Stack is basically a product argument that capability without legibility does not convert.
If you are building AI features, your job is not only to pick well yourself. It is to design surfaces that help teams and users pick well too.
For a more formal version of that mindset, the AI Evals skill treats evaluation rubrics as the requirement doc for AI features. Same muscle, different packaging.
Watch what is showing up in job posts. Less “generate concepts,” more “evaluate output,” “maintain quality bar,” “own the design system as it applies to AI-generated work.”
Teams that used to need five designers to produce options now need fewer people producing and more people deciding. That inverts what used to make someone senior.
I wrote about this shift when Ramp started hiring AI-first designers. The language is new. The underlying ask is not: can you move fast with AI, and can you still own the outcome?
We turned that into a practical skill: AI Native Product Designer. It is basically a rubric for what “good judgment at AI speed” looks like in a real product org.
Juniors are usually strong at generation and weak at judgment, because judgment is the thing experience builds. That used to be fine. Generation was the expensive part, so you hired for it.
Now generation is cheap and judgment is the constraint. The people most valuable on a team are the ones who have made enough bad calls already to recognize a good one fast.
If you are early in your career, this is the uncomfortable part. The muscle that makes you valuable is not the one AI made cheap. It is the one you can only build by being wrong a lot, on purpose, in front of people who will tell you why.
That is also why I think the design engineer profile keeps getting louder. Not because everyone needs to code. Because the people who can evaluate generated output against real constraints are the ones teams actually need.
You do not build decision clarity by reading about it. You build it by deliberately practicing the judgment call, the same way you would practice any other skill: repetition, feedback, a framework to keep you honest when you are tired and just want to pick the first option that looks fine.
Start small.
Next time a tool hands you five variants, force yourself to write one sentence of justification for whichever one you pick, before you pick it. Not after. The after-the-fact reason is always better than the real one.
If you cannot write that sentence, you do not know why you are choosing it. That is the whole skill, in miniature.
It will not feel like design at first. It will feel like editing.
Get used to that. Editing is the job now.
Go deeper on AI UX Playground
Browse 150+ AI UX patterns with interactive demos
Study how top products handle composer, output, and onboarding in Product Teardowns
Grab reusable Agent Skills for critique, evals, and AI-native design workflows
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.