Should You Reinvent the Wheel?

“Don’t reinvent the wheel” might be the most repeated advice in design. It makes sense, right? Why waste time creating something that already exists? But here’s the thing — if nobody ever reinvented the wheel, we’d still be riding around on solid wooden discs. No rubber tires, no pneumatic pressure, no steel-belted radials. Sometimes, reinventing the wheel is exactly what we need to do.

In my last article, “Rogue Rules That Prove Breaking Design Conventions Works,” we explored how breaking established design rules can lead to breakthrough innovations. Companies like Snapchat and Apple showed us that sometimes, throwing out the rulebook creates something extraordinary. But there’s another side to this story that we need to talk about: what happens when redesigns go wrong? When innovations fail? As it turns out, these “failures” might teach us even more than the successes.

Let’s talk about bad design. You know what I mean — those interfaces that make you want to throw your computer out the window, those products that seem like they were created by aliens who’ve never met a human being. We’ve all been there, cursing at a website that just won’t work the way we expect, or staring in confusion at a supposedly “intuitive” interface that feels anything but.

But here’s where it gets interesting: even these frustrating designs have something to teach us. In fact, some of our biggest design breakthroughs came from looking at flawed systems and thinking, “There has to be a better way.” So let’s dive into the world of questionable design choices and see what we can learn from them — and maybe figure out when it actually makes sense to reinvent that wheel.

Why Looking Back Matters

Think about it like this: every “obvious” design solution we take for granted today was once a wild experiment. The computer mouse? People thought it was ridiculous when it first came out. Touchscreens? “But what about my physical keyboard?” critics cried. Sometimes what looks like a design failure is actually just ahead of its time.

Take the Newton, Apple’s first attempt at a tablet computer back in the ’90s. It was a commercial flop and is often labeled as a design failure. But look closer, and you’ll see that many of its core ideas — handwriting recognition, touch interface, portable computing — were spot on. The technology just wasn’t ready yet. Twenty years later, these same concepts helped make the iPad a massive success.

The Context Is Everything (No, Really)

Before we start pointing fingers at “bad” designs, we need to understand something crucial: every design decision was made within a specific context. It’s easy to laugh at old interfaces now, but they often made perfect sense given the constraints of their time.

The Classic File Cabinet Metaphor

Remember when computer interfaces tried to mimic real-world office supplies? We had digital file cabinets, folders, and even a trash can. Today, it might seem silly — why limit digital interfaces to physical world metaphors? But back then, designers were dealing with a massive challenge: how do you help people who’ve never used a computer understand this entirely new way of working?

The file cabinet metaphor wasn’t perfect, but it gave people a familiar reference point. It’s like when you’re learning a new language — sometimes you need to translate everything back to your native tongue before you can think directly in the new language.

The Early Mobile Web: A Comedy of Errors (That Taught Us a Lot)

Let’s talk about something more recent: the early mobile web. Remember when websites just shrunk their desktop version to fit on your phone screen? The tiny text, the impossible-to-click links, the endless pinching and zooming — it was a mess. But this “failure” led to something important: responsive design.

Designers realized they needed to completely rethink how websites should work on different devices. Instead of just shrinking things down, they started asking better questions: What do mobile users actually need? How do people hold their phones? What information is most important when you’re on the go?

The Patterns We Keep Seeing (And What They Tell Us)

After looking at countless legacy designs, you start to notice some patterns. These patterns aren’t just interesting — they’re like warning signs showing us where designs often go wrong (and sometimes, unexpectedly right).

The “More Is More” Trap

Ever used a TV remote with fifty buttons? Or opened a software program with so many toolbars you can barely see your work? This is what I call the “more is more” trap, and it’s been catching designers for decades.

The thinking goes like this: “If some features are good, more features must be better!” It’s like adding every possible topping to your pizza — sounds great in theory, but good luck eating it.

Microsoft Word is the perfect example. In the ’90s and early 2000s, each new version added more features, more buttons, more options. The result? An interface so complicated that people started using Google Docs instead — not because it could do more, but because it could do less, more easily.

The “But That’s How We’ve Always Done It” Pattern

This is probably the most dangerous pattern in design. It’s the reason we still use the QWERTY keyboard layout, even though it was designed to slow typists down (to prevent typewriter jams). It’s why some government websites still look like they’re stuck in 1995.

But here’s where it gets interesting: sometimes, “that’s how we’ve always done it” actually protects good design decisions we’ve forgotten the reasons for. Take the humble doorknob — its basic design hasn’t changed much in centuries because it just works. The trick is figuring out which traditions to keep and which to throw out.

What Modern Designers Can Learn (Without Making the Same Mistakes)

Now for the really useful part: how can we take these lessons and apply them to modern design challenges? Let’s break it down into practical takeaways.

1. Start with the Problem, Not the Solution

Here’s a story that perfectly illustrates this: In the early days of digital cameras, manufacturers kept adding more megapixels because they thought that’s what people wanted. But you know what people actually wanted? To take better pictures in low light, to capture their kids running around without blur, to easily share photos with family.

