6 mins

There have been plenty of attempts to undermine the power of generative AI. Here's why there shouldn’t be so much skepticism.

In software engineering circles, generative AI-powered coding assistants like GitHub’s Copilot, are becoming a polarizing topic. While some are eager adopters, there are also plenty of engineers who are skeptical of its benefits. 

The arguments for and against AI coding assistants 

I have heard a lot of often heated conjecture on whether AI coding tools’ use should be mandated, to whom, when, and how. For example, certain folks believe that these tools should be solely reserved for senior engineer use, because AI-generated code often requires review and fixing, making it too complicated for junior engineers. While others feel that junior engineers are the best candidates for adoption as they aren’t yet stuck in their ways.

Likewise, some feel their codebase is too complicated for gen AI to assist with. Elsewhere, folks have argued that learning a new tool would negatively impact their productivity. I empathize with each of these arguments against adoption, because while I believe they are coming from a place of fear and distrust, they are also logical. 

Here are some common arguments against adopting AI coding tools and why they should be reconsidered. 

“Junior engineers will never learn how to ‘really code’” 

The idea that junior engineers won't learn to code “properly” if AI always assists them isn’t novel. And in response, I can’t help but look back to the late 1990s when I was learning C++. At the time, senior developers insisted that I would never truly understand software engineering if I didn’t learn assembly. Some still argue that using an advanced integrated development environment (IDE) instead of VIM (text editor) and a terminal to code means you don’t understand what’s happening under the hood. 

However, I understand exactly what’s happening under the hood when I write code, if I didn’t I wouldn’t be in my position. But I certainly like having tools that automate tasks like autofilling variables, closing parentheses and brackets, and running chains of Git commands. Using tools to make our lives easier isn’t cheating and it doesn’t mean that people don’t understand; to me, it’s no different than picking up my power drill instead of my screwdriver.

“Junior engineers aren’t adept enough to troubleshoot code generated by AI” 

Whether it’s the AI that made a mistake, a coworker, or yourself, learning to troubleshoot is an essential role of an engineer. Giving junior engineers the space to learn troubleshooting techniques early in their careers will help them to better understand the code and what common pitfalls to avoid. As soon as an engineer has to resolve their first complicated Git conflict they’re going to be thrust into the deep end of troubleshooting errors anyway.

Perhaps most importantly, let’s not sell our junior engineers short. Junior engineers are eager to learn and absorb information, so asking them to use modern tools isn’t going to be overwhelming. Remember, many engineers coming right out of university are very familiar with using ChatGPT and the like – AI coding assistants are already their new normal. Let’s not push our notions on them, but rather leverage their insights to help senior engineers move into the future.

“My codebase is too complicated for generative AI to help”

A lot of us work on legacy projects released at scale to huge customer bases. Massive code bases with commits dating back well over a decade. These code bases are often fragile and don’t use the latest libraries or software development kits (SDKs). The fragility and complexity of this older code can give folks trepidation about whether tools like Copilot would “break things.” What I find interesting about this argument is that one of the great features of a tool like Copilot is its ability to generate documentation based on existing code. In other words, it can help explain your complicated code to you. Even better, it can help you refactor that complicated code and create tests to reduce its complexity. 

“I don’t have time to onboard and learn a new tool”

The onboarding process of coding assistants is surprisingly simple and they’ll only change your day-to-day unless you choose to use them. For JetBrains and VSCode, Copilot is a plugin that you install, and if you never choose to open the Copilot interface then it doesn’t change your development environment at all. One of the interesting features of coding assistant tools is that they can explain to you how to use them, and explain to you how to use your own IDE. So, once you install it and open up the Copilot window you can basically ask it “how do I use Copilot?” – talk about self-documentation. It's just a version of ChatGPT that sits in your IDE ready to help with questions specific to your code.

Time is never cited as a constriction when engineers have to look into new concepts attached to their IDEs or new libraries they’re working with. For them, it’s natural to invest extra time into opening up a new tab in an already crowded browser window, pulling up a favorite search engine, and scrolling through several suggestions before finding an answer. Let’s not forget to factor in the time it takes to test the solution on the IDE. Now, imagine avoiding that hassle because those capabilities are already built into your IDE. That’s what generative AI coding tools do. Even if you only use them to avoid searching through tabs, you’ll be saving time in no time.

AI tools can also help you with those smaller tasks that seem to take up more time than they’re worth; for example, naming a new method or variable. They can also help with simple refactors and method extractions, as well as creating unit tests.

Embracing AI as a catalyst for growth 

Like most things in life, this topic isn’t black and white. There are so many shades of gray to using generative AI as a helper for the parts of your work – and your life. Gen AI is here to assist. While it may have its flaws and occasionally fall short, this is all part of the learning process as we figure out its strengths and limitations, refining our use along the way.

Tools like Copilot are not perfect, and they are not going to write all of your code for you. Sometimes, you might find yourself trying to use it to no avail, ending up writing the code yourself. I like to think of it as having a peer programming partner who sometimes just doesn’t understand what I’m trying to do. But, I can still ask it to handle tedious tasks or conduct research for me. Everyone will find their own sweet spot and comfort level with the tool and the various services it provides.

Using tools like Copilot and ChatGPT to help me write code or to help me explain a topic shouldn’t feel like cheating, or like I’m no longer doing my job (or even worse being replaced). Why feel conflicted over using tools to help me write code faster or do my job better? 

The bottom line is simply that this is our new normal. While we can reminisce about the “good old days” before generative AI, those days are behind us. Right now, we all have the opportunity to be part of this new era, no matter where we are in our careers.