I think that for the last year and a half, we’ve been hearing about how great AI is, how much it’s improving, how it can do everything on its own, how much faster we are, etc. As time goes by and as I work on projects during this period, I agree less and less with these claims.
The developer’s job has basically come down to writing a few prompts, waiting for AI to write the code for us, and then reviewing it. We go through dozens of files in every PR and look at what the changes are. As developers, we’ve started paying less attention to syntax and code cleanliness because we rely on AI, with all the rules we give it, to do an excellent job. Because of that, and because we accept a lot of AI slop code, the level of cleanliness we used to require has now been put aside.
The consequence of handing over the entire programming process to AI is that our PRs can become too big. We have a lot of complicated functions with a dozen checks and validations that we would never have written ourselves before. We have duplicated code because the AI agent often skips refactoring. We don’t notice these duplicates during review because we’re focused on that specific piece of code, without thinking about the rest of the code in the system.
If the system is large, it probably has a lot of tests, which are of course part of every PR. Teams can also decide to have additional files that help with AI development, which also need to be followed and reviewed every time. We are overwhelmed with reading code and lost in all that noise. We focus on individual pieces without always being able to understand the bigger picture.
The process is similar to practicing math, but in a way where we only read the problems instead of actually solving them. The code we read looks good, we are sure it works, and we simply accept it as it is. It’s hard to focus on the bigger picture and understand the project on a higher level. Even if we make an effort to learn how everything works, there is a high chance that we will forget what we learned by the next day.
The problem with this is when some urgent bug appears that we need to fix. That’s when we realize that we don’t know the system, we don’t know where things are in the code. What people will say is that this isn’t a problem, that AI can fix bugs for us, so once again we rely on AI. What can happen, and what has happened to me, is that the AI agent’s server gets overloaded and crashes at exactly that moment, or the session limit expires, or the agent takes forever to generate a few changes. In moments when the release is in five minutes and we need to push out a bug fix, this is a big problem.
Those are moments of frustration when we’re angry at ourselves because we didn’t manage to learn the code and instead left everything to AI. In those moments, we’re missing the confidence we used to have that our bug fix would definitely fix the problem without introducing some additional bug. Now we’re no longer sure about that.
A common argument for this is that developers didn’t understand the code before AI either, because they copied it from Stack Overflow. That argument doesn’t make sense. Back then, a developer would write 90% of their code themselves, and the copied part was just a small piece that was added on top. The developer would write the entire background and flow themselves and understand it; the copied code was just the small missing piece. A developer might not have understood that small piece perfectly at that moment, but they knew they had added it and what it was supposed to do.
Now AI writes everything itself, and the developer can’t keep up with all the changes. Because of that, the gap in our knowledge is much bigger than before. On top of that, I would say that our skills have also started to stagnate. Before, we programmed ourselves every day. We could read code like a book and solve almost any problem, and now we are slower. It takes us too long to concentrate, find our way around the code, etc.
As time goes by, the gap becomes bigger. We have too much code, a large system, and very few people who actually know the logic and the idea behind the system. New features and new requirements keep coming, and we focus on the new things. We don’t close the existing gaps, and with every new release, new problems become noticeable.
This raises the question: are we really deploying that much more than we could before? Yes, we are, much more. But is that code good, and does the entire team know what is happening in the project? I would say no.
Even with good onboarding and regular meetings, it’s difficult to follow everything in detail and really understand it well. I don’t know where this industry is heading, but I think it would be ideal if we found a balance where AI is used only to speed up the process of writing code, meaning that we use it to generate code piece by piece once we already know what that piece is supposed to do, rather than prompting an entire feature at once and then reviewing it.
Whether this is actually possible in this fast-paced industry, I really don’t know.