From designer to engineer

Throughout creative history, ideation and production were never completely separated. Not because they were always done by the same person, but because the medium imposed limits that forced one to think with it. A graphic designer knew what could be printed. An architect knew what could stand. The format was not neutral: it conditioned the process.

For some reason, in interface design, this bond that seemed inseparable was broken (or at least, until very recently).

To simplify the task, the designers who created the software we use every day made decisions to abstract complex concepts. States, flows, and behaviors difficult to represent were translated into limited options, panels, frames, and reusable components. This fixed certain limits on how we think about the digital.

These tools help us design; they also define what kind of interfaces we are capable of imagining. Their format, mostly static, forces us to think in isolated screens, even though we know that real products work dynamically.

That's where a boundary appears.

It is impossible for an engineer to replicate 100% the idea a designer has. Our task relies on showing concrete steps: views, flows, "happy" paths. But a large part of the experience happens in between, when things go wrong, or when things could go better.

Those spaces are rarely defined and, when they aren't, someone has to make decisions (probably an engineer, in a rush and with way too much work to do).

Blurring the Boundary

In this scenario, more and more designers are getting into code. Products like Linear or Vercel have been characterized in recent years by new but powerful teams of design engineers, differentiating themselves considerably from their competition by being pioneers in creating products that not only work well but feel good.

With entry barriers lower than ever, thanks to tools like Cursor, code stops being an exclusive territory and becomes part of the creative process.

When the designer can interact directly with the system, many assumptions become explicit. Limits stop being theoretical. Decisions no longer live only in the head or in the file, but in something that can be executed, broken, and adjusted.

In this context, design and engineering stop being separate stages and begin to merge into the same workspace.

Code seeks to bring design closer to the medium where it truly exists: the web.