Notes Tutorials

Why fundamentals matter more in the AI era

The last part of the series. AI made typing code cheap; it didn't make understanding cheap. What changes, what doesn't, why skills fade when you stop using them, how to learn with AI instead of around it, and a map of the whole series as a checklist.

8 min readAlso available in Bahasa Indonesia →

This series started in part 0 with a question: if you strip away languages and frameworks, what is programming made of? Twenty-four parts later, it ends with a different one. If an AI tool can write the code, why learn any of this?

The short answer: AI made typing code cheap. It didn’t make understanding cheap. And understanding is what decides whether the code is right.

What changed

A lot changed, quickly, and much of it is good:

  • A first draft is nearly free. Boilerplate, a regex, a SQL query, a test skeleton, a port from one language to another: seconds, not minutes.
  • Explanations are on demand. An unfamiliar codebase, error message, or library can be explained in plain words while you read it (part 12).
  • More people can build things. Someone who couldn’t write a script last year can now get a working one.

None of that is a threat to learning fundamentals. It’s a reason to learn them, because all of it produces more code, faster, that someone has to judge.

What didn’t change

Look back at what each part of this series was really about. Very little of it was about typing:

  • Knowing what to build. Turning “can you make me a monthly sales report?” into inputs, outputs, edge cases, and steps (part 9). An AI tool can only be as precise as the request.
  • Knowing whether it’s right. Money in floats (part 2), a quadratic loop on small test data (part 10), a swallowed exception (part 13), a race on the last item in stock (part 21), a missing ownership check (part 22). Every one of these runs, looks fine, and is wrong.
  • Finding out why it’s broken. Reproduce, read, guess, test, narrow down (part 15). A tool can suggest causes; you still need to know which suggestion explains the evidence.
  • Owning what runs. Deployments, data, users, and the call at 3 a.m. (parts 23 and 24).

Jeannette Wing’s 2006 essay, quoted in part 0, already drew this line: computational thinking is “A way that humans, not computers, think.” She also wrote: “Computational thinking is a way humans solve problems; it is not trying to get humans to think like computers.” The thinking was always the job. The typing was just how it got written down.

Feeling faster isn’t the same as being faster

One careful study is worth reading here. In 2025, a group of researchers ran a randomized trial with experienced open-source developers working on their own projects, with and without early-2025 AI tools. “Before starting tasks, developers forecast that allowing AI will reduce completion time by 24%.” Afterwards, “developers estimate that allowing AI reduced completion time by 20%.” The measured result: “Surprisingly, we find that allowing AI actually increases completion time by 19%–AI tooling slowed developers down.”

That’s one study, in one setting: experienced people, large codebases they knew well, tools from a specific moment. It doesn’t mean AI tools slow everyone down, and tools keep changing. What it does show is that how productive a tool feels and how productive it is can be very different, even for experts. The only way to know is to measure (part 10) and to check the result (part 14), not to trust the feeling.

Skills you don’t use, fade

There’s an older warning from a different field. In 1983, Lisanne Bainbridge published “Ironies of Automation”, about operators of automated industrial systems. One of the ironies: when automation does most of the work, “operators will not practice skills as part of their ongoing work.” Yet they’re the ones expected to step in when things go wrong, so they “need to be trained more to be ready for the rare but crucial interventions”.

Programming with AI has the same shape. If the tool writes everything, you stop practicing exactly the skills you need on the day it’s wrong: reading a stack trace, tracing a value through memory (part 3), spotting the O(n²), knowing why a transaction matters. The rare but crucial interventions are the production incident, the data corruption, the security hole. Those are the days that define whether a team can be trusted.

Learning with AI, not around it

None of this means “don’t use AI”. It means use it in a way that makes you stronger, not just faster:

  • Try first, then ask. Do the “Try it yourself” exercises in this series on your own before asking a tool. Then compare. The difference is where you learn.
  • Ask for explanations, not just answers. “Why does this return 0.30000000000000004?” teaches more than “fix this”.
  • Explain it back. If you can’t explain the generated code line by line, you don’t understand it yet (part 12). Rubber duck it (part 9).
  • Make it prove things. Ask for tests and edge cases, then check whether the tests would fail if the code were broken (part 24).
  • Ask small, precise questions. A clear function signature with stated constraints gets better results than “build the feature”, and writing that signature is the fundamental skill.
  • Read the real docs for anything unfamiliar. The Zen of Python has a line for this: “In the face of ambiguity, refuse the temptation to guess.”
  • Keep doing some things by hand. Debug a bug without help now and then. Write a small feature from an empty file. Skills stay sharp when they’re used.

The series as a checklist

Every part of this series turns into a question you can ask of any code, whether a person, a tool, or your past self wrote it:

Part Question it lets you ask
0 The basics of the basics What are the steps, choices, and repetitions here?
1 Running a program What actually runs this, and where?
2 Bits, bytes, and data types Is this the right type? Floats for money? Text encoding?
3 Memory Is this a copy or a shared reference?
4 Variables, state, and scope Who can change this, and when?
5 Conditions Are all cases covered? Any truthiness surprises?
6 Loops and recursion Does it stop? Off by one?
7 Functions What goes in, what comes out, what else changes?
8 Data structures List, set, or map: which fits the question?
9 Breaking a problem down What exactly was asked, including edge cases?
10 Algorithms and Big-O What happens with 100× the data?
11 Abstraction and naming Do the names tell the truth? What does this hide?
12 Reading code Can I explain every line? Why is this odd line here?
13 Error handling Can a failure pass silently?
14 Testing Would a test fail if this broke?
15 Debugging What’s the evidence, and what’s the hypothesis?
16 Git What changed, why, and can I undo it?
17 Refactoring Is this clear, or just clever?
18 The web Right method, right status code, safe cookies?
19 Databases Placeholders, transactions, indexes, NULL?
20 APIs Timeouts, retries, pagination, idempotency?
21 Concurrency What if two of these run at once?
22 Security Untrusted input, escaping, authorization, secrets?
23 Laptop to server Will this behave the same in production?
24 Reviewing AI code Do I understand it well enough to own it?

That table is the whole series in one place. None of the questions depend on which language you use, or on who (or what) wrote the code.

Why this matters day to day

  • The bottleneck moved. Writing code got faster; deciding what’s correct didn’t. People who can do the second are worth more, not less.
  • Tools change every few months. Fundamentals don’t. HTTP, SQL, memory, concurrency, and testing outlived every framework of the last twenty years.
  • Better input, better output. The clearer your understanding, the better your prompts, and the faster you spot a bad answer.
  • Trust. Users, teammates, and clients rely on the person who understands the system, not on the tool that typed it.

Try it yourself

  1. Pick three rows from the checklist table and apply them to a piece of code you shipped recently.
  2. Do one “Try it yourself” exercise from an earlier part without AI help. Then ask a tool to do it and compare the answers.
  3. For one week, write down each time an AI suggestion was wrong and which fundamental let you catch it.
  4. Explain one concept from this series, out loud or in writing, to someone who’s just starting.

Summary

  • AI made typing code cheap; it didn’t make understanding cheap.
  • What still needs you: knowing what to build, knowing whether it’s right, finding why it’s broken, and owning what runs.
  • Feeling faster isn’t the same as being faster; measure and check.
  • Skills you don’t practice fade, and they’re the ones needed when things go wrong.
  • Learn with AI: try first, ask for explanations, explain it back, make it prove things, read the docs, keep some practice by hand.
  • The series is a checklist you can apply to any code, from anyone.

Thanks for reading the whole series.

References