DEV Community: Ali Aldahmani

Is Learning to Code Still Worth It in the Age of AI?

Ali Aldahmani — Tue, 10 Mar 2026 01:12:23 +0000

A conversation that changed the way I think about programming.

I'll be honest, I had a moment of doubt recently. I'm in my last year and a half of university, majoring in AI, and the more I look at what's happening in the tech world, the more a quiet question kept nagging at me: Is any of this still worth it?

Every semester, I sit through classes on C++, Java, and Python — OOP concepts, data structures, and design patterns. Meanwhile, I watch people on social media generate entire working applications just by typing a sentence into ChatGPT. "Vibe coding," they call it. And it actually works. So naturally, I started wondering: if AI can write the code, why am I spending hundreds of hours learning to write it myself?

I needed an answer from someone who actually knew, not an AI, and not a random post online. I needed a real person with real experience. That's when I thought of my old professor: a computer science professor and department chair, someone who has watched this field evolve for decades.

So I sent him an email.

What I Asked

I shared with him what ChatGPT had told me — that programming isn't going anywhere, that AI will just assist developers and make them more efficient, that human creativity and problem-solving will always be needed. It sounded reasonable. But I wanted to know what he thought. Does programming still matter? Will it still matter when I graduate?

His reply was longer than I expected. And it completely reframed how I was thinking about the whole thing.

The History Lesson I Didn't Know I Needed

Instead of giving me a straight yes or no, my professor walked me through the entire history of programming, told through one simple task: adding a series of numbers. Each era, the same problem, a totally different world.

Stage 1 — Machine Language

It started at the very bottom. Pure binary. Instructions written as raw ones and zeros that the hardware understood directly:
0001 0001 0010
No abstraction. No human-readable anything. Just bits.

Stage 2 — Assembly Language

Then came Assembly, which gave human-readable names to those hardware instructions:
ADD R1, R2 ; R1 = R1 + R2
A small step in readability, but a massive mental leap for programmers of that era.

Stage 3 — Fortran (First High-Level Language)

Then the first high-level language appeared — Fortran — and suddenly code started to look almost like math:
DO 10 I = 1, 10 SUM = SUM + I 10 CONTINUE

Stage 4 — ADA (Second Generation High-Level)

Languages kept evolving. ADA brought cleaner structure and readability:
for I in 1 .. 10 loop Sum := Sum + I; end loop;

Stage 5 — Java (Object-Oriented)

Then object-oriented programming arrived, with Java letting developers model entire systems around real-world concepts:
for (int i = 1; i <= 10; i++) { sum = sum + i; }

Stage 6 — Python (Modern High-Level)

Then Python took things even further — doing in a few lines what used to take many, with expressive, readable syntax:
Create two arrays A = np.array([1, 2, 3, 4]) B = np.array([5, 6, 7, 8]) Add arrays C = A + B

Stage 7 — Vibe Programming (AI-Generated Code)

And now? You just describe what you want in plain English, and the AI writes it:

User: Create a Python program using NumPy that multiplies two matrices and prints the result.

import numpy as np A = np.array([[1, 2], [3, 4]]) B = np.array([[5, 6], [7, 8]]) C = np.dot(A, B) print("Matrix A:") print(A) print("Matrix B:") print(B) print("Result:") print(C)

Here's the thing: every single one of those transitions, from machine code to Assembly, from Assembly to Fortran, from procedural to object-oriented — felt radical at the time. People probably asked the same question at each step: "If the new tool does the heavy lifting, do I still need to understand the old way?"

The Part That Actually Hit Me

After walking through the history, my professor made a point that I keep coming back to.

He said that vibe programming allows the programmer to think at the level of ideas and design, rather than focusing on the mechanics of writing code. That sounds like pure freedom. And in some ways, it is.

But then he added the part I wasn't expecting: it is essential that the person writing the prompt actually understands the code that gets produced.

