I Used AI to Build a Course That Stops AI From Doing My Homework

Every week I see someone post an app they built in a weekend with AI. A to-do app, a SaaS landing page, a full dashboard. And honestly, that's great. A few years ago most of those people wouldn't have shipped anything at all.

But ask a few follow-up questions and things start to wobble. Why does this function return undefined? What happens if the request body is empty? Where does this data actually get saved? A lot of the time the answer is "I'm not sure, the AI wrote that part."

That's the part that bugs me. Not that people use AI. I use it every day. It's that a lot of new developers are skipping the step where you actually learn how programming works. And when something breaks, and something always breaks, they're stuck. All they can do is paste the error back in and hope.

So I tried a small experiment. Could I use AI to make learning the fundamentals faster, instead of using it to skip them?

What I built

I used Claude Code to build a full, hands-on course that goes from "what is a variable" all the way to building a backend API with Node.js and Express.

It's free and it's on GitHub: learn-to-code-in-node-with-ai

There are 20 modules, split into six phases:

• Programming basics: values, variables, operators, if/else, loops

• Building blocks: functions, arrays, objects, strings

• Thinking in functions: callbacks, map/filter/reduce, scope and closures

• Writing solid code: errors and debugging, modules, async/await

• Node.js: npm, reading and writing files, JSON, structuring an app

• Express: routes, middleware, routers, error handling

Alongside the modules you build one project step by step: a Task Management API. It starts small after Module 07 and grows over eight milestones until it's a proper layered Express app with validation, file storage and error handling.

You learn by running things, not by reading

I didn't want another course full of long pages you scroll through and forget. Every module follows the same loop:

Learn the idea (briefly) → Run a tiny example → Predict the output
  → Experiment → Do the exercises → Fix broken code → Self-check

Each module folder has:

• examples/ with small programs you run and change

• exercises/ with starter files that have checks built in. You run the file and see ❌ until you get it right, then ✅

• debug/ with programs that are broken on purpose, for you to fix

• solutions/ for when you've really tried

The predict step is my favorite. Before you run something, you write down what you think will happen. When you're wrong, and you will be wrong a lot, that's exactly where the learning is.

The debug folders matter too. In a real job you'll spend a lot more time reading and fixing code than writing it from a blank file. So it makes sense to practice that from day one.

Think first. Then ask the AI.

The interesting part: the AI is told not to give you the answer

This is the bit I'm most happy with.

Claude Code reads a file called CLAUDE.md from the project folder. It's just a text file with instructions. In this repo, that file tells Claude to behave like a mentor instead of a ghostwriter:

• Don't write the exercise or project solutions unless the learner clearly asks for them

• When asked for a hint, give one small hint, not a list of steps that is basically the answer

• When asked to debug, first ask what they expected, what happened, and what they think is wrong

• When asked to review, don't rewrite the code. Say what's good, what could be better, and which concept to revisit

• Explain things at a beginner level, and only use ideas the learner has already covered

So if you open the course in Claude Code and say "fix my exercise", it won't just do it. It'll ask what you've tried and nudge you in the right direction. It feels a lot like sitting next to a patient senior developer.

That's the whole idea in one sentence: the same AI that can write your code can also teach you to write it, if you set it up that way.

The help ladder

The course also has a short guide on how to use AI while you're learning. The main idea is a "help ladder". When you're stuck, you go up one step at a time:

1. Re-read the instructions and the error message slowly

2. Add a console.log() and see what's actually happening

3. Make the problem smaller and test one piece

4. Explain the problem out loud (rubber duck debugging)

5. Check the hints in the module

6. Struggle for about 15 minutes

7. Then ask the AI for a hint

8. Ask it to explain a concept

9. Write your solution and ask it for a review

10. Last option: look at the solution, close it, and write it again from memory

Most problems get solved somewhere in the first five steps. And the ones that don't are much easier to ask about, because now you know what you've already ruled out.

There's also a set of ready-to-use prompts. For example, this is the hint prompt:

I am trying to solve this exercise: [paste the exercise]
Here is my current code: [paste]

Do not give me the solution.
Give me one small hint that helps me reason about the problem.

And this one is great after finishing a module:

I just finished learning about [topic]. Ask me 5 questions, one at a time,
that test whether I really understand it. Include one "predict the output"
question and one "find the bug" question. Don't give me the answers until I've tried.

AI is actually really good at quizzing you. Most people just never ask it to.

How the AI's role changes as you go

You shouldn't use AI the same way on day one and day sixty. The course suggests something like this:

Stage | How to use AI

Modules 00–05 | Explain error messages, explain concepts in other words, quiz me

Modules 06–12 | Hints when stuck, review my working code, show other approaches

Modules 13–19 | Talk through design decisions, code review, "what edge cases did I miss?"

The project | Plan first, check the plan with AI, build it yourself, review together

After the course | Let AI write more, because now you can read it, judge it and debug it

That last row is the real goal. Knowing the fundamentals doesn't make AI less useful. It makes it much more useful. You can tell it exactly what you want, notice when it's wrong, and understand what it gave you.

Why I think this matters

There's a rule in the course I keep coming back to:

If you can't explain every line of the code, you don't own it yet.

Vibe coding is fine for a prototype or a weekend idea. But if you want to be a developer people can rely on, you need to be able to open a file you've never seen, read it, and figure out what's wrong. AI can speed that up a lot. It can't do it for you, at least not if you want to get better.

What surprised me most while building this is how little it took. One instruction file and a few good prompts, and the same tool that tempts you to skip learning starts helping you learn.

Try it

All you need is Node.js 20 or newer and an editor. VS Code works well.

git clone https://github.com/Nikeshkumar-tk/learn-to-code-in-node-with-ai.git
cd learn-to-code-in-node-with-ai/modules/00-getting-started
node examples/01-hello.js

Start with the README, read USING-CLAUDE.md (it takes about five minutes), and go from there. If you use Claude Code, open the folder in it and it'll pick up the mentor instructions on its own.

👉 github.com/Nikeshkumar-tk/learn-to-code-in-node-with-ai

If you try it, I'd really like to hear how it goes, especially if you're just starting out. And if something is confusing or broken, open an issue. That's useful feedback too.

Photos from Unsplash by Markus Spiske, Yen Vu and Anton Ryazanov.