Nothing Personal
Nothing personal.
It’s a phrase we reach for when we want to separate the work from the person. When we delete a branch, revert a commit, archive a project, or scrap something that took weeks. Nothing personal — just code.
But of course, it’s always a little personal. You don’t build things without putting something of yourself into them.
The Build-Delete Cycle
Every developer has a graveyard of projects. Half-finished CLIs. Abandoned side projects. That Rust rewrite that got three commits in before life intervened. The npm package with one star (yours).
We don’t talk about the graveyard much. GitHub profiles show the hits — the starred repos, the active contributions, the green squares. They don’t show the experiments that went nowhere, the pivots, the things that got pulled because they weren’t quite right.
But the graveyard is where the learning happens.
Every deleted project taught you something about scoping. Every abandoned rewrite taught you about the cost of rewrites. Every “I’ll come back to this later” that you never came back to taught you what you actually care about building versus what just seemed interesting at 11pm.
Shipping as a Practice
There’s a certain kind of developer paralysis that comes from wanting things to be right before they’re public. The README isn’t finished. The API might change. The tests are incomplete. The design needs one more pass.
Meanwhile, nothing ships.
The alternative — shipping early, shipping often, accepting that v0.1 will embarrass v1.0 — is uncomfortable. It requires a certain indifference to imperfection. Not carelessness, but the ability to say this is good enough to be useful today and mean it.
The best open-source projects don’t start polished. They start useful. Polish comes later, from the people who find it useful and want it to be better.
On Deleting Your Own Work
There’s a particular freedom in being able to delete something you made.
Not recklessly — not nuking things that people depend on — but the recognition that a piece of work served its purpose and the purpose is done. Archive it. Move on. The ideas inside it don’t disappear; they show up in the next thing you build, cleaner and better understood.
Archiving isn’t failure. Sometimes it’s just the natural end of a project’s lifecycle.
The hard part is telling the difference between a project that’s done and a project that needs more time. Usually the difference is whether people are still finding it useful. When the PRs slow down, when the issues go stale, when you stop thinking about the roadmap — that’s not a crisis. That’s information.
Nothing Personal, Everything Intentional
The phrase nothing personal is really about intention. It means: this decision isn’t about you, it’s about the work. It’s about what serves the goal.
That’s the best frame for building, too. The code isn’t personal. The project isn’t personal. What’s personal is the care you put into it, the problems you chose to solve, the people you hoped it would help.
Those things persist even after you rm -rf the directory.
Build things. Delete things. Build better things.
Nothing personal.