You have used the terminal. You know how to move around a project, list files, and read them. Claude Code is a program you run there, in the same window, pointed at the same project.
You describe what you want in plain English. It reads the files it needs, works out a change, edits them, and tells you what it did.
The difference from a chat window
A chat window is a text machine. You paste in some code, it hands you back some code, and you carry that code across to your editor yourself. Nothing changes on your disk unless you change it.
An skips the carrying. It has access to the folder you started it in. It opens files, reads them, writes to them, and can run commands like your test suite. The conversation looks similar. The reach is not.
Why this matters more than it sounds
Copying code by hand is slow, but it has a hidden benefit: you read every line on the way past. An agent removes that step. If you do not deliberately put the reading back in, nobody has read the code that is now in your project.
What a working session looks like
You are in a project folder. You type a request: add a loading state to the search box. The agent looks around, finds the relevant file, proposes an edit, and applies it. You look at what changed, run the thing, and either accept it or say what is wrong.
Then you do it again. And again. Most real work is twenty small turns, not one big prompt.
Quick check
You ask an agent to rename a function everywhere it is used. What has to be true for that to work?
What it is genuinely good at
- Work that is tedious but mechanical: renames, moving things, wiring up boilerplate.
- Finding where something lives in a codebase you do not know.
- Explaining code you did not write, in the terms you actually asked about.
- Turning a described bug into a reproduction, then into a fix.
What it gets wrong
Being honest about this now saves you a bad week later.
It invents things that do not exist. A function name, a library option, a whole API. It states them with the same calm confidence as the parts it got right — this is called a , and no amount of politeness in your prompt prevents it. Running the code is what catches it.
It is confidently wrong at scale. A human who misunderstands your request writes one wrong function. An agent that misunderstands your request can change eleven files in thirty seconds.
It does not know what you did not tell it. It cannot see the conversation you had with your team, the constraint in your head, or the reason that odd-looking line exists. Silence reads as permission.
It costs money and it costs attention. Long sessions use more of both. The attention is the scarcer one.
The rule for this whole course
Never accept a change you have not looked at. Not once. The moment you start clicking through diffs without reading them, you have stopped being the engineer and started being a spectator with a keyboard.
The habit to build
Say what you want. Read what it did. Say what is wrong. Repeat.
That loop is the entire skill. The rest of this course is just making each step of it faster and less painful — how to give it the right context, how to read a change quickly, and when to stop correcting and start over.
Do I need to know how to code to use it?
Can it break my project?
Try it yourself
One folder, one line changed. Watch where the change actually lands.