Careful how much AI-ing you do

I decided to change my course of using AI in my day-to-day developments.

How the cherishing of AI began

I knew about Copilot for cca a year, or a year and a half after it was released to the masses. For pure conservative reasons (I’m from the Balkans after all), I didn’t use it. The classic egoistic thoughts of pff that can’t be that good. Whatever, it’s not that much helpful. And others. I can’t remember why I tried it, but I decided to try it. I was on a call with my TL at that time, pairing on some coding. I was blown away. That dude (Copilot) could anticipate the things I was going to write! It started writing tests for me, and I could TAB ⇥ so much of my work.

I. loved. it.

As time progressed, I started leaning in to AI usage more and more. Nothing crazy. But day by day, (this part is very important) things began to change. I started google-ing less, I started reading documentation less, I started challenging myself less, I started reading source code less, I started writing less.

To be fair, I owe some very good solutions to AI. I remember once, I was busting my brains out how to solve something in Terraform. At least in a nice way. Decided to go to ChatGPT (or as Primeagen calls it ChatGipity), asked my question, and it offered a very nice suggestion to me. Some of it I didn’t know existed, but some of it I just fell stupid that I didn’t think of. At the same time felt amazing with ChatGPT, and bought the first-class ticket to lets use AI everywhere.

I’m not sure that destination is somewhere you want to go.

How the annoyance of AI began

The first thing that started occurring to me, is that programming began to be less fun. I mentioned that as a very important point. At least to me. Since I love programming. I can spend hours and hours programming something fun and laugh out loud about it. I was TAB-ing, not programming.

The second sign was that Copilot was starting to get it wrong more and more as time progressed. After a while, Copilots invasive recommendations actually started bothering me. I think I couldn’t browse normally through code without it making itself known with a useless suggestion.

The last one was the Cursor overuse. Even at my workplace, talks about Cursor and people using Cursor way too much for pretty much everything in my opinion.

The final one was the appearance of Vibe coding. Quite honestly, my reaction to Vibe coding was, what is happening, where am I?! Generally devs have become astonishingly lazy. The amount of time and effort spent into development of features/improvements or learning/improving. But this was a whole other level.

Remember how I mentioned ChatGipity solved my Terraform problem? Well, you can view the whole situation from a different angle. I didn’t know my stuff good enough to solve my problem. Because of the laziness accumulated over time, I didn’t delve deep enough into learning Terraform and the Hashicorp tools to solve my problem.

How I started shifting my perspective

After getting annoyed as fuck with AI, I decided to rotate it a bit. I uninstalled Copilot, and I switched to JetBrains AI. The reason I did that is that basically JetBrains AI offers almost no auto-completion suggestions. At least doesn’t work for me. But, I retained the option that I can have a chit-chat with the AI about some problem if I need to.

Took a bit of getting used to, but my productivity started increasing actually. With the overall productivity, I noticed that I generally produce better code without it. I still use it to generate myself some getter functions.

I wanted to delve deeper into it. So I threw myself into a spiral of philosophical thinking, and investigations. I came to a set of conclusions about it. It is bad for you, don’t overdo it.

1. Juniors are in the risk of getting stuck

Personally, I think juniors are in big trouble. The amount of deep learning and dedication juniors do nowadays (because of crazy frameworks) is at an all time low. But, with Copilot or any other AI tool, the shit is really hitting the fan. In a time-span of 5-10 years, I think current juniors and beginners could suffer the most impact. They will be stuck in a beginner spot, not being able to progress. Dust will fall on their brains, but expectations will start to grow. From themselves and from their employers.

Keep in mind, when you start using Copilot, you are usually astonished with the quality of code it produces. But usually you use it on a function so simple a high school beginner can get it right.

2. Your brain functions differently when you write code

When you write code, and when you read code, your mind functions totally different. When we read code, like a code review, our minds usually look for bugs, logical errors, and some semantics. Rarely we have the whole scope in our heads, having the feel of impact of that code on the codebase. Thats what happens when you spit all the code from Copilots/Cursors suggestions. I’m 99% confident, that 99% of code suggested can be written better. Not taking into account the prompts like: “Write me a function that does a binary search of []int“. When you write code, it is totally different. While developing your feature while writing everything, we always delve deeper. We understand what impact our code has deeper. We write it better, we browse around more. The whole approach in our mind is different.

3. We stopped learning

We stopped learning. We don’t delve deep anymore. For example, imagine writing a prompt like: “ChatGipity, create me a middleware for Go echo library that adds random numbers to Cookie Header“. You’ll get your piece of code, probably works because its simple enough. Though usually even misses that, but at least throws some direction. You finish it soon enough, and voila, off to production. But you haven’t learned anything. You haven’t read echo library docs. You haven’t gone through the echo source code. You don’t know what is happening under the hood. Prompt by prompt, we know less and less. Because we don’t need to. We offload it.

4. To do the hard things, you have to master the easy things

By offloading everything like that, you started to lose touch with things. You start losing your ability to implement simple and easy things. And if you don’t have a handle on the easy things, you can’t go do the hard things at all. When you have the easy things mastered, the hard things become easier as well. But, its the other way around as well. With losing track of the easy things, you won’t be able to solve the hard things. You know that saying you can’t run without learning to walk first. Yeah, but you can’t let yourself forget to walk as well.

What helped me to fortify my feelings towards AI and its usage is running into a lot of articles from people in the industry that I have the utmost respect regarding software engineering and coding in general. It seems to me that they are fighting hard against Vibe coding, and for a good reason.

---

Don’t get me wrong, I don’t think we should ditch AI tools completely. I think they are amazing. I still use AI in my IDE. I love to have a good discussion with it. Its like a colleague in pair programming, but with all the books and references in mind. Hey, I want to create a secure shell application. I presume the Elm framework would be suitable. Tell me about the Elm framework. What are the good and bad sides. Give me application examples I can browse through.. etc.. etc.

Careful not getting trapped in the AI does everything for me rabbit whole. In a year or two, you will regress a lot.