Why Learn C When AI Can Write Code

Let us take this question head on, because you are almost certainly asking it. Zara asked an assistant for a C program that reverses a piece of text. She got one in three seconds. It looked tidy.

It ran on the word hello and printed olleh. Then she ran it on an empty line and the program died. She could not tell why, because she could not read the seven lines that mattered.

That gap is what this lesson is about. Not "AI is bad". Not "AI will take your job". Just the plain question of what you gain by understanding the code in front of you.

Reason one: you cannot check what you do not understand

An assistant is a very fast junior developer who never says "I am not sure". It will hand you a crashing program with total confidence. Someone has to read that code. Someone has to say "this loop runs one step too far".

That someone is you. Here is the exact program Zara was given. You are not expected to write this yet. You are expected to look at it once, so the rest of the lesson has something real to point at.

#include <stdio.h>
#include <string.h>

void reverse(char *s)
{
    size_t i = 0;
    size_t j = strlen(s) - 1;
    while (i < j) {
        char t = s[i];
        s[i] = s[j];
        s[j] = t;
        i++;
        j--;
    }
}

int main(void)
{
    char word[64] = "hello";
    reverse(word);
    printf("[%s]\n", word);
    return 0;
}

[olleh]

#include <stdio.h>
#include <string.h>

void reverse(char *s)
{
    size_t i = 0;
    size_t j = strlen(s) - 1;
    while (i < j) {
        char t = s[i];
        s[i] = s[j];
        s[j] = t;
        i++;
        j--;
    }
}

int main(void)
{
    char word[64] = "";
    reverse(word);
    printf("[%s]\n", word);
    return 0;
}

Segmentation fault

#include <stdio.h>
#include <string.h>

void reverse(char *s)
{
    size_t len = strlen(s);
    if (len < 2) {
        return;
    }
    size_t i = 0;
    size_t j = len - 1;
    while (i < j) {
        char t = s[i];
        s[i] = s[j];
        s[j] = t;
        i++;
        j--;
    }
}

int main(void)
{
    char empty[8] = "";
    char one[8] = "a";
    char word[8] = "hello";

    reverse(empty);
    reverse(one);
    reverse(word);

    printf("[%s] [%s] [%s]\n", empty, one, word);
    return 0;
}

[] [a] [olleh]

#include <stdio.h>
#include <string.h>

void show_bytes(const char *label, const char *s)
{
    printf("%s (%zu bytes):", label, strlen(s));
    for (size_t i = 0; i < strlen(s); i++) {
        printf(" %02X", (unsigned char)s[i]);
    }
    printf("\n");
}

int main(void)
{
    char city[32] = "ঢাকা";
    show_bytes("before", city);

    size_t i = 0;
    size_t j = strlen(city) - 1;
    while (i < j) {
        char t = city[i];
        city[i] = city[j];
        city[j] = t;
        i++;
        j--;
    }

    show_bytes("after ", city);
    return 0;
}

before (12 bytes): E0 A6 A2 E0 A6 BE E0 A6 95 E0 A6 BE
after  (12 bytes): BE A6 E0 95 A6 E0 BE A6 E0 A2 A6 E0

So the uncomfortable summary. AI makes weak code less bad for everybody. It does not make the strongest programmers much stronger. The people who gain most already know what correct code looks like. They can steer it, reject a bad answer and repair a broken one.

Reason two: C is the floor under everything

Look at what C is holding up while you read this page.

Operating systems are C. Databases are C: PostgreSQL, MySQL, SQLite, Redis. Language runtimes are C: CPython runs your Python, and it is a C program. Networking gear is C, so the router in your house runs C right now.

Embedded systems are C too. These are small computers hidden inside other things: microwave ovens, smart meters, drones, car engine controllers and pacemakers. Anything with a chip and a strict power budget tends to be C. C lets you see exactly what the machine will do.

Every "why is my Python program slow" question eventually gets a C level answer. Memory, addresses, bytes, the stack. You can spend years not knowing. You will spend those years guessing.

Reason three: C makes every other language easier

C is small. The 1989 standard had 32 keywords. C17, the version this track uses, has 44, and most of the extra ten you may never type. Java reserves more than fifty words. Python 3.12 has 35.

Once you truly know C's handful, a lot of other languages stop looking new. Their loops are C loops. Their if statements are C if statements. Their curly braces are C curly braces. Even the languages that reject C's memory model, like Rust, borrowed its shape.

There is a second effect that matters more. Learners who start with Python often hit a wall later, when they finally meet pointers and memory. Learners who start with C hit that wall on day one. They climb it while the programs are ten lines long, which is the cheapest time to climb anything.

Reason four: contests, lab exams and interviews

Contests, university lab exams and job interviews all judge the same two things. They judge data structures and algorithms. C and C++ are the languages where those ideas hide the least.

An array in C is a block of memory with its items side by side. A linked list is a chain of addresses. Nothing is doing secret work behind your back. When an interviewer asks "what does this cost", you answer from what you can see.

What AI changed, and what it did not

Here is a fair summary rather than a motivational poster.

How to use an assistant while you learn

None of this is an argument for switching the tools off. It is an argument for a method. Here is one that works.

1. Try first, always. Write your own version before you ask. Even a broken attempt changes what you notice in the answer.
2. Ask why, not what. "Why does this crash on an empty line" teaches you something. "Write me a reverse function" teaches you nothing.
3. Paste your error message, not your problem. An assistant is very good at explaining expected ';' before 'return'. Let it do that, then fix the line yourself.
4. Ask for three inputs that would break it. This is the single most useful prompt while learning. You are training the habit Zara already has.
5. Read every line before you run it. If a line is a mystery, ask about that line. A program you cannot explain is a program you cannot debug.
6. Never paste a solution into a graded problem. Not because you would be caught. Because the practice is the entire product you are paying for.

Use the tool a lot. Use it as a tutor who never sleeps and never gets bored of your questions. Write the code yourself first. Get it wrong yourself first. You will build the one thing a tool cannot hand you: judgment.

size_t j = strlen(s) - 1;   /* looks harmless */

int average = total / count;   /* compiles perfectly */

Next you will meet the people who made this language, and the problem they were stuck on. The story explains almost every odd decision in C.