Learning with AI
Before you start
You need: Article 02 — a chosen path. No programming knowledge yet.
You need installed: access to Claude, ChatGPT or a similar assistant. The free tiers are enough for everything here.
Time: about 40 minutes. Come back to this article whenever you catch yourself pasting answers.
Learning objective
Use AI to learn faster from week one, and keep the understanding that gets you hired.
Topics
- Why this is here at the start, not the end
- The trap, described precisely
- Prompts that teach instead of answer
- The four checks before you accept anything
- What AI is genuinely good and bad at
- What to learn without it
- Studying with AI, week by week
Why this is here, not at the end
Track 18 covers AI-assisted development properly and in depth. It sits at the end of the programme because that is where the professional discipline belongs — reviewing generated code, commit boundaries, responsible use.
But you will start using AI in week one whether anyone tells you to or not. Everyone does. So the question is not whether, it is whether you use it in a way that builds understanding or replaces it.
Six months of the wrong habit produces a candidate who has "completed" the programme and cannot answer a follow-up question. That failure is common, it is invisible until the interview, and it is entirely avoidable.
The trap, described precisely
Here is how it happens. Nobody decides to do this.
Week 1 AI explains it. You read carefully. You understand. Learning
Week 4 AI writes it. You read it. It works. You move on. Drifting
Week 12 AI writes it. You skim. It works. Drifting
Week 20 AI writes it. You paste it. You could not rebuild it. Dependent
The trap is that weeks 12 and 20 feel more productive than week 1. Your output goes up. Your project grows. The exercises get finished. Nothing warns you, because there is no error message for "you did not learn this".
Then an interviewer asks "why did you use a Dictionary here rather than a List?" and there is nothing to say.
Four honest self-checks. Ask them monthly:
| Question | If no |
|---|---|
| Can I write a loop, a class and a LINQ query without help? | Practise until yes |
| Can I explain every line of what I just added? | You have not learned it |
| Can I debug code I did not write? | Track 17, now |
| Could I build a small feature with the internet off? | Try it this week |
The rule, once: if you cannot explain it, you have not learned it.
Prompts that teach instead of answer
The difference is not subtle, and it costs you nothing to choose the better one.
Ask for a critique, not a solution
Bad: Write a C# method that calculates a student's total fees.
Good: I'm writing a method to calculate a student's total fees from
TotalFees, DiscountAmount and their payments. Here's my attempt:
[your code]
Don't rewrite it. Tell me what's wrong and why, and point out any
edge case I've missed. I want to fix it myself.
This is the single highest-value prompt in the programme. You keep the part where you learn, and you still get the answer.
Ask to be quizzed
Quiz me on C# collections. Ask one question at a time, wait for my
answer, and tell me what I got wrong before the next one.
Retrieval practice — being asked and having to produce — builds memory far better than rereading. This turns an assistant into a study partner that never gets bored.
Ask for an explanation of something that exists
Explain this method line by line. I'll tell you which part I don't follow.
Trace what happens when POST /api/students is called in this controller.
Which middleware runs, in what order?
Explaining existing code is the lowest-risk use of AI, because the code is in front of you and a wrong explanation is catchable. It is also the fastest way into an unfamiliar codebase, which is exactly what your first month at work will be.
Ask why, and keep asking
Why is that better than what I wrote?
Why does that fail when the list is empty?
What would break if I did it the other way?
An explanation you can restate is knowledge. Code you pasted is not.
Ask for the trade-off, not the recommendation
Bad: Should I use Dapper or EF Core?
Good: What are the trade-offs between Dapper and EF Core for a
reporting-heavy application? I want to decide myself.
"Which should I use" gives you an opinion you cannot defend. The trade-off teaches you the axis — and the interviewer asks about the axis.
Ask for practice without answers
Give me five exercises on C# collections using a school system —
students, subjects, exam results. No solutions. I'll come back with
my attempts.
The four checks before you accept anything
Run these every time. They take seconds.
1. Does it compile and run? Not "does it look right".
2. Does it do what I asked? Generated code often does something adjacent, or more than you wanted — a caching layer you did not request, an interface with one implementation.
3. Can I explain every line? If not, ask about the line you cannot explain. Do not skip it.
4. Does it break one of the project's rules? This is the check nobody teaches, and it is the one that matters:
| Check | Because |
|---|---|
Is SchoolId from the token, not the request? | Otherwise one school reads another's records — with a 200 response |
| Is the absent check before the marks check? | Otherwise absent students are marked Fail |
Is money decimal, never double? | Otherwise totals drift by paise |
| Does every command inside a transaction receive it? | Otherwise a rollback leaves half the work applied |
None of those four produce an error. They are exactly what a model gets wrong, because it does not know your rules unless you tell it — and they are exactly what an interviewer asks about.
Does it exist? A fifth check for anything unfamiliar. Models invent method names that are precisely what you wished for. students.WhereNotNull() does not exist. A compile error catches most; a configuration key that is silently ignored does not.
What AI is good and bad at
| Strong | Weak |
|---|---|
| Explaining unfamiliar code | Knowing your codebase without being shown |
| Boilerplate — DTOs, mappers, CRUD | Novel logic |
| Syntax in a language you know less well | Anything after its training cutoff |
| Writing tests for existing behaviour | Knowing what is actually correct |
| Suggesting causes for an error | Debugging without evidence you gathered |
| Explaining a concept five different ways | Your business rules |
The pattern: strong on the general, weak on the specific. It knows how ASP.NET Core middleware is ordered. It does not know that your Student.Status has a Transferred value that fee reports must exclude.
Everything unique to your project has to come from you. That is not a limitation to work around — it is the part of the job that is yours.
What to learn without it
Do these by hand until they are automatic. They are what let you judge whether an AI answer is any good.
| Skill | Why it must be yours |
|---|---|
| Language fundamentals | You cannot review what you cannot read |
| Reading errors and stack traces | AI needs the error; you have to find it |
| Using a debugger | Evidence beats guessing, with or without AI |
| Reading SQL | To know whether a generated query is right |
| Git | Recovery is not something to improvise |
| Knowing the requirement | AI cannot know what correct means |
Interviews test these directly, usually with no AI available. So does the first production incident.
A workable rule while learning: attempt it yourself first, then ask. You keep the learning, you still get the answer, and the answer makes far more sense because you have already met the problem.
Studying with AI, week by week
| When | Use it for |
|---|---|
| Reading an article | Ask it to explain any paragraph you did not follow |
| Before the exercises | Ask for extra practice problems, no solutions |
| Stuck on an exercise | Ask what is wrong with your attempt — not for the answer |
| After finishing | Ask it to quiz you on what you just read |
| Reviewing last week | "Ask me ten questions on X, one at a time" |
| Debugging | Give it the error, the code and what you have ruled out |
One thing to avoid entirely: asking for the solution to an exercise before you have attempted it. The exercise is the learning; the answer is just the by-product.
Common mistakes
- Pasting code you cannot explain
- Asking for the answer instead of a critique of your attempt
- Skipping an exercise because AI can do it
- Never asking "why"
- Trusting a confident answer about your own project
- Accepting a method or package without checking it exists
- Reviewing generated code for style rather than for the four rules
- Reaching for AI before reading the error message yourself
Practice
- Write a small method by hand — a fee balance from total, discount and paid. Then ask for a critique with "don't rewrite it".
- Ask for the same method to be written for you. Compare what you learned from each.
- Ask an assistant to quiz you on something you read this week, one question at a time.
- Ask "why" three times in a row on one answer. Note where the explanation stops being useful.
- Paste an unfamiliar piece of code and ask for a line-by-line explanation. Verify each claim against the code.
- Ask for a method that does not exist — something like
List.WhereNotNull()— and see what comes back. - Ask for grading logic for exam results. Check whether the absent case is handled first. Record the answer.
- Ask for the trade-offs between two approaches, then defend one choice in your own words.
- Turn AI off for one full day and build something small. Note what you reached for and could not use.
- Run the four checks on the next piece of generated code you accept. Write down what each caught.
Exercise 7 is the calibration one. Generated grading logic gets the absent case wrong often, and noticing that is the skill.
You can now
- Use AI to learn faster without losing the understanding
- Ask for a critique instead of an answer
- Use AI as a quizzing partner
- Run the four checks before accepting generated code
- Name the four project rules that AI gets wrong silently
- Say what you must be able to do without AI
- Recognise the dependency drift in your own work
Review questions
- Why does the dependency trap feel like productivity?
- What makes "don't rewrite it, tell me what's wrong" the most valuable prompt here?
- Which four checks does generated code need, and why does none of them produce an error?
- Why is explaining existing code the lowest-risk use of AI?
Next: The .NET developer route