How I stopped worrying and learned to love AI

When I first tried AI in a code editor, I thought: well, this is a nice autocomplete. It suggests lines, sometimes even good ones. The important thing is to keep an eye on what it writes.

Then it started writing entire classes. Then agents appeared, and you could ask them to build a whole microservice.

And that was when I realized I was working more slowly.

Because AI had already written everything, while I was still sitting there reading. Checking every line. Trying to understand why it did it this way and not some other way.

And the code was already pretty decent. You look at it and think: yes, I probably would have written something like this myself.

That was the moment it started to feel unsettling. Not that I was exactly scared, but the thought appeared: do we still need programmers at all?

If AI can already write code, and I am just following behind it and checking its work, the whole thing starts to look a bit strange.

Then I came across another thought: why read every single line after it? Maybe part of that verification can also be delegated to tools.

We have tests. We have code quality checks. We can define constraints in advance: how things should be structured, what can interact with what, and what must not be done.

Of course, a green check mark by itself does not mean everything is fine. You can build completely the wrong thing and still pass the tests beautifully. Especially if the tests are checking the same assumptions the agent has just invented.

But that is already a different question: what exactly are we checking? How do we know the task has actually been solved?

Recently, I was changing the request intake microservice in Adal Cloud. I decided to see how AI would handle it if I simply gave it the task. Without a detailed breakdown: what we do in this case, what we do in that one, and what happens if something goes wrong.

It did everything. But when I started looking into it, I found bugs and a lot of questionable decisions. In the places I had not thought through or explained, the agent decided for itself. And often not in the way I needed.

Someone still has to think about those parts. And explain to the agent how things should be.

The longer I work with this, the more clearly I see how much of programming happens before you start writing code.

You need to understand the problem. Decide how to fit it into what already works. Anticipate where things can break. And then verify that what you got is exactly what was needed.

And if you do not understand that, an agent can very quickly build something convincing for you. But you will still be the one dealing with the consequences.

I think that is where I finally let go.

I spent years learning how to understand how everything works. That did not disappear just because code can now be written without me.

It is just that before, between the decision and the result, I still had to type all those lines myself. Now that part of the work can be delegated.

And honestly, that is exactly the part I am happy to hand off.