Agentic Coding Tools for Students

You are learning to program at the exact moment programming changed. Coding agents (Claude Code, Codex, Cursor's agent mode, and others) can take a task, read a project, write code, run tests, and fix their own mistakes. Used one way, they make you a much faster learner and a much more capable engineer. Used the other way, they let you submit work you do not understand, and that catches up with you in the first technical interview.

This module is early in the path on purpose. Every later module has exercises where an agent can help, and the difference between helping and cheating is a set of habits you should build now.

The Rule: The Agent Explains, You Decide

Here is the line. An agent may do anything that you could do yourself, given time, and can verify. An agent may not do anything you could not explain afterward.

Practically: if the agent writes a function, you should be able to say what each line does and why it is there. If you cannot, the next prompt is not "make it work", it is "explain this line by line and tell me what would break if I removed the second loop". That question is how you learn faster than anyone did before these tools existed.

What a Coding Agent Actually Does

An agent runs a loop: read your task and the project, take an action (edit, run, search), check the result, repeat. It can take dozens of actions before reporting. Three consequences:

• It needs a way to check its work. If there are no tests, ask it to write one first, and read the test. A test you understand is a specification you can trust.
• It reads a file at the project root before starting: CLAUDE.md for Claude Code, AGENTS.md for Codex and others. Whatever you put there shapes every session.
• It will be confidently wrong sometimes, in the same tone as when it is right. The summary is its opinion. The diff and the test run are the facts.

Set Up Your Projects for Learning

Write a short CLAUDE.md in every course project. Beyond the usual commands and rules, add learning rules:

markdownCopy
# CLAUDE.md

Course project: gradient descent from scratch in NumPy.

## Commands
- Tests: `python -m pytest -q`
- Do not add new dependencies without asking.

## How to work with me
- I am learning. Before writing code, explain the approach in 3 bullets and wait.
- After writing code, list the two lines most likely to contain a bug and why.
- Never modify tests to make them pass. If a test seems wrong, say so and stop.
- Prefer plain NumPy over library shortcuts; the point is that I see the math.

These rules cost you a little speed and buy you understanding. Remove the "wait for me" rule on projects where you are past the learning stage.

Delegation That Teaches

Some tasks are ideal to hand to an agent, because the mechanical part is not what you are learning:

• Setting up a project skeleton, a virtual environment, a test runner.
• Writing the plotting code for results you already understand.
• Converting a working notebook cell into a function with a test.
• Explaining an error message and listing the three most likely causes.
• Reading an unfamiliar library and summarizing the two functions you need.

Some tasks you should do yourself first, then ask the agent to review:

• The core algorithm of the module (the gradient update, the split logic, the attention computation).
• Anything the module's deliverable asks you to explain.
• Debugging your own code, at least for twenty minutes, before asking for help. The struggle is where the learning is; the agent is the hint you ask for after.

A good pattern: write it yourself, then ask the agent "review this for bugs and tell me what a senior engineer would change, without rewriting it". You get the feedback of a code review and keep the authorship.

Permissions and Plan Mode

Start every agent in a restricted mode: it may read and propose, and you approve edits and commands. Most tools have a plan mode where the agent explores and writes a plan without changing anything. Use it for any task touching more than one file. Reading a plan is faster than reading a diff, and the plan often shows you an approach you would not have considered.

Never let an agent run destructive commands (deleting directories, force-pushing, resetting git history) without a prompt. If you are unsure whether a command is destructive, ask the agent to explain it before approving.

Verification Habits

Build these until they are automatic:

1. Run the tests yourself after the agent says they pass.
2. Read the list of files it changed. Anything unexpected gets a question.
3. Watch for edits to test files you did not ask for.
4. Ask "what did you assume?" once per task. The answer is often where the bug is.
5. Diff the output of the script against what you expected, not against what the agent said.

The Interview Reality

Interviewers know these tools exist. Many now ask you to use one during a coding round and watch how you work. What they look for is exactly this module: a clear spec, sensible delegation, verification, and the ability to explain every line in the result. A candidate who can do that with an agent is worth more than one who can only do it alone. A candidate who cannot explain what the agent wrote is worth less than either.

Common Mistakes and Bad Instincts

• Prompting until it passes. You get code you cannot explain.
• Skipping the struggle. Twenty minutes of your own debugging before asking.
• No CLAUDE.md. Every session starts with no rules.
• Trusting the summary. Read the diff, run the tests.
• Global permissions. The one time it matters, it deletes the wrong thing.
• Not asking why. The explain-it-to-me prompt is the whole point.

Where to Go Next

• math-for-ml-linear-algebra-that-actually-matters: the next module is a good first place to use the "explain, then I write it" pattern
• software-engineering-fundamentals-for-data-and-ml-projects: tests and structure make agents safer and you faster
• context-and-harness-engineering: later in this path, you will build the systems around agents rather than just use them

What to Practice Next

Create a CLAUDE.md with the learning rules above in your current course project. Then pick one exercise from the math modules: implement it yourself first, ask the agent to review without rewriting, apply the changes you agree with, and write a short note on what you learned from the review. Keep the note; a folder of these becomes an honest record of your progress and a good interview story.