Design Leaders Are Going Back to Making Things Themselves
For most of my career, the message to any designer who wanted to advance was the same: stop making things. Learn to manage the people who make things. Own the roadmap, not the Figma file. Craft was for juniors; leadership meant distance from the pixels.
That direction just reversed, and it's not a nostalgia trend. Zalando Design's 2026 industry shortlist — a report tracking where design practice is actually heading, not where conference talks say it should — names it directly: design leaders are expected to be hands-on again, and craft is regaining value at exactly the level of seniority that used to abandon it. The reasoning isn't sentimental. It's structural. AI has made interface production cheap and fast enough that anyone can generate a competent-looking screen in seconds. What AI cannot generate is judgment about which of ten competent-looking screens is actually right for this product, this user, this moment. That judgment lives in people who still practice the craft, and it atrophies fast in people who don't.
The delegation model of design leadership was built for a world where craft was scarce and management bandwidth was the bottleneck. We're now in a world where craft is the bottleneck and generation is nearly free. The org chart hasn't caught up.
You can't evaluate taste you've stopped exercising
Here's the mechanism, and it's not unique to design — any craft-based leadership role degrades the same way. A design director who spent three years exclusively in roadmap reviews and stakeholder alignment loses the specific, physical fluency of knowing why one spacing value feels calmer than another, why one microcopy choice reads as confident and another reads as apologetic. That fluency isn't conceptual. It's built through repetition, the same way a chef's palate is built through actually cooking, not through reading menus.
When that fluency erodes, evaluation becomes proxy-based: does this match the design system, did it pass the review checklist, does the stakeholder like it. Those proxies work fine when the volume of design decisions is low and every decision gets real scrutiny. They collapse the moment AI tools 10x the volume of design output flowing through the pipeline — which is exactly what's happening right now. A leader evaluating by proxy in a 10x-volume environment isn't leading design. They're rubber-stamping pattern-matches, and everyone on the team can tell.
I watched this happen to a director I worked adjacent to two years ago — sharp person, good instincts once, three years deep into pure management by the time AI tooling hit her team's workflow. She couldn't tell which of the AI-generated variants her team was shipping were actually good anymore. Not because she'd lost taste entirely, but because taste needs maintenance, and management doesn't maintain it. She started deferring to whichever variant the loudest stakeholder liked. That's not a leadership failure of character. It's what happens to any skill you stop practicing for three years.
The developer-built design system is the warning shot
This isn't hypothetical industry anxiety — there's already a concrete case study for what happens when a discipline stops showing up to do its own hands-on work. The most consequential design system of the last two years didn't come from a design team at all — it came from developers, built in code repositories most designers never opened, adopted at scale before design leadership noticed it had become the de facto standard. That didn't happen because developers are better at design. It happened because design authority sat in a place — Figma files, design leadership meetings — disconnected from where the actual components were being decided and shipped. Authority follows whoever is closest to the working artifact. For a while, that wasn't designers.
Hands-on design leadership is the correction to exactly that failure mode. A director still writing CSS, still prototyping in code, still in the repository where components actually live, doesn't lose authority to whoever happens to be closest to the artifact — because they're still one of the people closest to the artifact.
What "hands-on" actually means at that level
This doesn't mean design directors doing individual-contributor ticket work full time — that's a different failure mode, and a fast way to become a bottleneck instead of a multiplier. What the successful version looks like, from what I've seen work: leaders who still ship — a real flow, a real prototype, a real piece of the system — often enough that their evaluative judgment stays current, paired with genuine delegation of everything that doesn't require that specific judgment. The split isn't 50/50. It's more like: 80% enabling the team, 20% hands-in-the-work, and that 20% is non-negotiable because it's the only thing keeping the other 80% honest.
The tell for whether a design leader still has it: can they open a Figma file or a codebase cold and immediately spot the thing that's subtly wrong, or do they need someone to walk them through why it doesn't work? The second answer isn't a character flaw. It's a maintenance failure, and it's fixable — but only by doing the thing again, not by managing the thing better.
The scarce resource just changed, and the org chart hasn't caught up
AI didn't make design leadership less important. It changed what the job actually is. When production was expensive, the scarce resource was output, and management's job was allocating scarce production capacity across priorities. When production is nearly free, the scarce resource is judgment, and judgment can only be led by someone who still has current, practiced judgment of their own.
Most design orgs are still promoting people away from the thing that made them valuable. The ones that figure out how to keep their best judgment-holders practicing their judgment — even at senior levels, even when it looks inefficient on a calendar — are going to out-execute the ones that don't. Not eventually. Already.
What does your own design leadership actually still make?