Steve Jobs once said:
All the work that I’ve done in my life will be obsolete by the time I’m 50… This is a field where one does not write a Principia which holds up for 200 years. This is not a field where one paints a painting that’ll be looked at for centuries, or builds a church that will be admired for centuries. This is a field where one does one’s work and in 10 years it’s obsolete and really will not be usable within 10 or 20 years… It’s sort of like sediment of rocks. I mean you’re building up a mountain and you get to contribute your little layer of sedimentary rock to make the mountain that much higher.
As a web developer, this hits home. Most of what I’ve built over the years is gone, broken, or forgotten. Old portfolio projects won’t even run. Half the APIs I once used don’t exist. Some apps I poured weeks into were sunset within months. Even celebrated production work has since been replaced by new designs, new frameworks, and new ideas. It’s humbling to realize: the code we write has a shockingly short lifespan.
And yet—that’s not a tragedy. It’s the essence of technology.
Unlike architecture or painting, software isn’t built to last forever. The pyramids of Giza still rise after thousands of years, and Cairo’s mosques continue to inspire centuries later. A painting can hang in a museum, unchanged.
But code? Code is alive only while it’s useful, compatible, and relevant. Ironically, a jQuery app from 2011 might still run today with little fuss, while something from the early days of React or Angular is almost impossible to boot without surgery. Frameworks evolve so quickly that yesterday’s “cutting edge” becomes today’s fossil. Reviving old code can be harder than opening a book written in 1812.
That fragility is inevitable. Software isn’t just text—it’s a web of dependencies. Frameworks get deprecated. Browsers evolve. Standards shift. Hardware disappears. What ran smoothly yesterday might break tomorrow with a single update.
So yes, it can feel discouraging. Why pour energy into something that won’t even boot a decade from now? Why does so much effort vanish into the void?
Here’s the paradox: while code itself is temporary, its influence isn’t.
That broken React app from 2016? The skills I gained building it still shape how I solve problems. That API I integrated might be gone, but the design decisions it forced taught me lessons I still use. Each “obsolete” project added a layer of understanding, accumulating like sedimentary rock.
And it’s not just personal. Code spreads ideas. Patterns like MVC, responsive design, or serverless architecture started as experiments. They became sediment. Now they’re bedrock. The original implementations may be gone, but their DNA persists.
Even abandoned work can leave a trail. A repo forked by a colleague. A Stack Overflow answer still helping strangers. An experiment that inspired a feature elsewhere. Permanence in software rarely lies in the artifact—it lies in the ripples.
This changes how I see my work. Instead of mourning its short shelf life, I’ve learned to embrace it. There’s freedom in knowing nothing I make has to be timeless. I can experiment, learn, and move fast without the burden of producing a masterpiece meant to last centuries.
Progress, not permanence, is the measure of success.
And ironically, that impermanence is what makes software so powerful. In a few decades, we’ve gone from Apple I to iPhone, from static HTML to AI-driven apps. Our creations may not survive long, but their cumulative impact reshapes the world—sometimes within a single generation.
So yes, most of the work I’ve done as a developer is gone. Some projects are just screenshots in an archive. Others live only in memory. But that doesn’t make them meaningless.
They were layers. They made me better. They contributed to the stack others now build on. And that’s enough.
In the end, our job isn’t to carve monuments like pyramids or domes of ancient mosques. It’s to build stepping stones. Our code may not be admired in 200 years—or even 20—but it will have moved the field forward.
And for me, that’s a beautiful trade-off.
Closing thought: Permanence isn’t in the software. It’s in the progress. And progress is the one thing our field never stops delivering.