I Never Knew When I Was Done. Now I Do

PotatoLab — Wed, 03 Jun 2026 18:32:13 +0000

I didn't realize I had a broken definition of "done" until I tried to write one down.

A few months ago I sat with a blank doc and asked myself: what would it actually take for this project to be finished? I couldn't answer it. Not because the project was complicated. I just never defined the finish line. I had just been running.

That's the thing about "done" when you're a perfectionist engineer. It doesn't really exist. There's always a refactor that would make it cleaner, a feature that would make it more useful, an edge case that would make it more correct. "Done" becomes a horizon. You move, it moves.

So in practice, my projects were never done. They were just abandoned. Quietly. No announcement. Just a private repo that I stopped pushing to.

What changed wasn't motivation. It was the contract.

When I started PotatoLab, I forced myself to write down what the project needed to do to be real before writing a single line of code. Not a spec. Not a roadmap. Just a small, honest list.

This needs to do X. When it does X, it ships.

That's it. That's the whole contract.

The first time I did this it felt almost too simple. But simple is what made it work. "Done" was now a specific thing I had already agreed to. I couldn't quietly move the goalpost. I signed the contract with myself before I got attached to the thing I was building.

Day-to-day, here's what actually shifted

Before, I'd open a project and ask what should I build next? Now I open it and ask am I done yet? That's a different question. It points toward an exit instead of deeper in.

When I catch myself wanting to add something that wasn't in the original list, I write it down separately. Not as a backlog, more like a "maybe next experiment" note. It scratches the itch without bloating the current thing.

I also stopped calling unshipped work "in progress." It's not in progress. It's in limbo. Progress means moving toward something. If I can't tell you what done looks like, I'm not progressing. I'm just busy.

The graveyard didn't close. But it stopped getting new residents.

I still have the old projects. I'm not going to pretend I finished them or that any of this makes them okay. They're still there.

But since I started writing the contract first, I've shipped three experiments. None of them are big in scope. But all three of them exist outside my laptop, which means all three of them kept their promise.

In the next posts I'll go through each one. What it does, how it works, and what I learned building it small on purpose.

That's what done means now. Not perfect. Not scalable.

Just the small promise, kept.

In Part 3 I'll close out the why before getting into the what. Each experiment, a name and a reason. Then the real posts start.

PotatoLab is at potatolab.cc. Lumpy things, shipped.

Why I Stopped Building Features and Started Shipping Experiments

PotatoLab — Sat, 16 May 2026 20:04:02 +0000

An honest post about perfectionism, unfinished projects, and why my portfolio is named after a vegetable

The worst advice I ever got about building projects

"You should know it all before you start."

You won't. You never do. And waiting until you do is just a more socially acceptable way of never starting.

I have a graveyard.

An Android SDK for image processing that never saw light. A logistics platform that got about 80% done before I move to different things. An e-commerce thing. Some indie apps I built sitting in a private repository.

I'm a full-time software engineer. I know how to build things. So why couldn't I finish any of them?

The answer, if I'm honest, is that I kept building the wrong version. Not wrong in the technical sense but rather wrong in the scope sense. Every project became the version that would handle every edge case and look perfect doing it. I never admitted that. But just kept building like that was the goal.

It wasn't perfectionism in the classic sense. It was perfectionism disguised as engineering. "I'll ship it when the architecture is right." Meanwhile nothing shipped.

Then my wife suggested I call it 감자랩 as in PotatoLab

I laughed. Then I thought about it.

Potatoes are not glamorous. They're lumpy, inconsistent, yet nobody ignores them. But if you know what you're doing with them, they turn into something completely different. Something good. The raw form doesn't matter; what matters is that you actually cook them.

So I made a rule for myself

A project that goes into the lab. It has to meet a small, specific set of requirements I define upfront not a roadmap, not a backlog, just: what does this need to do to be real? When it hits that bar, it ships. Not when it's perfect. Not when it scales. When it works well enough to be true.

Shipped doesn't mean finished. It means fulfilled. A small promise, kept.

The experiments on PotatoLab aren't impressive in scope. None of them are perfect. But they exist outside my laptop, which is more than I can say for the SDK that was going to change mobile image processing.

Start lumpy. Ship weird. Cook the potato.

In Part 2, I'll get into more details, and I don't know what I am going to write about but here we are...

DEV Community: PotatoLab