It's all about techRenato Golia
Menu

A few days ago, I was talking with a colleague about how AI is changing the way we work. At some point, I admitted something that had been bothering me for a while: I miss coding. She immediately agreed.

We talked about the satisfaction of solving problems ourselves, not just getting a result but going through the process of reaching it. There’s the exploration, the occasional frustration, the small discoveries, and eventually that moment when everything clicks. Neither of us misses spending hours debugging an obscure serialization issue, but when the debugging was part of getting an entire piece of machinery to work, it felt worthwhile. You took the highs and the lows.

It was a strange admission from two people who haven’t stopped developing software. If anything, we’re getting more done than ever, and we’re proud of what we accomplish. So why do we both feel that something is missing?

It started on a sunbed

This summer, while spending my holidays in Italy, I started using coding agents extensively to modernize several of my open-source libraries. It was fantastic. I could lie on a sunbed, describe what I wanted to achieve, and let an agent get to work while I went for a well-deserved dip in the Mediterranean Sea. By the time I returned, there was often something ready to review.

I could make progress without spending my holidays staring at an IDE. The surprise came after I returned home: what had been a convenient way to work on vacation had become my normal development workflow.

For my personal projects, I can now have several agents tackling different tasks in parallel. Sometimes I play videogames or watch a movie while they’re working, checking in periodically to review changes, answer questions, or send them back for another iteration. Part of the appeal is probably laziness. If I can get five things done with relatively little effort, it’s hard to justify spending that time implementing just one.

At work, the benefits take a different shape. I can attend a meeting without feeling that development has come to a complete stop. While I’m discussing an architectural decision or participating in planning, an agent can continue implementing something I’ve already designed. Instead of returning to another item on an ever-growing to-do list, I can come back to actual progress.

I value that freedom, both personally and professionally. But somewhere along the way, I stopped being the person writing most of the code, and I’m still figuring out how I feel about it.

The productman and the craftsman

I’ve come to think of two different sources of satisfaction in software development. For lack of better terms, I’ll call them the productman and the craftsman.

The productman enjoys getting things done: turning an idea into a working product, shipping a feature, solving a user’s problem, or simply seeing a project move forward. The craftsman enjoys making the thing itself: understanding the problem, exploring solutions, fitting the pieces together, and watching the implementation take shape. These aren’t separate professions or separate people. They’re two sides of the same developer, and I’ve always enjoyed both.

When I work on Xilo, one of my side projects, I get a great deal of satisfaction from seeing the product take shape. AI has allowed me to venture into areas I wouldn’t previously have attempted, particularly frontend development with Blazor. I still design, prompt, wait, evaluate, and sometimes start over, but I’m building something tangible that I care about.

My open-source libraries offer a different reward. Knowing that other developers find a tool I created useful, or even depend on it, gives me a sense of pride that isn’t tied to any particular implementation session.

It’s in my professional backend work that I notice the loss more acutely. I’ve spent most of my career building backend services; it’s my bread and butter and the kind of development I’ve always enjoyed. For much of its lifetime, I was deeply involved in building one system at work. I knew its internals, understood the reasons behind its design, and enjoyed participating in its evolution.

Over the last six months, development on that system has become increasingly agentic, and my relationship with it has changed. Some of that was inevitable: projects mature, other developers join, and responsibilities shift. I never expected to remain involved in every implementation detail forever. What I didn’t expect was to miss the development work while the system was still actively evolving.

The joy of making things work

Years ago, at a previous employer, I worked on redesigning how our websites displayed search results. We operated different websites for different countries and markets, each with its own requirements and presentation. Over time, those differences had led to a collection of implementations, and I wanted to find a common structure beneath the variations.

Through careful analysis, generalization, and quite a bit of chiseling, I designed a system that could reproduce nearly all the existing views through configuration rather than market-specific code paths. Reusable renderers and views could be composed and configured to produce the different layouts. It was an interesting design problem, and I was pleased with the architecture.

What I remember most vividly, though, is sitting beside a colleague as the components were integrated. One by one, the pieces started fitting together. There were small adjustments to make, a few screws to tighten, but the system worked much as I had imagined it would. Something that had existed in my head was coming alive in front of me.

