Contact usHire us
AI product design
20 November 20268 min read

What is design engineering? About our approach at Habitat

By Victor Samokhvalov, Founder & Design Director

Summarize:

What if building the interface was part of designing it?

Designers could explore ideas in code and refine the UI as it takes shape, all with fewer rounds of back-and-forth between design and development.

That's design engineering in a nutshell. We've been exploring this approach at Habitat for the past few years, and it's changed how we deliver projects. I thought I'd share what we've learned along the way and how we made it work.

First off, what is design engineering?

Design engineering is bringing implementation into the design process. Instead of designing first and building later, you do both in the same loop, exploring and refining the interface as you go:

Two-way arrows connect designing and engineering, showing how questions about what to build and how it should work inform each other.
Design engineering as one loop

The work can start in Figma or directly in code, and you can move between the two. In this setup, code becomes another design medium: a place to test interactions, validate ideas, or discover edge cases that are hard to anticipate in a static design. And that changes a few things.

What does design engineering make possible?

To me, it comes down to three things:

  • More informed design decisions. Teams can catch usability issues and technical constraints earlier, while there's still room to rethink the design.
  • Faster feedback and iteration. Teams can try out ideas in a working interface and make changes with fewer rounds of back-and-forth between design and development.
  • Less design intent lost along the way. When design and implementation happen together, there's less room for important interactions and details to get lost in translation.

I like how Natalya Shelburne, co-author of Design Engineering Handbook, highlights it:

“From prototyping to production-ready code, this function [design engineering] fast-tracks design decisions, mitigates risk, and establishes UI code quality.”
Natalya Shelburne, Product Design Manager, Design Systems Lead
A note on terminology: Design engineer is also a job title (and an increasingly popular one). The skills and responsibilities associated with the role vary across companies. A quick note on terms. “Design engineer” is also a job title, and you see it more and more often. What the role means changes from company to company. Here we don’t look at the role.

Why is design engineering getting so much attention now?

Design engineering has been around for years. But I don't remember seeing this much interest in the role before. Look up design engineer job openings, and you'll find software teams like Linear, Vercel, Replit, and Perplexity actively hiring for it.

My guess is that AI design-to-code tools played a big part. They've made it easier for more designers to experiment with implementation and discover the possibilities of working across design and code.

With all this attention around design engineering, you might be wondering what it looks like inside a team. The short answer? There's no universal playbook.

Get the week’s best stories

What does design engineering look like inside a team?

I was reading about how other companies approach it and came across an interesting example from Alan, a French health insurance company. They experimented with giving designers a more direct role in implementation. Now, their designers can contribute directly to the product's codebase. Each designer has a dedicated engineer they can turn to for help. The designers implement UI changes themselves, while engineers review their work and handle the merges.

So while some companies hire dedicated design engineers, some help their existing designers take on implementation work. I think it illustrates a point Natalya Shelburne makes about design engineering: the goal isn't to ask designers to learn an entirely new profession, but to make it easier for them to contribute to implementation.

At Habitat, we've been figuring out how to do that within our own team, too. Here's how we got there.

How design engineering became part of Habitat’s delivery process

A little backstory. A few years into running Habitat, we started working on more AI products. First came Hennii, an online banking service built around a conversational AI assistant. Then Lucend, Bagel AI, and Feeds. As we took on more projects like these, we began to see the limits of our usual design process.

We'd finish the designs in Figma, hand them off to developers, and they'd build the interface. Sounds straightforward, right? But even a detailed Figma file left room for interpretation. A designer could document every state of a component (hover, loading, disabled, you name it), but a developer still had to recreate how it behaved in code. Details could get lost along the way. And sometimes we'd discover a technical constraint only after the design was finished, which meant going back to Figma, reworking the design, and handing it over again.

Vitalii, one of our front-end engineers, compared the old process to passing goods back and forth at a market, and I think that's a pretty good description of what we were doing. That said, we wanted less of that back-and-forth and a faster way to get working interfaces into our clients' hands.

Design engineering gave us a way to do that. Instead of treating design and implementation as separate stages, we started bringing them together.

Before: design passes to development. Now: design and building inform each other, with engineering input throughout.
Before and after design engineering at Habitat

Today, design engineering is a key part of Blueprint-to-Deploy, our delivery approach where we ship a working interface in 6–12 weeks. Our design engineers explore, build, and refine interfaces, moving between design tools and code as needed. They work closely with front-end engineers, who help shape the technical approach, work through complex problems, and make sure the code fits each client's technical setup.

More on this next.

Making design engineering a team practice

We had a head start in one area: design systems. Our designers had been working with reusable components for years, and as we took on more AI products, we developed the Habitat Design System for agentic software. It’s a Figma kit and a React component library that match token for token. Both use the same configuration file to stay in sync, so when our designers started working in code, they already had familiar building blocks to work with.

