Designers are becoming design builders

By Imran Sheikh · 2026-11-12 · Design builders · 4 min read

Key points

  • A design builder ships working software, not just mockups.
  • AI coding agents removed the biggest wall between design and code.
  • The running product becomes the design file.

A design builder is a designer who ships working software. They open the repo, change the code, run the app and send the pull request. The mockup stops being the end of the job. The running product takes its place.

I have worked in product design for 15 years, and led teams for eight of them. For most of that time the handoff was the center of the craft. We made files, wrote specs and hoped the build would match. It rarely did. AI coding agents changed that, because a designer can now do the build step too.

Why the handoff always leaked

A design file describes a product. It does not behave like one. It has no loading time, no slow network, no long names, no keyboard focus and no second language. Every one of those gaps was filled by an engineer making a guess. Some guesses were good. Many were not, and nobody noticed until the feature was live.

Designers knew this. We wrote longer specs and ran more review sessions. We built prototypes that looked real and acted fake. All of it was a patch over the same problem. The person who knew how the thing should feel could not touch the thing itself.

What the agents changed

Coding agents read a codebase, propose a change and run the tests. They write the boring parts well. They are slow to forget a convention once you show it to them. A designer who can describe what they want in plain language and judge the result can now get a real change into a real branch in an afternoon.

Engineers stay on the team. The queue goes away. A designer no longer files a ticket for a four pixel spacing fix and waits two sprints. They make the fix, and an engineer reviews it like any other change. The engineer spends review time on logic and risk, and no time on padding.

The title sounds grand. The work is plain. A design builder takes a problem, shapes a solution and builds enough of it to test it on a device. Then they refine it in code until it is ready to ship.

  • Works in the real repo with the real components, so the design system is the one that ships.
  • Builds the interaction first, because motion and state are where taste shows up.
  • Tests on a phone or a real browser, never only in a canvas.
  • Writes the copy, the empty states and the error messages in place.
  • Opens small pull requests that an engineer can review in minutes.

At Emerge Labs we work this way with every client. We design in the client’s codebase, so what we design is what ships. I still design in the repo myself. It is the fastest way I know to find out whether an idea is any good.

What does not change

The hard questions stay hard. Who is this for. What are they trying to do. What can we leave out. An agent can produce ten versions of a screen before lunch. It cannot tell you which version respects the person using it. That judgment is the job, and it always was.

Research, systems thinking, writing, accessibility and care for the edge cases all matter more once building gets cheap. When output is easy, the choices become the scarce thing. A team that ships ten mediocre screens a day is worse off than a team that ships one good one.

When building gets cheap, deciding gets expensive.

The risks are real

A designer with an agent can also break things faster. They can ship code they do not understand. They can add a dependency nobody asked for. They can skip the test because the screen looks right. Banning the practice would waste the gain. Habits around it keep the gain and cut the risk.

  • Read every diff before you open a pull request.
  • Keep changes small and scoped to one idea.
  • Ask an engineer to review anything near data, auth or payments.
  • Run the app after each change and look at it.

These habits are not new. Good engineers already follow them. Designers who take on the build step should borrow them in full.

Why this matters for products

We make our own iPhone apps and games at the studio. Emerge Care, Neon Heist, Cat Nap Blocks and Five Skies all get designed in code. In a game, feel is the product. You cannot judge a block landing or a getaway turn from a static frame. You have to play it, change it and play it again. The same is true of a prayer time screen under a changing sky or a health companion that has to answer gently.

Most software has the same truth hiding inside it. A form feels slow or it does not. A transition makes sense or it confuses. The only way to tune those things is to build them and use them. Design builders close the distance between the idea and the evidence.

Where to start

Pick one small, real thing in a product you already know. A button state. A settings screen. An empty list. Ask an agent to help you change it in the actual codebase. Read what it did. Run it. Then ask an engineer to review it.

Do that ten times and the fear fades. You start to see the code as another material, like type or color. It has grain and limits. You learn where it bends. That is the moment a designer becomes a design builder, and from there the practice grows on its own.

Journal · Book a call · Home