Claude Code 101
For anyone who's used an AI chat window before, but is brand new to an AI that can open files, run commands, and make real changes.
You already know how to talk to an AI. This is the next layer: a kind of AI that doesn't just answer questions — it can read a project's real files, edit them, run commands, and ship changes, checking in with you before anything risky. This covers the words and ideas that come with that, assuming no prior experience.
Contents
01 Chat AI vs. Code AI
A normal AI chat window only talks. Ask it about a file and it can guess or describe one — but it can't actually open it.
This kind of tool is different. It can take real actions: open an actual file, change it, run a real command, and check whether that worked — then tell you what it did, not what it thinks probably happened. The industry calls this "agentic."
Concretely, inside Claude's own product line, that's the difference between Claude Chat and Claude Code — same company, same underlying model, but one only talks and the other can act. Whatever specific tool is actually in front of you, that's the split worth understanding.
That's a genuine jump in capability, not just a smarter chatbot. It also means mistakes have real consequences — which is exactly why the rest of this guide exists. Checkpoints, branches, and permission prompts are the safety net that make it safe to let an AI actually do things, instead of just talk about them.
02 The vocabulary of a project
Software projects are organized with a system called version control — an infinite, precise "track changes" for an entire folder, not just one document. These eight words cover most of what you'll hear, roughly in the order they happen.
Short for repository — the project's actual folder of files, plus its entire saved history, bundled together.
- Why it exists
- One place holds both the current version and every version that ever existed.
- Where you'll see it
- "Clone the repo" just means "get a copy of the project onto your computer."
A website that hosts a copy of your repo online — not the repo itself, just the most common place to keep one.
- Why it exists
- Backup (your work survives even if one laptop doesn't) and collaboration (everyone pushes to, and pulls from, the same shared copy).
- Where you'll see it
- "Push" sends your local commits up to GitHub; "pull" brings down everyone else's. GitLab and Bitbucket do the same job — GitHub is just the most common one.
A separate, parallel copy of the project you can change freely without touching the original.
- Why it exists
- So someone can try something risky or unfinished without breaking the version everyone else relies on.
- Where you'll see it
- Two people can work on two different features at once, each on their own branch, with zero risk of colliding.
A saved checkpoint: a snapshot of every file at one moment, with a short note describing what changed.
- Why it exists
- It creates a permanent, searchable history — nothing is ever silently lost.
- Where you'll see it
- "Let's commit this" means "let's save a checkpoint before going further."
A formal request to merge one branch into another — a proposal, sitting and waiting for a look-over.
- Why it exists
- A review checkpoint before a change goes live, so a second set of eyes catches problems first.
- Where you'll see it
- "It's open as a PR" means the change is ready and waiting on approval — not live yet.
Combining a branch's changes back into another branch, usually the main one.
- Why it exists
- Work that happened safely off to the side eventually needs to rejoin the main version.
- Where you'll see it
- "That's merged now" means the change is officially part of the project, not sitting off to the side anymore.
The one branch everyone treats as "the real version" — often what's actually live for customers.
- Why it exists
- A single agreed-on source of truth, instead of several slightly different "real" versions floating around.
- Where you'll see it
- "It's live on main" means it's the real, current version — not a draft.
Taking a version of the project and making it the actual, live thing the outside world sees.
- Why it exists
- It separates "this is done" from "the public can see it" — those are two different moments.
- Where you'll see it
- A change can be merged into main and still not be live yet, until someone (or something) deploys it.
03 Where the work actually happens
The AI is running right on your own computer, using your files and your internet connection.
- Where you'll see it
- The default way most of these tools run — fast, but tied to that one machine being on.
Instead of your computer, the job runs on the AI provider's own computers.
- Why it exists
- Long jobs keep running even after you close your laptop.
Lets you check in on a session running somewhere else — your computer or the cloud — from a different device.
- Where you'll see it
- Glancing at a job's progress from your phone, or nudging it in a new direction without sitting at a desk.
A plain text window where you type commands instead of clicking buttons.
- Why it matters here
- It looks intimidating, but it's just another way of talking to the computer. Some of these tools run inside one; others run as an ordinary chat window like this.
Local vs. cloud, side by side
| Local | Cloud | |
|---|---|---|
| Speed | Fastest — no network hop | A short delay getting started |
| Keeps going if you close your laptop | No | Yes |
| Works without internet | Mostly | No |
| Typical cost | Part of normal use | Often counted separately |
| Best for | Quick, everyday work | Long jobs, or work you want to walk away from |
Either way, once work is pushed to GitHub, it's safe even if the one machine that made it isn't.
04 How it organizes big jobs
A copy of the AI sent off to handle one piece of a bigger job, then report back.
- Why it exists
- Keeps a big, messy task — "search this whole project for X" — from cluttering up the main conversation. The helper does the digging; you just get the answer.
- How it happens
- Usually on its own — the AI judges when a job is big enough to hand off. Nobody has to click anything for that.
- A special kind: fork
- A helper that also carries the whole conversation with it, instead of starting from zero.
A second checked-out copy of a project's files on disk, tied to the same repo.
- Why it exists
- Lets more than one session have its own copy of the files checked out at once, without overwriting each other.
- Do you set it up?
- Almost never — the AI creates one on its own, only when two sessions actually need separate copies.
05 Staying in control
The AI checking with you before doing anything risky or hard to undo.
Things like typing in a password or payment details, or permanently deleting something. The AI simply won't — it'll ask you to do that part yourself.
Anything hard to undo or visible to other people — sending a message, publishing something, buying something, deleting a file. You'll always get a plain "okay to do this?" first.
Everyday, reversible stuff — reading a file, writing a draft, running a harmless command. No prompt, because nothing risky happened.
Rolling back to an earlier checkpoint if something goes sideways.
- Why it exists
- Because every step is checkpointed (see: commit), almost nothing is truly one-way — which is what makes it safe to experiment.
06 Tokens, cost, and speed
Every AI model — chat or agentic — runs on tokens: small chunks of text it reads or writes. Every message, every file it opens, every reply costs some. Longer conversations and bigger files cost more.
A few things that keep it efficient:
- Big searches happen off to the side. Instead of dumping a giant file into the main conversation, a well-built tool sends a helper to dig through it and bring back just the summary. This is usually automatic — the AI judges when a job is big enough to hand off, see section 04 — so nobody has to request it for it to happen.
- New topic, new conversation. Piling unrelated work onto one endless thread costs more and gets muddier than starting fresh.
07 Extending what it can do
A saved recipe for one specific, repeatable job.
- Why it exists
- Repeatable work should be reliable and consistent, not reinvented from scratch every time.
- Where you'll see it
- A team builds one for something they do every week — "publish this week's report" — and just triggers it by name after that.
A bigger version of the helper idea — a job split across many helpers working at once.
A job that runs on its own, on a timer, without a person kicking it off.
- Where you'll see it
- Recurring work — "check this every Monday morning" — that shouldn't depend on someone remembering to ask.
A plug-in that links the AI to an outside tool — a chat app, a project tracker, accounting software, document storage, and so on.
- Why it exists
- Instead of copy-pasting information back and forth, the AI can look things up — or take action — directly in the tool where it already lives.
- Where you'll see it
- Often grouped loosely by department: project-management tools, finance tools, communication tools, tools that search across a company's other systems. Names vary by product, and most need a one-time sign-in first.
08 Reading the screen
Once the words above click, the screen itself starts making sense. Here's what you're actually looking at.
Sessions. A session is one ongoing thread of work with the AI — tied to a specific project, remembering its own files, history, and permissions. It's not quite "a chat": closing and reopening it doesn't lose your place, and it can keep working on its own timeline.
A stand-in example — your own session names will replace these. The sidebar usually lists one session per project or task; the same area typically holds Skills, Workflows, Routines, and Connectors too — the ideas from section 07.
The status line. Many of these tools also show a small status line somewhere in the window, often formatted something like this:
A stand-in example — your own account, project, and branch names will replace these.
It tells you three things at a glance: who is signed in, what project you're in, and where — which branch — you're currently on. Once you're juggling more than one project, this is how you confirm you're actually looking at the one you think you are, before you make a change. The exact spot it shows up varies by tool and by view, but the three pieces of information are always the same idea.
09 Quick reference
A cheat sheet for the words above, in one scannable list.
| Term | One-line meaning |
|---|---|
| repo | The project's folder of files, plus its full saved history. |
| GitHub | A website that hosts a copy of your repo online, for backup and collaboration. |
| branch | A parallel copy of the project you can change without touching the original. |
| commit | A saved checkpoint of every file at one moment. |
| pull request | A proposed merge, waiting for review before it's accepted. |
| merge | Combining a branch's changes back into another branch. |
| main / production | The one branch treated as the real, live version. |
| deploy / ship | Making a change the real, live version everyone else sees. |
| local | Running on your own computer. |
| cloud | Running on the provider's computers instead of yours. |
| remote control | Checking in on a session running elsewhere, from a different device. |
| SSH | An old general tool for logging into a faraway computer from a terminal. |
| terminal / CLI | A plain text window where you type commands instead of clicking. |
| helper / subagent | A copy of the AI sent to handle one piece of a bigger job. |
| fork | A helper that also carries the full conversation with it. |
| worktree | A second checked-out copy of a project, so two sessions can't collide. |
| permission prompt | The AI checking with you before anything risky or hard to undo. |
| undo / rewind | Rolling back to an earlier checkpoint. |
| token | The small chunk of text an AI reads or writes — its basic unit of "cost." |
| context | Everything the AI currently "remembers" in the conversation so far. |
| session | One ongoing thread of work with the AI, tied to a project. |
| sidebar | The list of your sessions, usually alongside Skills, Workflows, Routines, and Connectors. |
| skill | A saved recipe for one specific, repeatable job. |
| workflow | A big job split across many helpers working at once. |
| routine | A job that runs on its own, on a timer. |
| connector | A plug-in linking the AI to an outside tool. |