Your software shouldn't have any connection to you; it should come from
exploration of an idea space. We often think of great creatives as pulling
things from their minds, but really they are good at leaning into discovery:

Brian Eno, [Brian Eno on AI, Art and What Makes Us Human]:

> When you're making something, it starts to come alive when you start to have
> feelings that you didn't expect from it ... and you can either say, "Okay, I
> don't want that." Which is what a lot of people do ... but I don't do that.
> And I think a lot of artists don't do that. We say, "Oh, I wonder where it's
> going. I wonder where it's taking me."

George Saunders, [George Saunders Says Breaking These 3 Delusions Can Save You]:

> In in the book, in that last 15 or 20 pages, I got a lot of surprises. Things
> that I was kind of rooting for didn't happen. Things that came out of nowhere
> and surprised me. So, for me, the beauty of the writing process is it's almost
> like something rises up out of me, that's a little smarter, a little more
> fair, a little more curious, and hovers over the desk for a while.

Jonathan Blow, [Truth in Game Design]:

> It was very clearly the case that more ideas came out of the development
> process and ended up in the final game than I put into it as a designer. The
> process of designing the gameplay for this game was more like discovering
> things that already exist then it was like creating something new and
> arbitrary. And another way to say that is that there's an extent to which this
> game designed itself.

The delta between invention and discovery is a connection to mundane human
experience. Artists and scientists have a sense of what sounds nice, and they
follow that taste through the space of their field. When they get stuck, it's
often because they're pulling the work in a direction it doesn't want to go.
Similarly, great software feels like it was plucked from a beautiful ether.
Like a law of physics, it represents ideas that feel like they've always
existed, that anyone else can implement. Bad software has been pulled away from
its ideal representation, becoming grotesque and deformed, tortured by the
preferences and fears of its creators.

Technologies like Lisp, C, or POSIX have lasted so long because they aren't
clumps of code, they're collections of ideas. If you're implementing an
operating system, a hierarchical file system with a simple user-level API is
just a good idea, and POSIX compliance comes naturally. Good technology only
serves its users, while bad technology serves its creators. Sometimes it serves
profit: Google has contorted the AMP standard to control ad-tech. Sometimes it
servs a desire for self-preservation: systemd is complex because it's a
monolith, it gives its maintainers lasting power over linux systems. Either way,
the software is not designed to help you.

If writing code is a spiritual practice, then folding your own desires into it
is like writing yourself into the Bible. Create things as if no one will ever
know you made them. When your software doesn't have to serve you (monetarily or
otherwise), you can explore the problem spaces on their own terms.