Why UX History Matters Now
UX design history doesn’t move in a straight line. It comes in waves, with each era fixing the headaches of the one before it and, in the process, creating a fresh blind spot. The phone era taught designers to think about hands, memory and error rates. The web era pushed structure and findability. Mobile forced ruthless prioritization. Design systems turned repeatable interface work into something closer to manufacturing. Now AI is changing the cost of producing screens, content and variation again, which means a lot of old habits are back on the table for review.
That’s why history in this field rhymes more than it repeats. The devices change. The teams change. The tools change. In a new outfit: What does the person need, the same basic questions keep showing up. What gets in the way? What should be left out? The answers don’t arrive fully formed from the latest tool. They usually arrive by remembering what used to break when the last toolset took over.
When production gets cheaper, the work rarely shrinks. It usually spreads.
That pattern has a name in economics: Jevons paradox. People don’t always use less of it, when a resource becomes easier and cheaper to use. They often use more. The logic shows up in software all the time. Faster computers didn’t lead to fewer applications. Better publishing tools didn’t lead to fewer websites. Cheap component libraries didn’t make product teams simpler. They made it possible to ship more, iterate more and pile up more variants. AI era UX may follow the same path. If generating a screen, a message, or a flow takes seconds instead of days, the temptation will be to produce a lot more of them.
That’s where the old standard still matters: design’s about how something works, not just how it looks. A polished interface that confuses people is still a bad interface. And a plain one that helps them finish the task’s better. This sounds obvious until a new tool makes decoration cheap and judgment expensive. Then the pressure is to fill every blank space, add every option and call it progress because the machine can spit it out before lunch.
So the job in this article’s pretty simple to state and harder to do well. Separate the habits that only made sense under older tools from the principles that still hold up. Some techniques will turn out to be tied to a specific era, a specific screen size, or a specific workflow. Others will survive almost anything. The next sections trace that split through the history of UX design, starting long before screens took over the job and made everyone forget that interfaces once lived in phones, buttons and systems first.
Before Screens: The Human Factors Roots
After the broad sweep of UX history, it helps to go back to a time when nobody said UX at all. The work still existed. It just lived in lab notes, phone prototypes and the patient little decisions that made machines tolerable for ordinary people.
At Bell Labs, John Karlin and his colleagues treated telephones as human problems first. They watched how people held a handset, how far a thumb could travel, what shapes could be read at a glance and what users could remember without squinting at a manual. That sounds obvious now, which is part of the point. It wasn’t obvious when much of technology assumed the person should adapt to the machine.
In those years, human factors design meant asking practical questions. Should a control be round or flat? Can a person operate it one-handed? In bad light, will the labels still make sense. Those questions seem small until you miss them. Then the error rate climbs, support calls pile up and the device earns a reputation for being fussy, which is a polite way of saying it didn’t respect the body using it.
Bell Labs’ keypad research in 1960 is a good example. Several layouts were compared, and the familiar three-by-three digit grid won because people could read it quickly and use it with less hesitation. The choice wasn’t about style. It was about speed, legibility, and the limited attention span of someone trying to place a call without thinking about the keypad itself. Even today, that grid still feels settled in the hand. You can almost forget it was ever a decision.
Good interface work often looks boring after the fact, because the arguments happened before the product reached your hands.
Some of those old choices have outlived their original devices. The three-line menu icon, now so common that it barely gets a second glance, first appeared on an early workstation in the early 1980s. Back then it was a tidy way to hide options without filling the screen. Decades later, the symbol keeps showing up in software that’s nothing in common with that workstation except a need to tuck away a mess of commands. It’s a tiny fossil, still doing a job.
The language around the field changed later than the work did. Brenda Laurel used the phrase “user experience” before it became a standard job title, which feels fitting, because she was already thinking beyond a single screen. Don Norman then pushed the idea further. The experience, in his framing, wasn’t just the interface in front of you. It included what the system made you feel, what you expected, what went wrong, and how the whole setup behaved when real people used it under real conditions. That broader view sounds simple now, but plenty of teams still slip back into screen-only thinking the moment deadlines get tight.
That’s the thread running through this era: design around the person and the whole system, not the machine alone. Buttons, labels, memory load, error recovery, physical reach, feedback and context all belong in the conversation. A good device can look unimpressive from a distance and still be a pleasure to use because the work underneath’s been done properly. Interesting. A bad one can be gorgeous and still make people mutter at it on the train.
This older lens also explains why later fields such as information architecture didn’t arrive out of nowhere. They took the same instinct, then pointed it at a different problem. Before screens became sprawling and pages multiplied, the discipline had already learned to ask how people see, remember, choose and recover. The web would give those questions a larger stage. And the questions themselves were already waiting backstage.
The Web Makes Structure the Product
Before the web got polished, it got crowded. Early sites often felt like filing cabinets with the drawers left open: press releases next to product pages, random FAQs tucked under “About,” contact details buried behind three clicks and a prayer. The problem wasn’t always visual taste. A lot of the time, the page looked fine. People just couldn’t find the thing they came for.
That changed the job. In the web era, the designer who only cared about colors and layout was missing half the job. Structure became the thing users felt first, even if they never named it that way. If a site had too many labels, the wrong labels, or a menu that made visitors guess, the interface might as well have been a maze with a nicer font. A page can be tidy and still make people work too hard.
A pretty interface still fails when the page map makes people guess.
This is where information architecture moved from niche discipline to daily practice. Card sorting helped teams see how real people grouped topics. Taxonomies gave large sites a way to sort pages without turning every section into a junk drawer. Navigation labels had to do actual work, which sounds obvious now, but at the time it meant arguing over single words that could send people either forward or nowhere. “Products” and “Solutions” aren’t the same, and visitors notice the difference faster than most meeting rooms do.
Usability heuristics joined that toolkit, too. If a label was vague, if the system kept people guessing, if the site hid the current location or made the back button feel like a life raft, the issue showed up quickly in testing. That was a useful shift. Design stopped being judged only by taste or a manager’s opinion. It had to hold up when someone who had never seen the site before tried to use it in a hurry, which is a far harsher test than a polished mockup on a conference room screen.
Cheap publishing made this work explode. Once companies could put almost anything online without a printing press, the bottleneck moved from distribution to organization. Every team wanted pages for products, news, support, careers, case studies, archives and ten other things that had seemed optional a year earlier. There weren’t enough people trained in web structure to handle the rush, so the people who understood page hierarchy, labeling and content order became very busy very quickly. The need grew faster than the training pipeline, which is why so many early web teams mixed writers, librarians, designers, and whoever else had a decent sense of order.
That pressure changed process, too. Web redesigns started to look less like one-off creative sprints and more like repeatable work. Teams built content inventories before they touched the homepage. They mapped old URLs to new ones so people wouldn’t fall into dead ends. Wireframes and staging environments instead of throwing a fresh coat of paint on a tangled site and hoping for the best, they used sitemaps. Even at small companies, launches became something you could plan, review and test in steps rather than a dramatic reveal on a Tuesday afternoon.
You can still see the logic in modern sites. A page like SoundGrail’s blog needs categories and labels that help readers move from one piece to the next without wandering. A shop page like SoundGrail’s shop has a different job, but the same rule applies: if the structure is muddy, the products may as well be hidden in the back room. The visuals can be tidy. The hierarchy still has to carry the weight.
That idea’s easy to miss when a team gets excited about a fresh design. The colors may be pleasant, the spacing generous, the illustrations charming. Then the menu buries the most-used page, the category names blur together and the user has to scan, backtrack, and guess. At that point, the site has a structural problem, not a styling problem. And structure is load-bearing. If it gives way, the rest of the design doesn’t have much to stand on.
That web-era lesson still hangs around because the medium never stopped rewarding clarity. The next wave would shrink the canvas and force even harder choices, but the old rule held: if people can’t find what they need, the experience fails before the interface gets a chance to look clever.
Mobile Scarcity, Then Design Systems
The first iPhone changed the size of the problem. Designers no longer had a roomy desktop browser window and a mouse pointer to work with. They had a small screen, a thumb and a user who might be holding a coffee in the other hand. That forced choice. The result usually felt cramped, fussy and hard to use, if an app tried to cram in every option at once.
In that mobile phase, good interfaces often got simpler for a reason that had nothing to do with minimalism as a style. Progressive disclosure became a practical habit because it let people see the next relevant thing without being buried in every possible setting. A screen with one primary action, plus a few supporting controls, often worked better than a page stuffed with equal-weight buttons. The old web instinct to expose everything at once had to give way to tighter editing. Don Norman’s broader view of user experience fits neatly here, because the screen was only part of the job. The rest was about how people moved, tapped, returned and recovered from mistakes.
Constraints didn’t make mobile design smaller. They made weak decisions harder to hide.
The hamburger menu followed the same logic. People love to argue about it, and fair enough, the icon’s hardly beloved. Still, it solved a real problem: limited space. If a product had too many destinations for the screen, the menu tucked them away without pretending that the device had more room than it did. That trade-off came with costs. Important actions could disappear behind an icon some users never recognized. But on a cramped interface, the alternative was often worse. Mobile design rewarded restraint, then punished clutter.
That same pressure also sharpened the language of user experience principles. Labels had to be shorter. Controls had to be easier to reach. Hierarchy mattered because there wasn’t much room for anything else. Teams learned that if every item fought for attention, nothing won clearly. In a strange way, the small canvas made interfaces easier to read, because it forced people to choose what belonged there in the first place.
At the same time, design systems took over the next job: turning repeated UI parts into reusable parts with names, rules and shared code, once those choices were repeated across products. Design tokens defined color, spacing and type values so teams didn’t have to invent them again and again. Component libraries packaged buttons, cards, forms, navigation, and other familiar pieces so they could be dropped into new products without a fresh round of debate every time. Design ops grew around that work, with people and processes focused on keeping the library usable, current and connected to engineering.
Public pattern libraries helped normalize the idea. Google’s Material Design, IBM Carbon, Atlassian, Shopify, and others made reuse visible instead of hidden inside separate product teams. Later tooling made the practice more routine. Figma libraries, Storybook, zeroheight, and similar tools let teams keep design and code in closer step, so a component could be updated once and reflected many times. SoundGrail’s own music theory app depends on that kind of clarity at a small scale, and a broader page like its learn, promote, and find music hub benefits from the same discipline when repeated modules need to stay consistent.
Reports from design-system vendors and independent studies generally point in the same direction: reuse saves time and cuts down on visual drift. Teams spend less effort rebuilding familiar pieces, and the output tends to look more consistent because the parts come from one source instead of five half-matching ones. That said, the win has a ceiling. Making UI cheaper to produce doesn’t reduce the amount of product people want to ship. It usually does the opposite. Once a component library exists, more screens get requested, more variants get created, and more surfaces need upkeep. The work changes shape, but it doesn’t get lighter.
That’s the useful lesson from the mobile-to-design-systems era. Scarcity forced sharper decisions. Then systems made repetition cheaper. Neither step made the job easy, and neither removed the need to decide what should exist in the first place.
What AI Changes, and What Should Stay the Same
The jump from design systems to AI feels smaller than it first looks. Once teams can spin up buttons, cards and whole page variants from a shared library, the next step is to ask a model to draft the copy, sketch the layout, or generate ten versions before lunch. That’s the new reality: one of the last hard constraints has loosened. Content can be produced on demand. Screens can multiply without much fuss. Variations that once took a sprint and a small pile of coffee now arrive in a burst of prompts.
That sounds efficient until the interface starts to look like a junk drawer. Restraint usually gets expensive, when production gets cheap. “ Need another panel for a setting? Fine. Another model reply state? Fine. Another explanation, tooltip, fallback and alternate path? Also fine. Pretty soon the product’s six ways to do the same thing and none of them feel like the obvious one. AI removes friction, but it also removes some of the quiet checkpoints that used to force a clear yes or no.
When making another screen costs almost nothing, saying no becomes part of the design work.
That’s where interaction design gets broader, and a bit messier. A lot of the important choices now sit outside the screen itself. The model’s behavior matters. The training data matters. Policy rules matter. So do refusal states, safety filters, confidence thresholds and the awkward moments when the system should ask a follow-up instead of bluffing its way through an answer. A screen team can polish the visible layer all day and still ship something brittle if the underlying model acts like a confident intern who skipped the meeting.
This is where older UX lessons keep their footing. Design for people, not for the convenience of the machine. Preserve structure so users can tell where they’re and what happens next. Use constraints on purpose instead of treating them like leftovers from an older toolchain. Jakob Nielsen’s usability heuristics still apply here because they were never really about pixels. They were about clarity, error recovery, consistency, and giving people a system they can predict after the second or third click. AI doesn’t cancel that out. If anything, it makes those basics more exposed.
The temptation, of course, is to let the model do the heavy lifting and call the result smart. Sometimes it’ll be. Sometimes it’ll produce a tidy draft that still needs a human to notice the wrong assumption, the odd edge case, or the screen that solves a problem nobody asked to have solved. That’s not failure. That’s the job.
The best teams in the AI era will sort old habits from durable lessons. They’ll keep the discipline that came from earlier eras and drop the habits that only made sense when every screen was expensive to build. AI should give designers more room to judge, edit and decide. If it replaces judgment entirely, the product may ship faster. It probably won’t ship better.
