How to hire and structure around design builders
By Imran Sheikh · 2026-11-12 · Design builders · 4 min read
Key points
- Hire for judgment and curiosity, then check how they build.
- Give design builders real repo access and clear review rules.
- Keep human designers on research, systems and hard ambiguity.
Teams hear about design builders and ask two questions. How do we hire one, and how do we organize around them. The answers are simpler than they sound. They also require a few honest changes to how design and engineering share work.
I led design teams for eight years and now run a small studio that works inside client codebases. What follows is my current view. It will keep changing as the tools do.
What to look for when hiring
Start with the same things you always wanted from a designer. Clear thinking about problems. Strong craft. Good writing. Care for the person on the other end. A design builder who lacks these will ship bad work faster.
Then look for the builder traits. Curiosity about how things work. Comfort with a command line. A habit of trying something before asking for permission. Willingness to be reviewed.
- Ask for a working project, not only a case study deck.
- Have them walk through a real pull request and explain each choice.
- Give them a small change in a sample repo and watch how they work with an agent.
- Ask what they did when the agent was wrong.
- Listen for how they talk about engineers. Respect is the right signal.
The last two matter most. A good design builder knows when to doubt the tool. They can describe a time they caught a bad suggestion and what they did next. That story tells you more than any portfolio.
Where design builders sit
Put them inside the product team that owns the thing they are building. They need the context, the backlog and the people. A design builder in a separate design group, filing requests into engineering, is a designer with a slower workflow.
Keep a light design community on the side. Designers still need critique, shared standards and a place to grow their craft. A weekly review where people show builds works well. It keeps taste consistent across teams.
Think about growth paths too. A design builder should be able to grow toward deeper craft, toward technical leadership or toward leading a team. Write those paths down. People stay where they can see a future, and this role is new enough that nobody can see it unless you draw it.
Set the rules of the road
Speed needs guardrails. Agree on them early, in writing. This protects the product and gives designers confidence to move.
- Every change goes through a pull request and a review.
- Designers own the interface layer. Engineers own data, auth, payments and infrastructure.
- Automated checks run on every branch, including tests, type checks and lint.
- Small changes ship often. Large changes get a plan first.
- A shared notes file records conventions for people and agents alike.
The ownership line matters. Interface changes carry low risk when they are scoped and reviewed. Changes near money or private data carry high risk. Draw the line where the risk changes, and tell everyone where it is.
Change how engineers and designers review
Review is the new handoff. It runs both ways. Engineers review the code. Designers review the behavior. Both look at the running build together.
Ask engineers to give design builders honest, specific comments, as they would for any colleague. Ask design builders to respond quickly and to learn from each note. Both sides get better at the other’s craft. Over months the gap closes.
Plan for the first month to feel slower. Reviews take time while people learn each other’s habits. Engineers will find small mistakes. Designers will find assumptions in the code that nobody wrote down. Treat both as useful. Each one is a lesson that the whole team keeps.
What still needs a human designer
Design builders sit beside designers on the team. Their arrival changes what a designer’s time is for. Some work stays firmly human, and it is the work that matters most.
- Discovery and research with real people, including the awkward conversations.
- Defining the problem before anyone builds.
- Design systems and the principles behind them.
- Brand, tone and the feel of a whole product.
- Hard ambiguity, such as new categories and trust questions.
- Accessibility and ethics, where a human has to stand behind the choice.
An agent can follow a system. It does not author one with care for how the system will age. An agent can generate options. It cannot tell the team why one option is right for these users at this moment. Keep humans where the stakes and the ambiguity are highest.
A practical way to start
Do not reorganize everything. Pick one product team and one willing designer. Give them repo access, a review partner and a short list of interface work. Run it for a month and look at what shipped.
Watch for three signals. Did the quality of shipped screens rise. Did the review comments get shorter. Did engineers get time back for harder problems. If yes, add a second team. If not, find out why before scaling.
Give designers the keys, and give everyone a review process.
Be patient with the measuring. Output counts are a poor guide, because an agent can inflate them. Look at the product instead. Is it more coherent. Do users complain less about rough edges. Does the team trust its own releases. Those answers tell you whether the structure is working.
This is how we work with clients at Emerge Labs. We design in their codebase, with their engineers reviewing, so the result is the product itself. Teams that adopt the habit tend to find the same thing. The work gets more honest, because it has to run.