My colleague was doing much of the integration work, so it wasn’t the act of typing every line that made the moment satisfying. I was there, following the details, understanding how the components interacted, and taking part as the whole thing came together. I still remember that feeling years later.

The satisfaction of getting things done

I don’t want to give the impression that agentic development has made me miserable. In many ways, I love it. At work, we have an asynchronous standup in Slack where we share what we’ve accomplished, and I take an almost masochistic pleasure in listing everything I’ve managed to complete. Looking back at a productive day and seeing tangible progress feels good.

The same is true of my side projects. I can try ideas that would once have been too time-consuming, explore unfamiliar technologies, and make progress on several projects without choosing which one deserves an entire evening. I’m proud of what those projects are becoming, even when I haven’t personally written much of the code.

There is a cost to this way of working, though. Keeping several agents moving requires constant context switching: one needs clarification, another has finished an implementation, a third has made a questionable architectural choice, and a fourth is waiting for review. I can finish a session mentally exhausted despite barely touching the keyboard.

My relationship with code reviews has changed too. I increasingly check whether requirements have been met, tests pass, and the implementation introduces any obvious problems. I still exercise engineering judgment and care about maintainability, correctness, and architectural consistency, but I don’t always explore the code with the curiosity I once had. More of my time goes into directing and evaluating work than into constructing it.

That’s valuable work, and I enjoy the results. The productman in me is having a great time; the craftsman, perhaps a little less so.

The craft I didn’t practice

A recent experience with Artisan Logbook brought the distinction into focus. It’s a World of Warcraft addon I’m building to record and analyze crafting activity, along with a companion application for exploring the collected data outside the game.

While working on the companion, I recognized that Reactive Extensions (Rx) would be a good fit for part of the implementation. I made the architectural decision, explained what I wanted, and let an agent build it. When I reviewed the first attempt, I wasn’t happy with the direction it had taken. There were far more private fields holding state than I had expected, which made me question whether the agent had approached the problem the way I intended. Looking back at my instructions, I realized that my initial prompt had probably contributed to that result.

I revised the instructions and asked the agent to try again, which produced a result I was happy with. I’m genuinely proud of that PR: I identified a suitable approach, recognized that the first implementation wasn’t what I had in mind, and used my judgment to guide the work toward a result I was happier with. Those are meaningful engineering contributions.

What I can’t claim is the same pride in the craftsmanship of the Rx pipeline itself. I didn’t construct it, work through the operators and their interactions, or experience the implementation gradually coming together through my own effort.

That takes me back to the search results system I built years ago. In both cases, I made architectural decisions while someone else did some or all of the implementation. But sitting beside my colleague as that system came together felt different from describing a result to an agent and evaluating what came back. The difference, for me, isn’t simply who wrote the code. It’s how much I participated in the process of creating it.

I don’t want to spend every afternoon fighting framework quirks or debugging obscure problems, but sometimes those frustrations come with a journey I genuinely enjoy. In trying to avoid the lows, I’ve also given up on some of the highs. And there’s nothing particularly epic about struggling to write the right prompt.

Did we optimize ourselves out of the fun?

Lately, I’ve wondered whether I should deliberately spend more time writing code myself. If I took an afternoon to implement a reasonably complex backend feature without agents, I suspect I’d enjoy exploring the problem, making decisions, overcoming a few obstacles, and finally getting it to work. I might finish with one feature instead of the five I could have delegated, and I think I’d be happy with that afternoon.

But will I actually do it? I’m not so sure.

The convenience of agentic development is real, as are the productivity gains and the pride I feel in what I’m accomplishing. I don’t regret adopting these tools, and I don’t believe software development was universally better before AI. Yet the satisfaction of delivering software and the satisfaction of building it don’t feel quite the same to me.

I’ve made it remarkably easy to satisfy the productman in me, perhaps at the expense of the craftsman. I’m proud of what I build with agents, but I miss being involved in more of the journey, not just reviewing what comes back.

The uncomfortable part is that, even knowing this, I’m not sure I want to go back.

This article was produced using an AI-assisted editorial process and was reviewed with AI assistance. Read about my editorial process.

Support this blog

If you liked this article, consider supporting this blog by buying me a pizza!