Skip to content
Miguel Dasalla
8 min read

The Design Engineer Is Already Here

Notes from UX+AI 2026 on why the gap between design and code is closing, and why a frontend developer still has to own the thinking AI cannot do.

Miguel Dasalla

I sat in UX+AI 2026 back on September 6, and it took me this long to finally sit down and write about it properly. The message kept repeating itself in different words from different speakers. Do not be afraid of AI. Use it, but do not hand it your thinking. That line stuck with me longer than any slide deck, and it reshaped how I see my own role as a frontend developer.

The role nobody named on purpose

A designer I follow wrote about this shift before I had the language for it. The short version: AI tools are closing the gap between a Figma screen and a working interface. A design file used to end at the handoff. Now a person with good taste and basic technical fluency can test actual behavior in an afternoon, not a sprint. The title people give this role is not really the point. The point is whether you ship something that works or something that only looks like it works.

That idea sat uncomfortably with me at first. I am a frontend developer. Most of what I know, I built through freelance work and personal projects, and the job always meant turning someone else's screens into divs and components. If AI can now generate a clickable prototype from a prompt, where does that leave the part of my job that used to be pure translation?

What UX+AI 2026 actually taught me

The conference answered that question better than I expected. Every speaker who talked about AI agentic coding, about Claude, about design tools that generate working code, said some version of the same thing: AI compresses the distance between idea and execution. It does not compress the idea itself.

A generated component is not ready to ship the moment it exists. Someone still has to read it, catch where it hallucinated a prop that does not exist, wire it to real data, handle the empty state, the error state, the slow network. That someone needs to understand code well enough to know when the AI is confidently wrong. That is not a smaller job than before. It is a different one.

Taste is the part AI cannot touch

The best product people I have collaborated with on freelance work are not the fastest typers. They are the ones with a clear sense of what the product should feel like before a single screen exists. AI can generate ten variations of a button in seconds. It cannot tell you which one actually belongs in your product. That judgment comes from taste, and taste comes from paying attention, from caring about details most people skip past.

This is where I stopped feeling threatened and started feeling useful again. Frontend development was never just converting screens to code. It was deciding how a component should behave under pressure, how state should move through an interface, what happens when the data is messy or missing. AI speeds up the typing. It does not replace the decision.

Prototyping over handoff

The old workflow went design file, then handoff, then wait for engineering to build it, then a round of feedback on something that no longer matched what the designer imagined. That loop used to take days. AI tools shortened it to hours. Someone with an idea can now test how a flow actually behaves before a single ticket gets written. The screen stops being the deliverable. The working prototype becomes the deliverable.

That shift changes what I need to be good at. I cannot just wait for a finished design and translate it anymore. I need to be part of the conversation earlier, while the behavior is still being figured out, because that is where the real decisions happen now.

Thinking in components and states, not screens

A static screen shows you one moment. It does not show you what happens when the list is empty, when the request fails, when the user has not finished onboarding yet, when the data takes three seconds to load instead of zero. Thinking in components and states means designing and building for every one of those moments, not just the clean one that makes it into the mockup.

This is the habit I lean on the most now. Before I let an agent generate anything, I list out the states a component actually needs to handle. Loading, empty, error, success, partial data. AI can fill in each state fast once I know what they are. It cannot tell me which states matter for this specific feature. That part still starts in my head.

Writing things down so the next person does not guess

Documenting a component used to feel like an extra chore nobody had time for. It stopped feeling optional once I started working this way. If a component is going to get reused, picked up by an agent, or handed to a future collaborator, it needs a clear record of its variants, its props, and the states it supports. That documentation is what keeps an AI agent from inventing a prop that was never there, because the expected shape is written down somewhere real instead of guessed from context.

What agentic coding looks like in practice

A lot of the talk around AI agents stays abstract until you actually sit with one through a full build. On a normal build now, I describe a feature, let the agent draft the first pass, then spend most of my actual time on the parts that matter: checking the data flow, verifying the edge cases, making sure the component holds up when the network is slow or the response is empty.

  • I still decide the component structure before any prompt gets written.
  • I review every generated block of code the same way I would review any pull request.
  • I keep a mental list of the mistakes a model tends to repeat, so I know exactly where to look first.
  • I treat the agent as a fast pair, not as the one making the final call.

Reading code is a skill again

There was a period where writing code felt like the entire job. Now reading it carefully, fast, and with suspicion, matters just as much. A hallucinated prop or a fabricated API shape can look completely normal at a glance. Catching it requires the same muscle that used to only matter during code review, except now it runs constantly, every time an agent hands something back.

  • Check every prop and type against what the component actually exports, not what sounds reasonable.
  • Trace where a piece of state actually lives before trusting that it updates the way the generated code implies.
  • Run it. A hallucination almost always breaks the moment real data touches it.
  • Compare it against a component you already know well. Unfamiliar patterns are where mistakes hide.

A quick note on vibe coding

Bryl Lim, one of the speakers at UX+AI 2026, showed the room a post from Vercel about vibe coding, and it put a name to something I had been circling around the whole time. Vercel builds entire tools, like v0, around this idea of going from a natural language prompt straight to a working app. The term itself traces back to Andrej Karpathy, who described it as fully giving in to the vibes, embracing exponentials, and forgetting that the code even exists. It is a real and useful way to move fast when the stakes are low.

But for me, the deeper meaning is a warning, not a shortcut. Do not rely on AI so much that you skip learning the fundamentals. The basics feel boring now because a tool can do them for you in seconds. That is exactly why they matter more, not less. If you never sit with the fundamentals, you will not know when the vibes are wrong, and you will have no way to catch it.

The part I keep repeating to myself

Here is the lesson I brought home from that conference, and the one I keep repeating to myself every time I open a new AI tool to build something.

AI can help you move faster. It cannot think for you.

Most AI agents now ship with some version of thinking built in. It is easy to lean on that and mistake it for your own thinking. But the model does not know your idea. It has never lived inside your head. The idea you are trying to build exists only in your imagination, and no amount of prompting replaces the act of actually working it out yourself.

Somewhere along the way, a lot of us stopped using our imagination the way we did as kids, when we built entire worlds out of nothing because nobody told us it was impossible yet. Getting that back matters more now, not less. The tools got faster. The thinking still has to be yours.

What I'm carrying forward

I keep coming back to a simple way of putting it. AI changed how fast I can build. It did not change what I need to bring to the table before I open the first prompt: the idea, the judgment, the taste to know what belongs and what does not.

That part is still mine, and after everything I heard at UX+AI 2026, I plan to keep it that way.