Why? Because software doesn't just get written once and live forever. It has a lifecycle, and every phase of that lifecycle requires real understanding:

That last one — maintenance — is the most important. Real software gets updated, patched, extended, and fixed continuously across many versions. And if you don't understand what the AI generated, you cannot maintain it, debug it, or evolve it with confidence.

He put it simply: AI eliminated some jobs that already existed — machine coders, assembly programmers. But it also created new ones. Prompt engineers. Vibe programmers. The field didn't shrink; it shifted.

The Calculator Analogy

This is the part that really settled the question for me. Think about what happened when calculators arrived.

Nobody said "math is dead." Nobody stopped teaching arithmetic in schools. What happened instead was that the floor of what you could accomplish rose dramatically — but the ceiling only moved for the people who actually understood what was happening underneath. A calculator in the hands of someone who doesn't understand math is just a machine that produces numbers. In the hands of someone who does, it's a tool that amplifies everything they're capable of.

AI and code generation are the same. The tools get more powerful. But the person operating them still needs to understand what they're doing — otherwise they're just producing output they can't explain, verify, or fix.

What I'm Taking Away From This

I came into that email thread feeling like my curriculum might be obsolete before I even graduated. I came out of it feeling as if I finally understood why my curriculum exists.

Learning C++, Java, and Python isn't about memorizing syntax that an AI can generate in seconds. It's about building a mental model of how software actually works, how memory is managed, how objects interact, and how algorithms perform at scale. That mental model is what lets me read AI-generated code critically, catch mistakes, ask better questions, and ultimately build better things.

The programmers who will struggle in an AI-driven world aren't the ones who learned to code. They're the ones who learned to copy-paste without understanding. AI doesn't change that equation — it just raises the stakes.

So yes, it's still worth it. Not despite AI, but especially because of it.

I got tired of Googling pandas methods, so I built this

Ali Aldahmani — Thu, 26 Feb 2026 22:11:09 +0000

I built a VS Code extension that shows Python cheat sheets right next to your code.

So I got tired of switching between my editor and browser every time I forgot a pandas method or a numpy function. You know the drill, you're in the zone, writing code, and then you have to stop, open a new tab, search "pandas groupby example", scroll past 3 Stack Overflow answers... and by the time you get back to your code, you've lost your train of thought.

So I built something to fix that.

DevLens is a VS Code extension that opens a cheat sheet panel right beside your code. It covers HTML, CSS, Tailwind, NumPy, Pandas, Matplotlib, Seaborn, and Scikit-learn (for now).

The part I'm most happy with is the auto-detection. When you open a .py file, it scans your imports and automatically switches to the right library. Open a file with import pandas as pd, and it's already showing you pandas snippets. No clicking, no selecting.

Every snippet has two buttons: Insert drops it directly at your cursor, and Copy puts it on your clipboard. Small thing, but it saves a surprising amount of time.

What's next:

More Python libraries (requests, os, datetime...)
JavaScript and TypeScript support
Java support
Install the library button directly from the panel

It's open source, still early, and I'd love feedback from other developers.

👉 GitHub: https://github.com/Ali-Aldahmani/devlens

Would love to hear what libraries you'd want added first. Drop a comment! 🙌

Introducing AI

Ali Aldahmani — Thu, 15 Jan 2026 07:40:59 +0000

Introduction

This article is a simple summary of what I learned while studying the basics of Artificial Intelligence. I focused on understanding the core ideas—what AI is, how machine learning works, why data matters, and how deep learning and generative AI are changing the world.
Even though I studied this through an Amazon program, I chose not to talk about specific Amazon services. My goal was to keep the information general, clear, and useful for anyone who wants to understand AI, no matter which platform they use.
AI is a broad term.
It refers to a field that has been developing since the 1950s, and it includes many different methods and approaches that help machines do things that usually need human intelligence.

To truly benefit from AI, we also need to manage its risks.

Benefits

