For years, I’ve been following the trend of code first, design second.

Sounds almost blasphemous to a UX designer: Isn’t the whole point of UX research and design to optimize the experience BEFORE a line of code is written?

Yes. But.

Thanks to AI, the cost of and barriers to designing in code have dropped rapidly and significantly.

Meaning that the traditional ways of design handoff are now being rethought. If not by designers, by PMs and devs.

In addition, I've been a practitioner of No Handoff, which prioritizes a shared prototype as the design source of truth. This method also benefits from AI tooling.

At the end of the day, it doesn’t matter what you read in books or on social media. Your UX design workflow all comes down to your own lived experience, and what works best for you and your team.

Using that frame, I am seeing my workflow shift to what I call the "Long Tail* of Design.”

After completing your demand- and supply-side UX research, the start of the product creation process is rapid functional prototyping. In a day to a week or so, you put together a barely working prototype that prioritizes function over form. It can look hideous as hell … as long as it works.

And "works" is a squishy standard. The prototype shouldn't cover all the functionality. Just enough so that a real person can use the prototype just well enough to actually replicate the epicenter of the product's main intention.

Once this functional prototype is in the hands of the product team, early alpha testers, and the design team – that's when real design work begins.

First, the usability feedback loop.

The prototype will reveal numerous various flaws and shortcomings – feature X is kludgy, or feature Y needs interface Z to work properly. That is the first slice of design work: Making the interface usable for the 80% primary use case. This will drive a lot of the initial work for the UX-minded designers.

Second, visual refinement.

The prototype will likely be ugly and require a heavy facelift. Your UI-minded designers will audit the prototype and identify where design needs to go from 3 to 10, and more importantly, where in the product those prioritizations need to occur.

(Side note: Can designers do conceptual visual design in Figma or other non-coding tools prior to the prototype? Of course. I think the mind shift here is that those concepts should be treated like suggestions and ideas, and not laws, unless they are non-negotiable and MUST go into the final product. In my experience, all design is negotiable, because at the end of the day, the product is built for the humans who use it every day, not the digital product team.)

Third, the experimentation and exploration loop. The prototype is designed this way, but what if it had a radically different interface? Or what if a specific key feature was designed in a completely different way?

As development of the main product occurs in parallel, this is the time for AI-assisted designers to branch the prototype and test drive different ideas with themselves and others. (In fact, the greatest sign that you probably failed in the Long Tail is that your initial prototype design and final product design work the same.)

Finally, the product vision and strategy loop. Using the prototype as the living spec, is the business value obvious? What is the product/market fit? Where can this product win in the market, if it launched today? Being real, is the prototype a sign that this project should be killed BEFORE the final product is developed?

(Granted, these are questions closer to product than design, but designers should have a seat at the table IMO.)

To be clear, the "Long Tail of Design" has ZERO to do with vibe coding. In vibe coding you're going from zero to product with the help of AI. In this process, your functional prototype and final product run in parallel after the prototype is built. And the lessons learned and incorporated into your "living spec" prototype inform what the production dev team needs to deliver.

In fact, your prototype code and final product code should be completely different code bases.

So what is your dev team doing during the Long Tail? Well, they are coding the data infrastructure, scaffolding and navigation that is unlikely to change between the prototype and the final product. Then pulling in features, using the prototype as the living spec doc, once refinements narrow and change risk is reduced.

Folks, that is where the “Long Tail of Design” lives in an AI-assisted design era. After that rapid functional prototype creation, the Long Tail is that multi-threaded process to refine and enhance the prototype while the real product is built in parallel.



In my projects, I’m seeing the Long Tail be 5x to 10x of the initial prototype work. So if it takes you a week to stand up the prototype, you’ll get roughly 5 to 10 weeks of design afterward.

The hidden benefit (and grand irony) of the Long Tail, is that by moving supply-side design to the post-prototype side of product development, designers now have greater influence in shaping the final product’s look and feel. Designers come even MORE important at end of the product process than ever before. Because rather than design in Figma, hope it works, and expect the devs replicate the design effectively, designers are now boots on the ground while the product is being finalized.

Similar to walking a construction site, designers can compare their living spec doc (the prototype) to what's being built for real, see for themselves where the rough spots are, and prioritize which parts of the product need more design attention.

*Note: Not to be confused with "The Long Tail" book by Chris Anderson; the reference here is purely coincidental.