Simple Tech Talks
The Hidden Risks of Depending Too Much on AI for Programming

The Hidden Risks of Depending Too Much on AI for Programming

Vahagn Chavushyan's photo
Vahagn Chavushyan
·

4 min read

Table of contents

As someone relatively new to programming, I’ve witnessed firsthand how AI has changed the way we learn and build software. At first, it seemed like a game-changer—an instant problem solver, a shortcut to mastering complex concepts. But was it really helping me learn, or was it making me dependent?

Looking back, I realize AI had a much bigger impact on my learning process than I initially thought. And not in the way I expected.

During my first year in programming, my go-to resources were repositories, documentation, Stack Overflow error discussions, and the good old trial-and-error approach. Breaking things, fixing them, and truly understanding what went wrong—that was how I learned. It was frustrating at times, but it forced me to think critically, read documentation, and gain a deep understanding of the code I was writing.

As I started exploring new languages and frameworks, the amount of content I had to absorb greatly increased. Suddenly, learning felt overwhelming. I needed a faster way to keep up. That’s when I turned to AI tools for help with coding and studying.

At first, it seemed like magic. I could ask a question and get an answer instantly. No more spending hours debugging or reading endless documentation. But here’s the problem—while AI gave me solutions, it rarely helped me understand them.

¨We will come back to the quality of solutions I got from it later in this article.¨

Relying on AI made me lazy. Instead of truly learning concepts, I started copying and pasting solutions without questioning how they worked. Debugging became a nightmare because I didn’t fully grasp the logic behind the generated code.

  • Outdated Practices: The AI may suggest using outdated or deprecated methods for common tasks, like using old variable declaration methods or legacy functions that are no longer recommended in modern practices.

  • Inefficient Solutions: The AI might recommend solutions that are not the most efficient, like using more complex or lengthy constructs when simpler, built-in methods would suffice. For example, it might suggest manually looping through an array instead of using a higher-level function or method that is optimized for the task.

  • Outright Incorrect Code: The AI could generate code that doesn't account for possible errors, such as calling methods on null or undefined, or not handling edge cases properly, which could result in runtime errors.

  • Hardcoding and Redundant Imports:The AI might suggest hardcoding values directly into functions or repeating imports unnecessarily, leading to redundant or inefficient code.

Here a little example of what I mean: We have a file, utils.ts, where we have utility functions, and we import these functions into another file, app.ts. However, in app.ts, we are not only importing the functions from utils.ts, but we're also duplicating some of those functionalities directly within the file

// utils.ts

export function calculateTax(price: number, taxRate: number): number {
  return price * taxRate;
}

export function formatDate(date: Date): string {
  return date.toLocaleDateString();
}

// app.ts

// Redundant imports and hardcoded functionality
import { calculateTax } from './utils';

// Hardcoded version of calculateTax, redundant and inefficient
function calculateTaxManually(price: number, taxRate: number): number {
  return price * taxRate; // Same as calculateTax() in utils.ts
}

function displayPrice() {
  const price = 100;
  const taxRate = 0.1;

  // We are importing the calculateTax function from utils.ts,
  // but we are also defining the same function in this file (redundant).
  console.log('Tax (imported):', calculateTax(price, taxRate));
  console.log('Tax (hardcoded):', calculateTaxManually(price, taxRate)); // Hardcoded solution
}

displayPrice();

I realized this was happening a lot when I decided to debug some features of my platform without using AI. I chose to refactor everything using only my knowledge and the language documentation I was working with.

The answer is yes—but not in the way you might think. AI can be a powerful tool, but only if you use it wisely. Here are some key points to keep in mind:

  • Don’t rely on AI to write your code. There will always be gaps in its understanding, and blindly following its suggestions can lead to issues down the line.

  • Complex problems require human reasoning. AI doesn’t truly understand your project, your goals, or the nuances of your requirements—even if you craft the best possible prompt.

  • AI excels at debugging and error analysis. I’ve found it especially useful for identifying issues in code I’ve written myself. It also speeds up my workflow when I use it for quick reference checks.

AI can be a great assistant, but it should never replace your own critical thinking and problem-solving skills.

AIlearningLearning Journey