AI systems can analyze data and discover insights that traditional programming could never find.
AI can automate tasks and boost efficiency, saving time and effort by handling repetitive or boring work.

ٍRisks

If AI systems are designed poorly, they may include biases or mistakes that lead to unfair or wrong decisions.
When AI systems are not transparent or accountable, it becomes hard to fix problems or deal with their negative effects.

The Promise of AI

AI can analyze huge amounts of data, including sounds, images, and information from the environment, and find patterns that humans would struggle to see.
AI helps organizations detect problems and respond to them faster, in ways that would normally require large teams of experts.
Today, many organizations use AI to tackle big global challenges such as protecting wildlife, fighting hunger, and helping communities recover after disasters.

The Challenges of AI

Some studies have shown that certain AI systems used in healthcare can show racial bias when suggesting treatments, which means some patients may not receive the care they truly need.
In other cases, lawyers have used AI tools that produced fake or incorrect references, and these mistakes were included in court documents. This has led to serious legal problems and multiple lawsuits.

Responsible AI should be at the heart of every AI system.

These examples show why practicing responsible AI is so important. Responsible AI includes the rules, best practices, and tools that help make sure AI systems are safe, fair, and protected from the risks that come with copying human thinking.

No matter what kind of AI you use or build, making sure it is designed and maintained responsibly should always be a top priority.

The module called Practicing Generative AI Responsibly focuses more on how these ideas apply specifically to generative AI. Since this field is changing very fast, it’s important to use the provided resources to learn more and stay updated with the latest guidelines and tools.

Machine learning concepts

ML is a common type of AI

Machine learning is a group of AI methods that use existing data to train a mathematical model. The model learns patterns from this data so it can make accurate predictions when it sees new data later.

Traditional machine learning uses algorithms to learn from data. After training, you get a model that can make predictions or decisions based on what it has learned. Over time, models became more advanced, like neural networks, and with more data and stronger computing power, new techniques like generative AI появились.

At its core, a model is simply guessing something based on past experience—like checking if a payment is fraud or suggesting a restaurant.

To make it easy, think of a model like a brain. Instead of giving it strict rules, you show it many examples. Just like a child learns the difference between a dog and a cat by seeing them many times, a model learns from repeated examples in data. The more it sees, the better it gets.

In real life, data scientists choose the right data and method, train the model, test it, and improve it again and again until it works well.

Trained ML models make inferences

Inference: The output is the result the model gives when it uses what it learned during training to understand new data.

After a model is trained, improved, and tested, and its results are good, it is deployed so it can be used on real data. For example, a bank may use a trained model in its live system to check credit card transactions and decide if they are fraud.

Each time the model looks at new data and gives an answer, this is called an inference—it is the model using what it learned to make a new decision.

Once the model is live, it must be watched and checked regularly. If the data in the real world changes, the model can become less accurate. For example, fraud methods may change. When this happens, the model needs to be retrained with new data so it can learn again.

Determining if ML is the right approach

Before choosing machine learning, you should first ask: do I really need ML for this problem?

Some problems can be solved easily with traditional data analytics. If the rules are simple and can be written clearly in code, analytics is often the better choice. For example, a store can use past sales data and basic statistics to decide how much stock to keep each month—no ML needed.

But if the problem is more complex, like grouping customers by behavior and giving them personalized product recommendations in real time, then ML can be a good choice.

Even then, you must check a few things:

Do you have enough good-quality data to train a model?
Is your problem okay with predictions that may not be 100% exact?
Do you need clear explanations for every decision?
Does your system need very fast answers?

If ML fits your needs, you also have to think about cost. Training, running, and maintaining ML models is not free. The benefit of the solution must be worth the effort and money. Cloud tools make it easier to test and find a cost-effective way to use ML.

Good data is critical to high-value, responsible outcomes

Choosing data sources

Do you have enough data?
Is the data high quality?
Is the data biased or not truly representative?
Is the data recent enough?
What type of data is it?
How much effort is needed to prepare and use this data?

