I miss programming.
I came to this conclusion recently, when my little brother started his Computer Science degree. To be honest, I hated my degree. I think its format is pretty outdated, but that's a topic for another day, and one I'd like to write about at some point. The thing is, watching him start made me remember my first years programming and, above all, my first job as a full stack developer.
Back then we had ChatGPT 3.5, and it felt like a revolutionary tool. Looking back, though, its capabilities were pretty limited. It had no Internet access, it made mistakes constantly, and it often suggested solutions that didn't work because it didn't know about the latest versions of the frameworks. In practice, we used it to generate simple, repetitive snippets of code, to look for ideas when we got stuck, or to try to fix the occasional bug. But development was still fundamentally manual.
I remember how good it felt to have autocomplete in the editor. It was almost magical, even though, deep down, it was just predicting the next thing you were going to type. I also remember building a product and implementing the whole sign-up and authentication system myself: hashing passwords, managing session tokens, handling permissions... Things I'd probably solve today with a single prompt to Claude, asking it to integrate Better Auth and take care of pretty much everything.
And it wasn't just about writing code. Programming as a team had something especially fun about it: arguing over different solutions to the same problem, reviewing your teammates' code, discovering everyone's little quirks, debating architecture, or spending hours trying to understand why something wasn't working. There was something deeply satisfying about that whole process.
The Feeling of Having Built It Yourself
I'm not saying that building software with AI isn't fun. In fact, it has incredible advantages. You can try out many more ideas, build prototypes in a matter of hours, and iterate at a speed that would have seemed unthinkable a few years ago. But there's something I miss.
The products I build now don't feel as mine as they used to.
While thinking about why that was, something came to mind that, at first glance, has little to do with programming: Minecraft. There's a very specific feeling that anyone who has spent countless hours playing it will probably recognize. That feeling of walking around your world, hopping around without going anywhere in particular, just taking in everything you've built.
Your house, your farms, the paths connecting the different areas, that absurd build you spent an entire afternoon on... And the funny thing is that a big part of that satisfaction comes from having built it block by block.
Imagine you could describe to an AI what you want your world to look like. You decide where each building goes, which farms to build, how to lay out the paths, and what style each area should have. And the AI takes care of building all of it for you. The result could be exactly the same. Even better.
But would you feel the same walking through it? I don't think so. Because even if the decisions are still yours, an important part of the bond you have with that world comes from the time and effort you put into building it. You don't just enjoy the result. You enjoy knowing everything that went into it.
The Joy of Building
I think this same idea explains why we love things like LEGO so much. If all we cared about was having a nice model on a shelf, we could buy it already assembled. But a huge part of the fun is opening the box, sorting the pieces, following the instructions, and watching something slowly take shape.
And the same goes for many other hobbies. Setting up a homelab, for example: spending a whole weekend configuring servers, wrestling with Docker, and automating services you could probably pay a few euros a month for. Or woodworking: spending hours designing, cutting, sanding, and assembling a piece of furniture you could buy ready-made, probably cheaper and with a better finish.
From a purely practical point of view, many of these activities are pretty inefficient. But that's exactly the point. We don't do them only for what we get at the end, but for what we experience along the way: the joy of learning, getting things wrong, solving problems, and watching something take shape with our own hands.
And I think there's something even deeper behind all of this.
The Bonsai Theory
Of all the analogies I can think of, the one that best captures this feeling is the bonsai. Bonsai is a practice that goes far beyond gardening. In its tradition, growing one can become a form of patience, contemplation, and connection with nature.
A bonsai isn't built in an afternoon. It's cultivated over years. You have to prune it, shape it, watch it grow, correct mistakes, and learn to respect its own rhythms.
And the interesting part is that the goal isn't simply to have a pretty tree. The time you devote to it, the decisions you make, and the care you put into every small detail are part of what gives the activity its meaning.
I think something similar happens when we program, build with LEGO, work with wood, or raise our own little Minecraft world. Spending hours creating something to our liking, facing its difficulties, and watching it evolve little by little makes the activity transcend its original purpose. Somehow, we stop simply building something and start building a relationship with it.
And maybe that's where the difference lies: between having something you've imagined and having something you've built.
The Efficiency Paradox
All of this makes me think about a rather curious contradiction. We've spent our whole lives building tools to save time and effort. We abstract processes, automate tasks, and look for ways to do things faster. And, in principle, that's fantastic.
But what happens when the thing we're trying to eliminate is precisely part of what we enjoyed?
When you program with AI, many of the small hurdles you used to have to overcome on your own simply disappear. You no longer need to spend an afternoon reading documentation to understand how a library works, or hours debugging some weird error. Often, it's enough to describe the problem and wait a few seconds. And, of course, that's a huge improvement when your goal is to ship a product. But maybe not every difficulty is necessarily a bad thing. Some of them are exactly what makes an activity interesting.
It's funny that we can spend eight hours looking for ways to automate our work and then come home and spend another three assembling a piece of furniture, solving a puzzle, or building something in Minecraft. Deep down, I think the difference lies in the purpose behind what we do. If I need a piece of furniture, I'll probably prefer to buy it. But if what I want is to enjoy woodworking, buying it ready-made removes exactly the thing I was looking for.
And maybe something similar is starting to happen with programming.
From Programmers to Directors
Another thing I find interesting is how our role in software development is changing. Before, a big part of our job was turning an idea into code. We had to think both about what we wanted to build and about every single step needed to get there. Now, we spend more and more time defining what we want, giving instructions, reviewing results, and correcting course. In a way, we're going from being craftspeople to becoming a kind of architect or director.
And I don't think that's necessarily a bad thing. Being able to focus on high-level decisions and delegate a good part of the implementation lets you build things that would have been unthinkable for a single person before. Besides, there's still plenty of creativity in designing a product, making architectural decisions, or finding solutions to complex problems. But it's a different kind of creativity.
An architect can feel enormous pride in a building they designed without laying a single brick. And a carpenter will surely also feel proud of a table they built following someone else's plans. Both took part in its creation, but their relationship with the result is different.
I think something similar happens with software. It's not that building with AI is less valid; it's that we're trading one kind of satisfaction for another. And, personally, there are days when I miss the first one.
Programming for the Joy of Programming
At this point, I think the solution is pretty simple: nothing forces us to stop programming the traditional way. We can keep using AI at work, take advantage of everything it offers, and build products much, much faster. But that doesn't mean we have to use it for absolutely everything.
If you enjoy programming, why not start a personal project and build it without AI? Without worrying about how long it takes, without trying to finish it in a weekend, and without constantly looking for the fastest way to the result. It could even be fun to do it in a language you've never used: learning Rust, experimenting with some odd framework, building your own game engine, or trying to implement from scratch something you'd normally solve by installing a library.
Not because it's the most efficient choice, but precisely because it isn't. Just for the simple joy of researching, learning, and building something little by little.
I think one of the biggest obstacles to doing this is a mindset we've internalized more and more: the feeling that everything we do has to be productive or end up making money. If you start a personal project, it seems like it should turn into a startup. If you learn a new technology, it should help improve your CV. If you spend time on a hobby, it almost feels mandatory to find a way to monetize it. And if you don't achieve any of that, it feels like you've wasted your time.
This obsession with being efficient and productive deserves a deeper look, and I'd like to write more about it in the future, because it goes far beyond programming and it's something I have quite a few opinions on. But, for now, I'll stick with a much simpler idea:
Not everything we do has to be useful for something else.
We can build things simply because we enjoy building them. A project can be left half-finished, have no users, not make a single euro, and still have been completely worth it.
After all, nobody spends years growing a bonsai because it's the most efficient way to get a tree. They do it because they enjoy the process: caring for it, shaping it, and watching it grow. And maybe we should allow ourselves to do the same with programming.
I don't know if I'll ever feel exactly what I felt during those first years writing code; there's probably a fair amount of nostalgia in all of this, too. But I like to think that, every now and then, I can close Claude, open the editor, and spend an entire afternoon wrestling with some absurd problem that an AI would have solved in thirty seconds. No rush, no expectations, and no need to turn it into anything.
Just for the joy of programming again.