The lesson? Don’t get so caught up in the how that you forget about the why. Before you start designing, ask yourself: What problem am I really trying to solve here?

2. Watch What Users Actually Do (Not What They Say They Do)

Remember when Apple removed the headphone jack from the iPhone? Everyone complained — loudly. But what happened? People adapted, wireless headphones became normal, and now most phones don’t have headphone jacks.

This teaches us something crucial: user feedback is important, but user behavior is more important. People often resist change in surveys but adapt quickly in real life if the new design actually makes their lives better.

3. Make It Obvious (But Don’t Insult Their Intelligence)

Early computer interfaces often treated users like idiots, explaining every little thing with lengthy tooltips and cartoon assistants (looking at you, Clippy). Modern interfaces sometimes go too far the other way, hiding important features behind mysterious icons and gestures.

The sweet spot? Make the main actions obvious, but trust users to explore and learn. It’s like designing a good video game — the first level should be easy to figure out, but there should be advanced features to discover as you get better.

Real-World Examples: The Good, The Bad, and The “What Were They Thinking?”

Let’s look at some specific examples to see these principles in action.

The Evolution of Car Dashboards

Car dashboards are fascinating because they show the constant tension between adding features and maintaining simplicity. Early cars had just a few gauges — speed, fuel, engine temperature. Then came the era of “every possible indicator light,” creating dashboards that looked like Christmas trees.

Tesla took a risk by moving almost everything to a touchscreen. Was it the right call? That’s still debated. But it teaches us something important about digital interfaces: just because you can put everything on a screen doesn’t mean you should.

The Rise and Fall (and Rise Again) of Skeuomorphism

Remember when digital interfaces tried to look exactly like physical objects? Apple’s original iPhone had a notes app that looked like a yellow legal pad, complete with fake leather binding. Then we swung completely the other way with flat design — no shadows, no texture, just pure geometric shapes.

Now we’re seeing a more balanced approach. Modern interfaces use subtle shadows and depth to suggest functionality without going overboard on the realism. It’s like the design equivalent of finding a good middle ground between formal and casual wear.

The Ongoing Saga of Video Conference Software

If you want to see legacy design patterns colliding with modern needs, look no further than video conferencing software. Zoom became huge during the pandemic not because it had the most features, but because it nailed the basics: good video quality and an interface anyone could figure out.

Meanwhile, more established players were stuck with interfaces designed for corporate IT teams, not regular people working from home. The lesson? Sometimes the best design is the one that solves the core problem really well, even if it means leaving out “advanced” features.

Designing for the Future (Without Forgetting the Past)

As we look toward the future of design, especially with AI and virtual reality becoming more common, these lessons from legacy designs become even more important.

The AI Interface Challenge

Right now, we’re seeing the same patterns repeat with AI interfaces. Everyone’s defaulting to the chat metaphor because it’s familiar. But is that really the best way to interact with AI? Or are we falling into the same trap as early GUI designers who could only think in terms of file cabinets and folders?

The Virtual Reality Learning Curve

VR interfaces are going through their own growing pains. Some try to recreate physical worlds exactly (complete with virtual desktop computers — how meta), while others go for abstract interfaces that can be hard to understand. The winners will probably be those who find the right balance between familiar metaphors and native VR interactions.

Practical Tips for Modern Designers

So how do we actually apply all this in our day-to-day design work? Here are some concrete suggestions:

Do Regular Design Audits

Every few months, look at your interfaces with fresh eyes. Ask questions like:

• What features do people actually use?

• What causes the most support questions?

• What parts of the interface feel outdated?

• What new technologies or patterns could make this better?

Create “Desire Paths”

You know those dirt paths that appear in parks where people actually walk, instead of following the paved sidewalks? Look for the digital equivalent in your designs. What shortcuts are users creating? What unexpected ways are they using your interface? Sometimes the best design improvements come from watching what users do and making those actions easier.

Build in Room for Evolution

The best designs are those that can grow and change without breaking. Think about how Amazon’s interface has evolved over 25 years — it’s completely different, but somehow still familiar. That’s not an accident; it’s the result of careful, gradual evolution.

The Big Picture: Why This All Matters

Here’s the thing about design: we’re not just creating interfaces or products. We’re shaping how people interact with technology, how they work, how they communicate. That’s a big responsibility.

When we look at legacy designs — even the flawed ones — we’re looking at previous attempts to solve these same fundamental challenges. Each attempt, successful or not, adds to our understanding of what works, what doesn’t, and why.

Looking Ahead

The next time you encounter a “bad” design, try to understand it before judging it. What problem was it trying to solve? What constraints was it working under? What can we learn from its mistakes — and maybe even its accidental successes?

Remember: today’s cutting-edge design will be tomorrow’s legacy system. The question isn’t whether our designs will become outdated (they will), but whether they’ll lay a good foundation for whatever comes next.

So go ahead, break some design conventions — but do it thoughtfully, learning from both the successes and failures of the past. After all, the best way to predict the future of design is to help create it.

And who knows? Maybe someday, future designers will look back at our work and think, “Well, that was an interesting choice” — and hopefully learn something useful from it.