But there was more to do, and both designers and front-end engineers had to contribute:

  • Designers expanded their work into engineering. This is how our designers began growing into the design engineering role. Nazar was one of the first to explore it. He started learning front-end frameworks, building interfaces himself, and gradually helping other designers do the same. “Learning to code was tricky,” Nazar says, “but it helped us see where things get lost between design and development, and what we could do about it.”
  • Front-end engineers provided technical foundation and guidance. As our designers began taking responsibility for UI implementation, we needed to make sure their code could meet the technical requirements of client projects. Taras, our front-end engineer, helped develop an engineering starter for every project, with a predefined code structure and quality checks.
A shared starting point for Habitat’s design engineers combines reusable design system components with project structure, architecture, and quality checks.
A shared starting point for Habitat’s design engineers

It took some learning on both sides, and we're still figuring some things out as we go. But as more of our designers grow into design engineering roles, we’re already feeling big changes in how the team works. Nazar summed it up better than I could:

“Both teams stop being held hostage by the process. Designers experiment in code and test ideas in a working product, while engineers contribute as those ideas take shape. We solve problems together and move from idea to delivery at a speed that was unthinkable in 2020.”
Nazariy Mynzak, Lead Design Engineer, Product Designer

More on what that collaboration looks like on client projects next.

How the work happens now

Our design engineers move between Figma and code as the project requires. They use tools like VS Code, Cursor, Codex, and Claude Code to explore ideas, build interfaces, and refine the design as they go. Sometimes they'll start with a rough version in code to see whether an idea works, then use what they learn to develop it further.

See also: Habitat’s tested and proven picks of design-to-code tools

The interfaces they build also need to work within each client's technical setup, whether that's an existing architecture, a particular framework, or strict security requirements. So our design engineers work closely with front-end engineers on questions about integrations, authentication, and more complex frontend logic.

On some projects, that collaboration happens directly in the codebase: design engineers commit their own UI changes, front-end engineers review the code at relevant stages, and automated checks help catch issues along the way.

Iterative design engineering workflow: explore ideas in Figma or code, build and test working UI, then refine the design with engineering input throughout.
Iterative design engineering workflow at Habitat

How closely our design engineers and front-end engineers work together depends on the project. Some need little more than code reviews, while others call for engineers to get involved earlier to work through complex technical decisions. We expect the balance of that collaboration to evolve over time. Taras, for one, already has an idea of how his role might change:

“As our design engineers gain more experience with implementation, I see front-end engineers spending less time mentoring and more time working through complex technical decisions and reviewing code.”
Taras Humeniuk, Front-end Developer, Team Lead

Now, what does this new process bring our clients?

What changes for our clients

Better show than tell. Take Lucend, a team building AI software for data centers.

Lucend’s engineers had a product to build, and the last thing they needed was to spend weeks translating our Figma designs into working UI. But for security reasons, we couldn't work directly in their codebase either.

Nazar built the interface in a separate project and shared a working version that Lucend's engineers could click through. Even small interactions were there, like a warning when someone tried to leave a page with specific conditions logic applied. He also shared the code in a GitHub repository. Of course, Lucend’s engineers still had to adapt that code to their own architecture, and they'd estimated about two weeks for that work. It took them two days.

What do teams get from design engineering? That depends. At Habitat, the deliverable may be a working prototype, frontend ready for integration, or an implementation that needs further engineering. We agree on the scope and level of technical readiness with each client. In any case, design and front-end engineers have already shaped the output together, so fewer decisions need to be reconstructed after a handoff.

To sum it up: What design engineering looks like at Habitat

At Habitat, design engineering means bringing design and implementation into the same process. Our design engineers explore ideas in Figma or code, build and test working interfaces, and refine the UX/UI as they go.

They work closely with front-end engineers throughout this process:

  • Design engineers take responsibility for the UX/UI and its implementation.
  • Front-end engineers guide them through complex decisions and make sure the code meets each project's technical requirements.
Habitat’s design engineering process, from technical setup through repeated cycles of UI exploration, building, and review to final technical review and delivery.
Habitat's design engineering process in a nutshell

Now, do you need design engineering?

If your designers and developers spend a lot of time passing work back and forth, it's worth thinking about how you could bring implementation closer to design.

And no, I don't think you necessarily need to hire someone with ‘design engineer’ in their job title. You can start with the team you already have. Maybe your designers could build interactive prototypes in code. Maybe they could fix small UI issues themselves, with an engineer reviewing the changes. Or maybe you'd rather bring in a design engineering partner to help you get a working interface into your team's hands. I might know someone. ;)

Whatever approach you choose, the goal is the same: less back-and-forth, more room to refine the design as you build, and a shorter path to a working interface.

A free product audit by real designers

We’ll review your product and share 3–4 specific improvements within 48 hours.

Please insert a URL to your product or Figma file and your email below

What to read next