The Joy of Coding
(or what it looks like now)
There is a lot happening in the tech scene right now.
New model releases, new coding agents, and more conversations around autonomous coding. Things are moving fast. I don’t know if it’s a bubble around me or if it’s actually everywhere, but it’s very real in my circle. The people I follow, the people I talk to in real life. Everyone seems to be discussing the same shift.
It feels important. Like this is not just another tool upgrade, but a change in direction.
At the same time, I sometimes feel a bit discouraged. Not depressed, but something closer to uncertainty. What we used to do, and how we used to do it, is changing. The way I learned to code, the way I spent years getting better at it, doesn’t map one-to-one anymore.
I’m not resisting this change. I’m actively using these tools. Claude, Codex, multiple agents. I experiment, I adapt, I try to understand what works. Work still gets done. In many cases, it gets done faster.
The joy of coding is still there for me. It just looks different now.
I’m not writing every single line of code anymore. Instead, I’m guiding agents. Shaping direction. Reviewing outcomes. Translating thoughts into something executable through these tools. That process still gives me joy.
Recently, this became very clear while I was building my claude.md.
I spent time writing down my engineering philosophy. Not as theory, but as a summary of what I’ve learned over the years. Things like YAGNI with seams, being pragmatic about DRY, preferring simple code over clever abstractions, designing for deletion, treating security as a first-class concern, and focusing on integration tests over excessive mocking.
Writing it forced me to reflect. On mistakes I’ve made. On systems that became hard to change. On abstractions that looked elegant early on but became liabilities later. On production incidents that shaped how I think about observability, testing, and security.
I felt genuine pride while writing it. Not because it was perfect, but because it felt honest. Like compressing years of experience into something explicit. Something that could guide not just me, but also the agents I work with.
It wasn’t a new realization. More like a confirmation.
The joy of coding was never about typing code.
It was always about the end product.
But the process mattered. It was challenging, sometimes frustrating, and that’s exactly what made it satisfying. The thinking. The tradeoffs. The discipline to decide what not to build. The willingness to delete things that no longer served the system.
Today, that same process still exists. It has just moved up a layer.
Instead of expressing judgment through keystrokes, I express it through constraints, principles, reviews, and guidance. Through documents like claude.md. Through how I steer agents rather than how fast I type.
I don’t know how the future will look. I don’t know how far autonomy will go, or what the role of an engineer will eventually become.
What I do know is that the part I’ve always enjoyed hasn’t disappeared. It has just shifted.
The joy was never in typing code. It was in the process of thinking deeply, making tradeoffs, and turning ideas into systems that work.
If that process still exists in some form, I’m curious to see where this goes.