Oct 2026

Contents

Background

I’ve been a professional Software Developer since 2013. In that time, I was always focused on delivering quality over quantity. During my consultancy period, I felt like that that was the thing that I brought to the table, what I was hired for. Ofcourse, the main goal was to take a problem, slice it into smaller problems, and create solutions for those problems. But, I also had to make sure that the solutions were readable, maintainable and understandable.

Creating solutions with a good structure, simple to understand and consistent code, was something I always were proud of. It gave me energy and satisfaction. Coding those solutions did that also. Moving slowly and thinking through my solutions, allowed me to do that.

When I started

Around the beginning of 2023, my experience with AI started. I was a bit skeptical around the use of AI, specifically about the ownership of the code if AI would do the work. My company allowed me a license for GitHub CoPilot, so I started experimenting with it. It felt like a fancy autocomplete, being able to make better suggestions because it had more context.

However, I noticed becoming more annoyed with the suggestions. It was not always right. When it was, it was not the way that I would code it myself. I felt that I had to write the code myself, to keep the understanding of the codebase and keep building my knowledge of it (and the language and/or frameworks used). If I did not understand what copilot suggested, I threw it away anyway. Quality was still very important to me. My usage of AI slowly degraded.. But I did see a rapid growth of all kinds of AI tools added in programs or apps.

Advisory role

Then, around a year later, I started to work with ChatGPT a bit more. I did still write all of the code myself, but sometimes troubleshooting issues manually take too much time or was too hard. ChatGPT was a great fit for this. Or it helped me to explore some ideas before I would start to implement a solution. A great tool for Rubberducking1.

I occassionally switched to Claude Code, to aid with troubleshooting any bugs or problems. However, I noticed that sometimes the agent seemed to drown in its own words and it made stuff worse. Probably because the context window was getting too large. But still, I always wrote the code myself. I enjoyed it too much and did not trust the output of AI enough to let it take over that part of my job.

Writing code

Fast forward to 2026, where I started to experiment with letting the agent write (some of) my code. The Software Engineering industry seemed to move more and more towards that. I can only judge that way of working, by learning from experience.

The agents were (or are) pretty good at implementing features. But, it’s so verbose. Without any guardrails, the agent just outputs so, so much. Loads of comments. Long commit messages. A lot of code for a simple feature. So many markdown files. Many ADR’s2. I disliked having to go through all of that to get a sense of what is going on.

Eventually I found a way to have it work for me, by using the skills from Matt Pocock. With good guardrails and small tasks, the agent seemed to do exactly what I want, the way I want it. The output was much more readable for review and better to grasp. But still, I was having doubts about this new way of working. It did not give me the same level of satisfaction as when I write the solutions myself. I did noticed, however, that I enjoyed coming up with a good software design, a clear separation of concerns. Essentially the Strategic Programming3.

Current state

With the Software Engineering craft changing as we speak, I am left wondering what the long-term effect would be of letting AI do all the programming work. In my experience, manual coding gave me the feeling of being actually responsible for what I did. A sense of ownership. I do not have that, or have it less, when an agent writes the code for me. It’s better when I design the actual solution myself, but it’s really tempting to let the agent do it all. The path of least resistance.

But I am responsible. That’s my job. I have to review everything the agent does. Because I have been developing for over a decade, I developed a kind of sixth sense, a so-called fingerspitzengefühl, to know when code is bad or could be improved. However, when I keep writing less code by hand, I fear that that sense will degrade over time. Will it make me dumber? How would I prevent that or how will I keep learning? How would any junior developer increase his or her craft?

It’s like I am between stage 4 and 5 of the 5 Stages of AI Grief, between Depression and Acceptance. I try to keep an open mind, however, and will see how it works out long-term.

Footnotes

  1. Rubberducking is a problem-solving technique where you explain your code or task to a rubber duck—or any inanimate object—and discover the solution yourself through the act of explaining. ↩

  2. Architecture Decision Record. ↩

  3. A term coined by John Ousterhout in A Philosophy of Software Design: Investing time and effort in the Software Design. ↩