I was using Codex to build a side project over the weekend. A lazy vibe-coding session with no wireframes, Figma screens, or specs. Just an idea and an endless prompt thread with an AI.

As I ran out of tokens at record speed, I realized that the way I think as a designer is fundamentally incompatible with how AI coding tools are meant to be used.

The way designers think, aka _the design proces_s

When I start designing something, I don't know what the final outcome will look like. I have a feeling. A loose sense of what the experience should be. The layout, style, flows, interactions, edge cases are details that emerge through making and exploring.

Here's what this looks like translated into Codex: I give it a vague prompt. I see what it creates. I react. I give it more specific instructions. We go back and forth, reverting, detailing, testing and fixing. Iterations in, the product slowly starts to reveal itself.

This is the process. This is design.

It is through loops of this process that the core problem emerges. Tools like Codex and Claude Code are built for workflows where you know exactly what you want. An engineer using Claude Code starts with a clear description of what should be built and the AI implements it. The output is controlled and predetermined. The tool is a medium for execution, not exploration.

But a designer is not doing that. I don't have the answer at the start. I'm finding the answer by building.

The spectrum, as it stands

Think of design tools as a spectrum, from pure vision to pure code.

Figma (as it traditionally was) lives at the far left. It's entirely in the realm of imagination. You can create a hundred frames, explore a hundred directions; nothing is committed, nothing is real. The cost of a bad idea is zero. But Figma is also completely disconnected from the actual medium your product lives in, which is code. And given that we now have the capacity to build real things quickly with AI, keeping design in a simulation feels increasingly wasteful.

Claude Design sits somewhere in the middle. It's rooted in code, produces visual output, and is faster and more tangible than Figma. But it's still a discrete step away, a sandboxed environment that requires translation before anything reaches production. It still feels like a separate process that is useful but not unified.

Claude Code and Codex are at the far right. Here, there's virtually no boundary between design and code. You're working in the real medium, in the real codebase. What you build is what ships and what the users see.

This is ideally the dream. However, it comes with a cost.

When everything is real, everything demands attention

When you design directly in code, every imperfection is visible. Every bug, every pixel that's slightly off, every interaction that doesn't feel quite right. It's all there, demanding your attention, right in the middle of what should be an expansive, exploratory phase.

This creates a cognitive tax that interferes with the creative process.

Every time I notice something wrong, I have to make a judgment call, "Is this a design signal? Is this telling me something important about the experience, something I should address? Or is it just an implementation detail, a rough edge that an engineer would clean up in twenty minutes after a handoff, and that I'm wasting creative energy on right now?".

In Figma, this question doesn't exist. Everything is soft and uncommitted. Nothing is technically real, so nothing technically breaks.

In Claude Code, everything is real. The noise distracts me from actually designing because I get too busy triaging bugs.

The gap in design AI tooling

There is a gaping hole in the design tools that exist in the market right now. This gap sits somewhere between Claude Design and Claude Code. Claude Design is still too far from implementation. Claude Code is too close to it, too soon.

Here's what an ideal AI tool would look like to me personally:

A tool where the early phase feels fluid, low-stakes, and purely exploratory, like Figma, where I can chase ideas without the weight of implementation pulling me down. But one that lives in the same codebase as production, firmly rooted in the realities of the medium. When I'm done exploring, there's no translation layer: no export, no tedious handoff. An engineer picks up the same project in the same interface, handles the technicalities, and pushes it to production.

Why this gap matters

The vibe-coding workflow of loose prompting, reacting, iterating, tightening is new and exciting. But it leaves designers stuck choosing between full creative control with high translation cost (design tools) and less creative control with low translation cost (code tools), with nothing in between that fits the actual shape of the design-development process. The result is a messy workflow still stuck in pre-AI methods, with redundant, inefficient AI steps tacked on top — for a designer who is already overwhelmed trying to keep up with their engineering counterparts who have seen their productivity 10x in the past couple of years.