Working with designers

Open original

An engineer explains why he loves working with designers but thinks having more than one on a team causes constant conflict, and why design systems, despite being the best option he knows, create friction for engineering teams. He also questions whether many products need designers at all.

  • Designers show their value immediately: a placeholder UI gets replaced by a mockup that is better in ways the engineer couldn't have imagined.
  • Multiple designers on one project tend to clash because their disagreements rest on taste rather than measurable criteria like latency or bugs, and because users see the product as one design, so every change ripples through.
  • Design systems are still the best way the author knows to keep UI consistent, but they create tension between product teams with odd requirements and design teams protecting the look, plus compatibility problems with older frontend code.
  • Many teams, like those building APIs or billing systems, don't benefit from designers, and plenty of products succeed despite poor design.

Sean Goedecke, an engineer, argues that designers are a great addition to a team but that having more than one is asking for trouble. He says designers prove their value at a glance: he builds placeholder UI, a designer glances at it, and returns with something clearly better in ways he couldn't have imagined. He also says designers are culturally distant from engineers, who tend to be "people of the spreadsheet," and he sees that distance as a plus. Engineers and product managers who try to make their own technical judgments about engineering work often erode the trust their teams need, while designers largely avoid that trap. The core complaint is about multiple designers. Goedecke compares them to the Slavic Domovoy household spirit: one protects the home, but several fight bitterly. His worst project had three designers, first one, then two senior replacements who immediately redesigned the product, forcing him to rewrite most of the frontend styles. They then disagreed with each other, sending each page back and forth three or four times while he struggled to get the product working. Bringing everyone into a room didn't help, because the differences in taste were too deep. The team eventually pushed through by implementing each iteration, and two layers of management froze the design about a week before the deadline. He stresses these were talented, pleasant people. His two theories for the pattern: engineering arguments can be settled with measurable things like latency and bug counts, while design arguments rest only on taste, and design changes ripple across the whole product because users see it as one unit, whereas engineering internals can vary invisibly. On design systems, Goedecke says he hates them but still thinks they beat the alternatives for keeping UI consistent across large applications. The problems are incentives and compatibility. The team that owns the system wants elegant, always-beautiful components, while product teams need ugly but necessary features like arbitrary images in a dropdown, so the two are in constant conflict. Embedded designers who push slight variations make this worse, and engineers end up reimplementing components or overriding CSS that breaks on every update. Compatibility is the other headache: design systems are built in modern frameworks like React, while many production frontends still run on pure HTML and CSS or older React versions, so the version a designer mocks up often differs from what engineers can actually build. Goedecke's wish is simple: that designers appreciate how much harder a design system makes day-to-day implementation.

Ask about this article