<leeconlin.co.uk />

Artificial Intelligence (AI) coding assistants promise to revolutionise the way we write software, claiming to save time, reduce errors, and even inspire new approaches. With these claims, it's no wonder many developers, myself included, have given them a try. I’ve spent significant time integrating AI coding tools into my workflow, both on local machines and through cloud-based services. However, despite the initial excitement, I ultimately decided to step away from these tools.

This decision wasn't taken lightly. I want to share my experience, the challenges I encountered, and why, in the end, the drawbacks outweighed the benefits.

The Performance Problem

One of the first hurdles I encountered was the performance of local AI coding tools. Many of these tools rely on the processing power of your local machine to generate code suggestions. Unfortunately, unless you have a high-end computer with top-of-the-line specifications, these tools can be painfully slow. Even on a decent machine, the lag between typing a piece of code and getting a suggestion from the AI was noticeable.

This lag isn’t just a minor annoyance; it breaks the flow of coding. Coding, especially when you’re deep into solving a complex problem, requires focus. Any interruption, like waiting for a tool to catch up, disrupts that focus. The time spent waiting for a suggestion or a code completion to appear was often more than the time I would have taken to write the code myself.

Cloud Tools: Fast, but Flawed

To overcome the performance issue, I turned to cloud-based AI coding assistants. These tools are faster because they leverage powerful servers to process and deliver suggestions almost instantly. The difference in speed was remarkable, and at first, I thought this might be the solution I was looking for. However, this approach introduced a new set of problems.

My primary issue with cloud-based AI coding assistants was their integration with my Integrated Development Environment (IDE). IDEs like Visual Studio, IntelliJ, and others have built-in features like Intellisense that provide smart code completions. These features are designed to understand your project, offering suggestions based on your existing codebase and the context of what you’re writing.

The problem arises when the AI coding assistant tries to do the same thing—often at the same time. The AI would make suggestions that clashed with the IDE’s suggestions. The result? A confusing mess of code completions, and more often than I’d like to admit, I found myself accidentally accepting an AI-generated suggestion when I was trying to use the IDE’s built-in functionality.

This conflict not only slowed me down but also introduced errors. For example, the AI might suggest a slightly different method call or variable name than what I intended, leading to bugs that were frustrating to track down. These interruptions were counterproductive, and the time I was supposed to be saving was instead spent resolving these conflicts.

Outdated Models: A Major Drawback

Another major issue with AI coding assistants is that they rely on models trained on a snapshot of data. The most advanced models today are based on GPT-3.5, which was trained on data available up until the end of 2021. That might not seem like a big deal, but in the fast-moving world of software development, it’s a significant limitation.

Programming languages, frameworks, and libraries evolve rapidly. New versions with important changes are released regularly. These changes can include new syntax, new features, or even entirely new ways of doing things. When an AI assistant is based on outdated data, it can’t keep up with these changes. This means that the suggestions it provides might be based on practices that are no longer relevant or even incorrect.

For example, if you’re using a library that introduced a new function or changed the way something works after 2021, the AI might not know about it. It could suggest outdated methods or even completely wrong approaches. Relying on these suggestions could lead to code that is not just inefficient but potentially insecure or unstable.

The Risk of Over-Reliance

As I used AI coding tools more, I noticed a worrying trend. I was becoming more dependent on them for generating code, especially for complex algorithms or functions that I would typically spend more time writing. At first, this seemed like a time-saver. However, I realised that I was starting to trust the AI-generated code without fully understanding it.

This is dangerous. While the AI can generate code that works in many cases, it doesn’t replace the need for a knowledgeable developer to review, understand, and verify that code. Trusting AI-generated code without this critical review can lead to subtle bugs, security vulnerabilities, or other issues that might not be immediately apparent.

Moreover, by relying on the AI, I found myself reading the code less. Instead of deeply understanding the logic and structure, I was just accepting it because it “seemed to work.” This goes against the very principles of good software development, where understanding the code you write is paramount. It’s not just about making something that works; it’s about creating something robust, maintainable, and secure.

The Time Sink of Engineering Prompts

One area where AI tools, particularly chat-based assistants, can be helpful is in speeding up code writing when given clear, specific prompts. However, I found that creating these prompts took more time than anticipated. The AI requires precise instructions to generate useful code, and crafting these instructions is an art in itself.

I often spent more time engineering the perfect prompt than I would have spent writing the code manually. This defeated the purpose of using the AI in the first place. The more complex the task, the more nuanced the prompt needed to be, which turned into a time-consuming process.

Additionally, even with well-crafted prompts, the AI sometimes generated code that wasn’t quite right. This required further tweaking and adjustment, which added even more time to the process. In the end, I found that the time saved by the AI-generating code was lost in the time spent crafting prompts and fixing the AI’s output.

The Future of AI in Coding: A Cautious Approach

AI coding assistants have great potential, but they are not without their flaws. For now, they still require a knowledgeable developer to guide them, correct their mistakes, and ensure that the generated code is up to standard. The limitations of outdated models, the risk of over-reliance, and the conflicts with existing tools make them more of a hindrance than a help in many cases.

This doesn’t mean AI has no place in software development. It can be a valuable tool, particularly for automating repetitive tasks or for generating code snippets that you can then refine and improve. However, I believe it’s crucial to use these tools with a healthy dose of caution and to avoid becoming too dependent on them.

For now, I’ve chosen to step back from AI coding assistants. They’re not quite ready to replace the expertise and intuition of a seasoned developer. But I’ll keep an eye on how they evolve. With further development, they may well become an essential part of the coding toolkit. For the time being, though, I’m sticking with my tried-and-true methods—after all, they’ve served me well for over 25 years.