You've seen the portfolio. Type that breathes. So smart hierarchy. That said, clean lines. But then you watch the designer work — and it's all shortcuts, messy layers, naming conventions that would make a developer cry.
Flip side: you meet a technician. On the flip side, immaculate file structure. Components that scale like a dream. Soulless. But the work? Derivative. Pixel-perfect exports. It solves the brief but misses the point.
Here's the thing most people miss: design and technique aren't the same skill. They're not even the same kind of skill. And confusing them is why so many portfolios look impressive but fall apart in production — or why so many production-ready files feel like they were made by a robot with a template addiction And that's really what it comes down to..
What Is Design (and What Is Technique)
Design is decision-making. It's the why behind every visual choice. Why this typeface at this size? Why this much white space? Why does the button live here instead of there? In real terms, design lives in the realm of intent, hierarchy, narrative, and user psychology. It's the argument you make without words And that's really what it comes down to. Worth knowing..
Technique is execution. Even so, it's the how. It's knowing which tool does what, which shortcut saves forty minutes, how to set up a component library that won't collapse when the product team adds twelve new states. Technique lives in the realm of craft, workflow, file hygiene, and technical constraints And that's really what it comes down to..
They require different brains
Design thinking is divergent. Exploratory. On the flip side, messy. Even so, you're asking "what if? In real terms, " and "why not? " and "does this feel right?" You're sketching bad ideas on purpose because the path to the good one runs through the bad ones Less friction, more output..
Technique is convergent. Precise. Systematic. You're asking "how do I build this so it doesn't break?" and "what's the most maintainable way to structure this?" You're applying rules, not breaking them.
The best designers I know are terrible at file organization. That said, the best technicians I know struggle to articulate why a layout works. That's not a failure — it's specialization.
Why This Distinction Actually Matters
Because hiring managers conflate them constantly.
Job postings ask for "strong design skills" and list Figma auto-layout mastery as a requirement. On top of that, that's like hiring a chef and requiring they also manufacture their own knives. Related? Here's the thing — sure. Day to day, same job? Not even close.
The portfolio trap
Junior designers obsess over technique because it's visible and measurable. You can see clean layers. That said, you can count components. You can screenshot a perfectly organized file and feel accomplished.
But a beautiful file full of bad decisions is just organized garbage. I've seen portfolios with immaculate structure — consistent naming, proper constraints, zero missing fonts — where every screen felt like a slightly worse version of a Dribbble trend from 2019.
People argue about this. Here's where I land on it Most people skip this — try not to..
Meanwhile, the designer with messy files but sharp instincts? Practically speaking, their work works. It communicates. It converts. It feels inevitable. You forgive the layer named "Rectangle 4 copy 3" because the thinking behind it is undeniable Worth keeping that in mind..
The production trap
Senior technicians sometimes forget that technique serves design — not the other way around. They build component systems so rigid they prevent the very exploration that leads to better solutions. "We can't do that, it breaks the grid" becomes a design constraint imposed by the tooling.
That's backwards. The tool should bend to the idea. When the idea bends to the tool, you get design by default — which is just template selection with extra steps Worth keeping that in mind..
How They Work Together (and Where They Clash)
The magic happens in the handoff. Not the designer-to-developer handoff — the internal handoff, from your designer brain to your technician brain.
The loop
Real work doesn't flow one direction. It loops:
- Design impulse — "What if the navigation lived in the content area instead of the chrome?"
- Technique check — "Can our component system support that? What breaks?"
- Design adjustment — "Okay, but the principle matters. How do we keep the intent while working within — or extending — the system?"
- Technique evolution — "Right. We need a new component variant. Here's how to build it cleanly."
- Back to design — "Now that it exists, what else becomes possible?"
This loop is where seniority lives. So juniors treat it as a waterfall: design then build. Seniors know it's a conversation.
Where it goes wrong
Design ignoring technique: You craft a beautiful interaction that requires 47 custom variants. The developer quotes three sprints. The product manager cuts it. You're mad — but you designed something unbuildable within constraints you knew existed.
Technique ignoring design: You refuse a design request because "it's not in the system." You don't ask why the designer wants it. You don't explore whether the system should grow. You just protect the architecture. The product ships with a compromised experience because the tooling won.
The fake bridge: "Design systems" that are really just component libraries with good documentation. They solve technique. They don't solve design. A design system without design principles — without opinionated guidance on when and why to use each pattern — is just a sticker sheet.
Common Mistakes / What Most People Get Wrong
Mistake 1: Thinking "good taste" is design
Taste is recognition. Design is argument.
You can have impeccable taste — know exactly what looks good, spot a misaligned baseline from across the room, curate a beautiful moodboard — and still be a weak designer. Because design isn't about recognizing quality. It's about producing it under constraints, for a specific audience, to achieve a measurable outcome.
Taste is passive. Design is active.
Mistake 2: Thinking tool mastery is technique
Knowing every Figma shortcut doesn't make you a strong technician. It makes you fast at one tool Easy to understand, harder to ignore..
Real technique is transferable. It's understanding:
- How design tokens map to CSS custom properties
- Why naming conventions matter for developer handoff
- How component architecture scales (or doesn't)
- When to use auto-layout vs. absolute positioning vs.
Shortcuts save minutes. Architecture saves weeks Easy to understand, harder to ignore..
Mistake 3: Believing you're "just not a technical designer"
"I'm more of a visual designer" is the most career-limiting sentence in this industry.
You don't need to write production code. And a print designer who doesn't understand bleed, trapping, and color separation isn't "conceptual" — they're unprepared. You do need to understand the medium you're designing for. A digital designer who doesn't understand the box model, stacking contexts, and responsive behavior isn't "ideation-focused" — they're guessing Simple as that..
Technique isn't optional. It's the difference between a sketch and a specification.
Mistake 4: Believing you're "just not a creative technician"
"I just build what's in the spec" is the other career-limiting sentence.
If you only execute, you're replaceable — by AI, by offshore teams, by the next tool that automates your workflow. " "Have you considered this edge case?The technicians who survive are the ones who push back: "This pattern won't scale. Here's a better approach." "The design asks for X but the user needs Y — can we align them?
That's not "doing design work."
