In the last few months, I found my passion for programming again.

For a while, I thought I had lost it. Like many developers, I was busy delivering features, attending meetings, reviewing tickets, fixing production issues, and moving from one sprint to another. Programming slowly became something I did because it was my job, not because I genuinely enjoyed it.

Then AI arrived. Or, more accurately, AI became part of our everyday workflow.

Suddenly, we could generate boilerplate in seconds. We could ask for tests, refactorings, explanations, and implementation suggestions. We could move faster than ever before. The AI era is transforming our lives and our jobs at an incredible pace. AI is everywhere: coding, art, design, architecture, healthcare, cars, and countless other industries.

As developers, we now have access to incredible tools.

And that’s exactly why I believe software craftsmanship matters more than ever.

Speed Is No Longer the Problem

For years, one of the biggest challenges in software development was delivery.

How can we build faster? How can we reduce repetitive work? How can we ship more features? AI gives us an answer to many of those questions. Need boilerplate? Generated. Need unit tests? Suggested. Need a second opinion on a pull request? Available. Need help understanding an unfamiliar framework? Just ask. Speed is becoming cheaper.

Understanding is not.

The bottleneck is shifting.

The difficult part isn’t typing code anymore. It’s knowing what should be built, why it should be built that way, and whether the solution fits into the larger system.

The Return of Engineering

Over the last few months, thanks to my daily work and a couple of great books, I’ve rediscovered the joy of software development.

Two books had a particularly strong impact on me:

  • The Missing README
  • The Pragmatic Programmer

They reminded me that great software isn’t accidental.

It’s the result of habits and principles practiced consistently over time.

I’ve started paying more attention to code reviews. I’ve tried to improve the architectures I work on. I’ve thought more about orthogonality, reducing coupling, applying DRY appropriately, and designing systems that are easier to evolve. Not because someone told me to. Because I started enjoying it again.

There’s something deeply satisfying about simplifying a complex design.

About removing an unnecessary dependency. About finding a cleaner abstraction. About making future changes easier for the next person who reads the code. Those things don’t show up in release notes.

But they matter.

Don’t Outsource Your Thinking

AI can help us write code.

But it cannot own our understanding.

One habit I’ve tried to adopt is simple:

Before I merge code, I ask myself:

Can I explain every line of this change?

If the answer is no, I go back and learn.

Why was this library chosen? What are the trade-offs? How does this algorithm behave under load? What happens when this service fails? How will this evolve six months from now?

These questions transform coding into engineering.

It’s easy to copy and paste. It’s harder—and much more rewarding—to understand. I don’t think developers should avoid AI. I think we should avoid turning our brains off.

Use AI as a pair programmer, not as an autopilot. Challenge its suggestions.

Ask why. Verify its assumptions. Learn from it. Disagree with it.

Think in Systems, Not Files

One thing I realised is that I had started focusing too much on individual pieces of code. Functions. Classes. Tickets. Pull requests.

But software isn’t just code.

Software is behaviour. It’s communication between components. It’s trade-offs. It’s architecture.

The best developers I’ve worked with don’t necessarily write code faster than everyone else.

They understand systems. They know where complexity belongs. They know when not to introduce another abstraction. They optimise for change.

Because every system eventually changes.

Code that is easy to modify is often more valuable than code that is merely clever.

Personal Projects Changed Everything

Outside of work, I started coding for fun again.

No deadlines. No stakeholders. No sprint commitments.

Just curiosity.

One of the projects I’m having a lot of fun with is Italian DB, a database written in Java.

I’m intentionally using as little AI as possible. Most of the code is written manually. The architecture is designed by me. Not because using AI would be cheating, but because I wanted to struggle with the problems myself.

I wanted to make mistakes. To redesign things. To discover why databases work the way they do. To understand.

Even on a personal project, I’m following practices I’d use professionally:

  • Creating issues
  • Writing stories
  • Breaking work into tasks
  • Iterating in small increments
  • Reviewing my own decisions

Ironically, removing some of the automation brought back the joy I had when I first learned programming.

The joy of figuring things out.

Make Programming a Craft Again

I don’t think AI is the enemy of software development. I think blind dependence is. AI is a powerful tool. Maybe one of the most powerful tools our industry has ever had. But tools don’t replace craftsmanship.

They amplify it. The developers who thrive won’t necessarily be the ones who generate the most code. They’ll be the ones who understand systems, communicate clearly, make thoughtful decisions, and continue learning. Use AI to eliminate repetitive work. Use it to challenge your ideas. Use it to accelerate feedback loops. But don’t stop studying fundamentals. Read books. Build side projects. Review code carefully. Learn how things work under the hood. Stay curious. Because programming was never just about producing lines of code. It was about solving problems, building things, learning continuously, and creating something meaningful.

And maybe, like me, you’ll find your passion for programming again.

Make code fun again.