The past few years have profoundly reshaped my work and days as a designer. I won’t lie—it feels like nearly everything has changed. With genAI here and undeniably real, I sometimes wonder if I’m still necessary at all. But more than anything, what’s most striking isn’t just the tech itself, but a shift in the very way I approach design—the process, if you can still call it that, because linear design no longer applies.

Last year, I collaborated with a startup on building reputation systems, exploring how we can own, curate, and verify our own algorithms. Designing a reputation system taught me this: you don’t create it with a clear end state because you simply don’t know, understand, or maybe can't even imagine it. Instead, you set up the foundation, then continuously tune, tweak, and evolve it. The more people interact with it, the more the system teaches you. Every element of a reputation system—whether it’s the way we weigh values, the placement of buttons, or even the names we give things—affects everything else. You build the ship while you sail it.

“You can’t really get into a linear design mode.”

That was my realization. In this type of design, you’re not just building a system—you’re co-creating with every user, every input, all at once. You can’t design the “final” thing because it doesn’t exist, yet it’s already here—kind of a paradox. The process is cyclical and recursive, more like an Escher painting or a Möbius loop, a circular flow that feeds back into itself. It’s a design ouroboros, forever consuming and renewing itself.

So maybe design today is no longer a set of steps. There’s no old-school design thinking “double diamond,” no clean ideate-prototype-build sequence. Instead, it’s all happening at once, all the time with the real thing. It’s no longer just design; it’s organic design.

Before, I saw prototypes as quick learning tools, conversation starters, a proof of concept, stepping stones toward a final product. But now, prototyping has become existentially different. What I learned from designing algorithms or reputation systems, you can’t prototype in isolation, you build in reality. You can’t control the system; it reveals itself only in real environments. You have to test within the wild because every change echoes through the entire structure. The system itself unveils what works. You’re not a builder—you’re a curator.

The product becomes a living organism, constantly evolving in response to every nudge, every variable you adjust. It’s a lot less about perfecting aesthetics or designing on an infinite server-side canvas; instead, it’s about letting the product grow, adapt, and redefine itself by designing it live in its final environment. Those builds aren’t just plans—they’re the start of a continuous dialogue with the real world.

For me, sometimes self-labeled a UX/UI designer until a few years ago, click-through dummy prototypes were the pinnacle of design. You could sketch the potential, make a case for what the final product might look like. But today, if all you’re doing is creating something that “looks like” the end product, you’re already behind. You’re part of a culture of “guesswork” design, and guesswork doesn’t cut it anymore.

Now, I feel an urgency to test my work with real code, real functionality. With tools like Cursor, V0, Replit, and Valtown, I’m closer to engineering than I ever imagined. My prototypes don’t just simulate; they actually function. There’s a new dynamic tension here—you’re coding the reality while you design it, closer to a conductor’s world than an architect’s.

Yes, there are quirks and bugs to work out, but it brings design to a very raw form, where experimentation is as real as it gets. You don't bring a prototype to the field. The field is as much the design as the design itself is. Young, naive me would obsess over the perfect border radius, the visual polish. Now? I skip the infinite canvas and go straight into the build. I am designing organisms with real mechanisms, not still lives.

If you build with LLMs, you’re creating within a strange, empowering trap—a design ouroboros. You’re designing the ship as you define it, bound to this continuous loop where the end is the beginning. It’s a design process that’s profoundly different, one that shifts discovery into real time and lets the product evolve with me. It’s not just a cycle; it’s entangled, braided, like a Möbius strip folding back on itself.

“My design loops are real loops, more like entangled Möbius braids.”

Products aren’t static outcomes anymore; they’re continuous experiments, reacting and morphing with every interaction. When you design tools, you shape the use cases, the outcomes, and the ecosystem itself. Every interaction, every user, becomes part of the process.

You design the real product as you build it. The edges blur; the end is the beginning, and the beginning is the end. Maybe my role is less about finishing and more about cultivating.

So, some observations about this design ouroboros:

• The Product Shapes Itself: Design isn’t a blueprint; it’s a behavior. You set the initial trajectory, but the product takes on its own life.

• Real Loops, Not Lines: Every prototype is the final product. The steps fold back into each other; there is no linear path.

• Continuous Collaboration with Reality: You’re building in the real world, adjusting, responding, adapting. The system is as much your guide as it is your creation.

• The End is the Beginning is the End: There’s no finality, only iterations. Every release, every tweak, every nudge is a new beginning.

Oh you cute design ourobors.