Tried explaining 90s web design to a younger developer last week.
"You hand-coded everything?"
"You couldn't see changes without uploading files?"
"How did anything get done?"
Slowly, I told them. With more planning. Because mistakes took time to fix.
Then they asked me to help troubleshoot a responsive design issue. The visual editor was generating unexpected breakpoints. They'd been clicking through menus for twenty minutes, trying different options, hoping something would work.
I opened the code inspector, spotted the problem in ten seconds. A conflicting media query the editor had generated. Fixed it in thirty seconds.
They asked how I knew where to look. Because I used to write every media query by hand. I know what they do, how they conflict, what the editor is actually generating behind the interface.
That's the difference. They use the tool. I can understand it.
What understanding the manual version gives you
Last month a client's component library broke after an update. Their developer couldn't figure out why buttons suddenly looked different across the site. They'd updated the master component but individual instances weren't changing.
I've built component systems manually before libraries existed. I know how inheritance works, how overrides propagate, where specificity conflicts happen. Found the issue in minutes - a local override blocking the global update.
The developer had only ever used the library interface. When it didn't behave as expected, they had no framework for troubleshooting. They knew which buttons to click, not what those buttons actually did.
This happens constantly now. People use powerful tools at surface level. When tools work as expected, fine. When they don't, they're stuck.
Understanding what tools do underneath the interface - because you've done it manually - changes how you use them. You troubleshoot faster. You catch problems others miss. You know when the tool is helping and when it's making decisions you should be making yourself.
AI responses that sound plausible but miss the point? Obvious when you understand how language models work. Visual editors generating bloated code? Visible when you've written clean code by hand. Automated exports producing wrong formats? Clear when you understand compression and codecs.
It's not about being able to do things the old way. It's about understanding principles well enough to use automation effectively.
How this speeds up adaptation
When Figma introduced auto-layout, some designers adopted it immediately. Others avoided it for months, intimidated by the learning curve.
The designers who adopted quickly? Usually the ones who'd worked with CSS flexbox or grid systems before. They recognised the pattern. Same principles, different interface. They already understood the underlying concept of flexible layouts - just needed to learn where Figma put the controls.
Designers who'd only ever used fixed positioning struggled more. They were learning the concept and the interface simultaneously.
This pattern repeats with every tool evolution. People who understand principles adapt faster than people who only know interfaces.
I watched this happen with responsive design. Designers who understood fluid layouts and proportion adapted quickly. Designers who'd only ever designed fixed-width pages struggled for years.
Happened again with component systems. Developers who understood object-oriented principles built effective systems immediately. Developers who'd only written procedural code treated components like complicated templates.
Happening now with AI. People who understand how these models work, what they're actually doing, adapt faster than people treating them like magic boxes.
The advantage isn't the old knowledge itself. It's the pattern recognition. You've adapted before, so you recognise the adaptation process. New tool, familiar pattern.
Why some designers struggle while others thrive
Two designers using the same tools can produce dramatically different work. Not because one is more talented. Because one understands what the tools are doing.
Designer A uses AI to generate image variations. Accepts whatever outputs appear. Assumes that's the best the tool can do.
Designer B understands how diffusion models work. Writes better prompts because they understand what the model responds to. Iterates because they know first outputs are starting points. Recognises when results need human refinement.
Same tool. Completely different capability.
This isn't about clinging to old methods or dismissing new tools. It's about understanding that tools amplify capability - but only if you understand what they're amplifying.
Someone who learned design only through templates struggles when projects need custom solutions. Someone who learned to code only through visual editors struggles when the editor produces wrong output. Someone who only uses AI at surface level struggles when nuanced work requires refinement.
Understanding fundamentals doesn't slow you down. It makes you faster because you're not guessing. You know what works and why.
What's coming next
AI is transforming work now. Visual programming will transform it next. Then something we haven't imagined yet.
Each evolution follows the same pattern. What required specialists becomes accessible. What took hours takes minutes. New capabilities emerge that were impossible before.
The people who thrive through these changes aren't the ones clinging to old methods. They're the ones who understand principles well enough to recognise them in new interfaces.
Code editors became visual. The principles of clean code stayed the same. Designers who understood those principles adapted quickly. Design tools became collaborative. The principles of effective feedback stayed the same. Teams who understood those principles adapted quickly. AI handles repetitive tasks now. The principles of when to automate and when to apply judgement stay the same. People who understand those principles are adapting quickly.
Ten years from now, today's cutting-edge tools will seem primitive. We'll look back at current workflows the way we look at hand-coding HTML - with appreciation for how much has improved, not nostalgia for old methods.
The craft stays constant. Understanding users. Solving problems. Creating experiences that work. Tools keep evolving to help us do that better.
Understanding where tools came from - what problems they solve, what used to be hard - makes you better at using what exists now and faster at adapting to what comes next.