Managing data

Does the data include personal or sensitive information that must be protected?
How will you keep the data safe during development and after deployment?
What rules or systems will you use to avoid duplicate or inconsistent data?

Data is the fuel that runs machine learning. It helps models find patterns, make predictions, and take decisions. The better and more diverse the data, the better the model will perform.

Since ML learns from data, bad or limited data leads to bad results. If the data is biased, outdated, or too small, the model can become inaccurate or unfair. The more important the decision is, the more important it is to use high-quality and unbiased data.

Think of it like teaching a child the difference between dogs and cats:

Volume: How many examples do they see?
Quality: Are the examples clear or blurry?
Bias: Are they seeing only one type of dog?
Timeliness: Is the information still relevant?

If the data is weak, experts clean it, fix it, and prepare it before using it. This step takes a lot of time but is very important.

When choosing an ML method, two big things matter:

What type of data you have (structured or not)
Whether the data is labeled or not

General data types that ML might use

Data usually falls into three main types: structured, semistructured, and unstructured.

Structured data is the kind you see in tables, like in Excel sheets or databases. Everything has a fixed place—rows, columns, and clear rules. This makes it easy to search and analyze, but not very flexible.

Semistructured data is more flexible. It uses tags or labels to organize information, but not in strict tables. For example, emails have parts like sender, subject, and body, but the content can vary a lot. Formats like JSON and XML are also semistructured.

Unstructured data has no fixed format at all. Things like text files, photos, audio, and videos don’t follow a clear structure. This makes them harder to analyze, but with the right tools, they can be very powerful.

Depending on your problem, you either choose a model that can handle your data type, or you first prepare the data so the model can use it.

Labeled data identifies the target of an ML prediction
Target: Is the image a dog or a cat?

One important thing in machine learning is whether your data is labeled or not.

Labeled data means each example already has an answer. Like a photo that is marked “dog” or “cat,” or a transaction marked “fraud” or “not fraud.” This helps the model learn faster and more clearly.

Unlabeled data has no answers. The model must figure out patterns by itself, which is harder and usually needs more data and stronger models.

If data is not labeled, experts—or even other AI tools—may first label it before training the main model.

Basic ML paradigms and common problem types

Machine learning, deep learning, and generative AI

Deep learning is a type of ML that uses neural networks

Neural networks are built from layers: an input layer, one or more hidden layers where thinking happens, and an output layer that gives the final answer. When a model has many layers, we call it deep learning.

Deep learning stands out because it uses huge amounts of different data and very deep models. These models are great at working with messy, unstructured data like images, sound, and text, and at finding complex patterns.

Traditional ML usually learns from a clear dataset to answer one specific question, for instance: is this transaction fraud or not?

Deep learning, on the other hand, handles bigger and more complex problems. For example, a self-driving car must understand roads, signs, people, and traffic rules—all at once—to decide how to drive. It has one main goal, but it makes many small decisions to reach it.

Generative AI uses deep learning to create new content

Generative AI is built on deep learning models called foundation models. These models are trained on huge amounts of data, so they can handle many different types of requests—even ones they were not trained on directly.

Instead of just choosing an answer, they create new content, like writing text, chatting naturally, or generating images from a description.

Because they are so flexible, foundation models can be used in many situations, even for ideas and applications that were not planned from the start.

Conclusion

Learning about AI showed me that it is not just about machines—it is about data, decisions, responsibility, and impact. From simple models that predict outcomes, to deep learning systems that understand images and language, AI is becoming part of everyday life.

But with this power comes responsibility. Building AI is not only about making it smart—it must also be fair, safe, transparent, and trustworthy. Good data, good design, and good intentions matter.

This is just the beginning of my journey in AI. What I learned here gave me a strong foundation, and I am excited to keep learning, building, and using AI in ways that truly help people and make a positive difference.