After 35 Years of Software Development, I'm Having Fun Again

I've been developing software for roughly 35 years. Long enough to watch platforms rise and fall, and more than a few supposedly revolutionary ideas turn out to be old ideas with better marketing.

I've always enjoyed building things. What I haven't always enjoyed is everything surrounding the building: configuration, dependencies, infrastructure, and the hours spent getting ready to solve the problem that interested me.

Lately, something has changed. I'm having more fun writing software than I have in years.

And I'm probably writing less of the code myself.

The work has changed

There's plenty of talk about AI replacing programmers. I'm less interested in the predictions than in what happens when someone who already knows how to build software gets help with the mechanical work.

I can describe an architecture, explain the constraints, and ask an AI coding agent for an implementation. That lets me spend more time reviewing decisions, identifying weaknesses, and verifying that the result works.

It doesn't mean I can stop thinking. Quite the opposite.

Writing code and engineering software aren't the same thing. The hard questions are about boundaries, tradeoffs, failure conditions, maintenance, and whether you're solving the right problem at all.

AI can produce impressive code quickly. It can also confidently implement a terrible idea, invent unnecessary complexity, or declare victory before anything has been tested.

Sometimes the most valuable instruction is: No. That's much more complicated than it needs to be.

The economics are different

I've always had more ideas than time. Some were too small to justify the setup. Others were interesting experiments that would never become commercial products.

These days, I can explore more of them. I've been building things around astronomy, wildlife, family storytelling, business automation, and whatever catches my attention.

Modern cloud infrastructure helps, too. A small application can be inexpensive to run, automatically deployed, tested before release, and maintained without a fleet of servers.

None of this makes software free. My time still matters, and so does the judgment required to make something reliable. But the threshold for asking what if? has dropped dramatically.

For someone prone to rabbit holes, that's dangerous in the best possible way.

The machine still needs supervision

AI agents lose the thread. They solve the wrong problem, add abstractions nobody asked for, and occasionally become far too enthusiastic about telling me how wonderfully everything is going.

I don't need a cheerleader. I need a useful engineering partner.

So I still insist on source control, tests, repeatable builds, verified deployments, and a way to roll back failures. The resulting software should make sense without asking the AI to explain every line.

The objective isn't the maximum amount of code. It's the smallest reliable solution to a worthwhile problem.

And that's where experience still matters. The lessons learned from years of mistakes don't become obsolete just because a machine can type faster.

Still building

I'm not convinced anyone knows what software development will look like five years from now. I've been around too long to trust predictions delivered with absolute certainty.

But I still love taking an idea, figuring out how it ought to work, and turning it into something real. Now I can follow more of those ideas and spend less time on the parts that used to get in the way.

I still make mistakes. I still learn the hard way. And I still disappear down rabbit holes.

The difference is that I can build something useful on the way down.