It starts innocently.

You rename a batch of files with a ten-line Python script, or you alias a common
git command to shave off two keystrokes. Maybe you build a small shell
function to format JSON from the clipboard.

You’re not even trying to be clever. You’re just solving tiny problems. Making
the machine do what it should have done in the first place. And then something
happens. You cross a threshold. You look at your tools, your environment, your
operating system—even your editor—and suddenly everything is fair game.

You could rebuild that (if you wanted to).
You could improve that (if you wanted to).

Then someone challenges you. As banter maybe, perhaps jokingly but also with a
dash of hope. Then the air in the room changes.

It suddenly becomes something else. It becomes:

You should.

And from that moment forward, the world is broken in new and specific ways that
only you can see.

Technical Capability as a Moral Weight

Before I could program, broken software was frustrating but ignorable. For years
I’ve simply “used” a computer, as a consumer. I was what companies were
concerned with tricking into buying their products, or subscribing to their
services. Not the technical geek that they prefer to avoid with their software
releases, or banning from their games based on an OS.

Now it has become provocative. I can see the patterns that I wish I couldn’t,
find oversights that I can attribute to a certain understanding (or the lack
thereof) of a certain concept and I can hear what has been echoing in the head
of the computer illiterate person who conjured the program I have to debug.

I notice flaws like a good surgeon notices a limp.
Why the hell does this site send ten megabytes of JavaScript for a static
page?
Why is the CLI output not parseable by awk?
Why is this config hardcoded when it could be declarative?

Those things are not just questions, they are accusations. And,
unfortunately, they do not stop.

Now that I’ve learned to notice, my perception of software has changed in its
entirety.

Every piece of software becomes a TODO list.
Every system becomes a scaffolding for a better one.
Every inconvenience becomes an indictment of inaction.

One Must Imagine Sisyphus Happy

Like Camus’ Sisyphus, we are condemned to push the boulder of our own systems
uphill—one fix, one refactor, one script at a time. But unlike the story of
Sisyphus, the curse is not placed onto you by some god. We built the boulder
ourselves. And we keep polishing it on the way up.

I’ve lost count of how many projects I have started that began with some
variation of “Yeah, I could build this but be