I've rebuilt the same side project in four different frameworks. Not because any of them failed me. Because a newer, shinier one showed up, and some part of my brain decided that starting over in it would finally be the version that stuck.
None of them were the version that stuck. The project still isn't finished. What I have instead is four half-built versions of the same idea, each one abandoned right around the point where it stopped being fun and started being work.
It took embarrassingly long to notice the pattern: the problem was never the framework.
The Dopamine of Starting Fresh
There's a specific kind of high that comes with a brand new project in a brand new tool. Nothing is broken yet. Nothing has technical debt. Every decision still feels reversible, because you haven't made enough decisions yet for any of them to matter. It's the most optimistic a codebase ever feels — right before you've actually built anything real in it.
That feeling is seductive, and it's also almost entirely fake. It's not that the new framework is better. It's that you haven't lived in it long enough to hit its rough edges yet. Every tool feels amazing in the first week. The real test is whether it still feels reasonable in month six, when the excitement has worn off and you're just trying to ship something.
What Depth Actually Buys You
Here's what nobody tells you about staying with one stack long enough to get genuinely good at it: the payoff isn't linear, it's compounding. The first few months of learning any tool are mostly friction — fighting the syntax, misunderstanding the conventions, googling things that will eventually be muscle memory. But somewhere past that early hump, something shifts. You stop looking things up. You start recognizing bugs by their shape before you've even read the stack trace. You know which part of the system is lying to you before you check.
None of that transfers when you switch tools every few months. You're perpetually stuck in the friction phase of something, which feels like progress because everything is new and you're learning constantly — but it's a different kind of learning than the kind that actually makes you fast. Breadth feels like growth. Depth is what actually pays out.
The Real Reason We Chase the New Thing
If I'm honest with myself, novelty wasn't really about finding a better tool. It was about escaping the unglamorous middle part of mastery — the part where you already understand the basics, the excitement has faded, and what's left is just the slow, occasionally boring work of getting actually good at something. Starting over in a new framework quietly resets the clock. You get to be a beginner again, which feels a lot safer than sitting in the uncomfortable middle of getting truly competent at something you already chose.
That's a hard thing to admit, because it doesn't look like avoidance from the inside. It looks like curiosity. It looks like staying current. It looks, ironically, like the opposite of laziness — you're clearly still learning, still putting in hours, still building things. It just never quite arrives anywhere, because arriving was never really the point.
When Switching Actually Makes Sense
None of this is an argument for never trying new tools. Ecosystems do die. Jobs do require specific stacks. Sometimes the tool you're using genuinely is the wrong one for the problem in front of you, and no amount of depth will fix a fundamentally bad fit.
The difference is in the reason. Switching because the current tool is measurably failing you is a legitimate engineering decision. Switching because a new framework showed up on your feed and looked exciting is something else entirely — and if I'm being honest about my four abandoned versions of the same project, it was almost always the second one wearing the costume of the first.
Choosing the Boring Option on Purpose
These days, before starting anything new, I ask myself a blunt question: am I switching because this tool is actually holding me back, or because I'm bored with the discomfort of getting better at something I already know? Most of the time, uncomfortably, it's the second one.
So I've started doing something that feels almost anticlimactic: staying. Sitting with the same stack past the point where it stops being exciting. Pushing through the boring middle instead of restarting somewhere shinier. It's a much less thrilling way to work. It's also, so far, the only approach that's actually produced something finished.
The Actual Lesson
The next framework was never going to fix the unfinished project. Depth was always the missing ingredient, not novelty. If there's one habit I'd tell any younger version of myself to build early, it's this: get suspicious of the urge to start over somewhere new, especially right when things start to feel like real work. That discomfort isn't a sign you picked the wrong tool. It's usually just the entrance fee for getting good at the one you already have.