The Same Principles, Different Products

For most of my career, I thought process improvement meant adding something new.

Another checklist. Another report. Another feature. Another layer of control.

Lean manufacturing and Kaizen taught me almost the opposite.

The best improvements rarely come from adding. They come from removing.

Every extra button, scan, handoff, approval, or “it only takes a second” decision creates friction that piles up over time. Complexity is a tax. And you don’t pay it once. You pay it every single day.

Lean taught me to ask a simple question:

If I had to pay for this step forever, would I keep it?

Years later, I found myself asking the same question while building software.

If a new feature requires more training, more decisions, or creates more room for confusion, then I’m probably taxing the system, not improving it.

Training should teach judgment and craft. It shouldn’t be there to compensate for a messy process or bad design.

That lesson took me a while to carry over into software.

When I first started building on the Nostr protocol, I was fascinated by the technology. Encryption. Key pairs. Sovereignty. Open protocols. I thought everyone else would be fascinated by it too.

But I was looking at the product through a builder’s eyes.

Most people just wanted recipes.

The irony is that Zap Cooking originally started as an attempt to remove noise. Strip away the ads, pop-ups, life stories, and everything standing between someone and the recipe they wanted to cook.

And somewhere along the way, I started putting noise back in through technology.

User feedback brought me back down.

Don’t make people learn your technology. Make your technology learn their habits.

That doesn’t mean abandoning sophistication. In many ways, it means the opposite. The complicated work still has to happen. It just shouldn’t always be visible to the person using the product.

A good manufacturing process works the same way.

The person doing the work shouldn’t have to think through twenty unnecessary decisions just because the system allows twenty possibilities. Good process design makes the right action easier.

Eventually, it becomes habit.

Software isn’t much different.

Over time, I stopped measuring progress by how many features we shipped and started asking different questions.

Did we remove a decision?

Did we eliminate a click?

Did we make something easier to understand?

Does the next step feel obvious?

Will someone come back and use this without having to think about how it works?

Those are habit questions, not feature questions.

Because people don’t build habits around complexity. They build them around confidence.

And this is where my experience in manufacturing and supply chain continues to shape how I see the world.

I love manufacturing because I can see where the improvements need to happen.

You can walk a process. Watch material move. Talk to the person doing the work. See where information gets lost, where a handoff breaks down, where inventory piles up, or where someone has created their own workaround because the system doesn’t actually work the way someone in an office thought it did.

There is something incredibly satisfying about that.

Software has given me another way to explore the same ideas, but at a different speed.

There are often fewer layers between seeing a problem and testing a solution. You can build something, break it, learn from it, and build it again.

The harder part has always been people.

And strangely enough, that might be the part I was born to do.

You can build the best process in the world, but if you don’t understand the people inside of it, it probably won’t last.

That takes communication. Trust. Patience. Curiosity.

And maybe most importantly, humility.

The older I get, the more I think humility might be one of the most important parts of continuous improvement.

You have to be willing to admit the system could be better.

That your idea might be wrong.

That the person closest to the work might understand something you don’t.

And that same thinking has started showing up in other parts of my life.

I serve on a school board. It’s hard to spend any amount of time around education and argue that there aren’t systems that need to improve.

But education isn’t a factory.

People aren’t machines.

You can’t optimize everything with a spreadsheet, an algorithm, or another policy.

The same is true in manufacturing. And supply chain. And software. And communities.

We’re building systems for people.

Looking back at my career, the pieces might seem disconnected from the outside.

Manufacturing. Supply chain. Lean. Software. Bitcoin. AI. Education.

I don’t really see them that way anymore.

I see one discipline expressed through different mediums.

Simplify complexity.

Respect the person doing the work.

Build systems that make the right action easier.

Remove more than you add.

And have enough humility to keep asking whether there is a better way.

I’m not chasing perfection. I’m not sure perfection is even the point.

I’m trying to take what I’ve learned and make things a little better than I found them.

Sometimes that’s a manufacturing process.

Sometimes it’s a supply chain.

Sometimes it’s a piece of software.

Sometimes it’s education.

And sometimes it’s simply helping people connect.

Maybe that’s what continuous improvement really is.

Not a manufacturing philosophy. Not a software methodology. Not another framework.

Just the humility to believe something can be better, the curiosity to ask why it isn’t, and the willingness to do something about it.

And lately, I’ve been wondering how many of the problems we think belong to completely different worlds are really the same problem underneath.