Why You Should Try Everything for Experience — Even If It’s Been Tried a Billion Times

By Aryan Chauhan– June 17, 2025

There’s a thought that haunts almost every young developer:

“Why should I build this? It’s already been done a thousand times.”

It's not wrong. It has been done — sometimes better, sometimes worse. But here's the truth: the fact that it’s been done is exactly why you should try it yourself.

Experience isn’t about being the first. It’s about understanding why things are built the way they are — and the only way to gain that understanding is to build them yourself, from scratch, without shortcuts.

The Illusion of Redundancy

Let’s say you want to build a virtual machine. You search online and instantly find dozens of open-source VMs — some small, some industry-grade like Lua, JVM, or .NET CLR.

So why bother building your own?

• Because documentation doesn’t teach you why decisions were made.
• Because debugging someone else’s code won’t give you architectural instincts.
• Because abstraction blinds you to the hard lessons buried underneath.

Every time you rebuild something that already exists, you relearn the journey that led to the modern solution. You may even discover better ways — or at least understand what doesn't work and why.

The Value Is in the Doing

When I built Khoya and later Aspire, I wasn’t inventing anything new. People have been building stack-based VMs, register machines, and interpreters for decades.

But the point wasn’t to innovate — not at first. It was to learn:

• What it feels like to write a parser from scratch
• How to design a bytecode format that’s extensible
• How memory layouts affect performance and bugs
• How privilege separation and sandboxing can be implemented

These are lessons you can’t read your way into. You have to live them. You have to suffer through broken implementations, design flaws, and debugging hell until your intuition starts building itself.

Repetition Builds Mastery

There’s a reason musicians play scales, athletes do drills, and martial artists repeat forms endlessly — because repetition builds reflex. It builds comfort. It turns conscious decision into instinct.

Software development is no different.

“Just because someone else has done it doesn’t mean you shouldn’t.”

You’re not building it for GitHub stars. You’re building it for your brain, your hands, and your instincts. You’re building it so that when the time comes to solve real problems, you’ll know which tools to reach for and why.

What You’ll Gain

Trying “old” ideas on your own gives you:

• Architectural literacy — you start recognizing patterns and knowing when to break them
• Debugging depth — you begin predicting failure modes before they happen
• Fearlessness — new technologies stop feeling overwhelming; they just feel like new compositions of the same patterns
• Originality — ironically, the more you copy, the more you learn how to innovate

Real Innovation Starts with Reinvention

Every breakthrough starts with understanding. And understanding starts with building.

Every new system stands on the shoulders of countless old systems. But those old systems were built by people who weren’t afraid to reinvent — even when the world thought it was pointless.

That’s what separates tinkerers from engineers. One gives up after seeing what already exists. The other rebuilds it to understand why it exists that way — and how it could be better.

Conclusion: Build It Anyway

There’s no such thing as wasted effort when it comes to hands-on experience. Whether you’re building a VM, a web framework, a database engine, or a toy compiler, the experience will serve you in ways you can’t predict.

So yes — your idea has been tried before. A billion times, even.

Try it anyway. Your brain will thank you.