Claude Code Glossary

This course goes from your first terminal window to building your own tooling, so the vocabulary widens as you go. Rather than carrying definitions in your head, search this page whenever a word stops you.

Terms the course teaches are defined the way the course uses them. Terms you will meet outside the course are here too, because the moment you start reading documentation or asking other people for help, they turn up.

Where two terms get confused with each other, the entry says so plainly, because those pairs are where people actually get stuck.

A

Accept-edits
A permission mode where Claude changes files without stopping to ask you each time. It also runs a short list of ordinary housekeeping commands inside the folder you are working in, covering making a folder, moving a file, copying one and deleting one. Anything beyond that list still stops and asks. It is commonly misread as approve everything, and it is not. See also Auto mode and Permission mode.

Accessibility
Building a page so people using screen readers, keyboards instead of mice, or reduced motion settings can still use it properly. It shows up in this course as semantic HTML, accessible labels on interactive elements, and respecting a visitor's motion preferences. See also Semantic HTML and WCAG.

Additional directories
Folders you add alongside the one you started Claude in, so files inside them follow the same permission rules as your original folder. You add one with a flag at launch, with a slash command mid session, or with a line in a settings file so it sticks. The flag and the slash command also load that folder's own configuration, while the settings entry gives file access and nothing more. See also Working directory.

Agent
A program that can carry a job from one end to the other on its own, deciding its own next step rather than waiting for you to direct each one. A chatbot hands you text and leaves the work to you. An agent reads your intent, plans an approach, and runs the whole thing across your file system. See also Agentic loop.

Agentic coding
Describing what you want at a higher level and having Claude Code implement it autonomously, then reviewing the decisions it made. Instead of writing every function yourself, you direct an agent that writes them for you. It is also called orchestration, and both names describe the same way of working.

Agentic loop
The repeating cycle Claude moves through on every task: read the project, plan the approach, execute the plan, adapt when the project pushes back, and verify by stating what got built. Execute and adapt braid into each other every time the work hits a constraint. Knowing the loop gives you somewhere to stand when something surprising happens, because you can ask which step it is on.

Agentic technical debt
The mess that builds up when quick decisions keep piling on quick decisions across a long run of sessions. Ordinary technical debt sits still. This kind compounds, because a fresh session with no reliable record of earlier decisions re-derives them and drifts a little further each time. See also Drift and Handoff.

AI Engineer
The role the industry is naming for someone who directs intelligent tools rather than typing every line themselves. The work is architecture, edge cases and trade-offs, with the implementation handled by tools they are directing. It sits on two skills, agentic coding and context engineering.

Allow list
The list in your settings file naming things Claude may do without asking you. It is checked last, after deny and ask, so a broader ask rule sitting above it wins every time. An allow rule you regret takes about ten seconds to narrow or delete, which makes it the most forgiving of the three lists. See also Ask list and Deny list.

API
A channel one program uses to talk straight to another program, with nobody clicking anything in between. In the narrower sense this course uses when talking about money, going in through Claude's API is a second way of paying for the same Claude, priced per amount of text rather than as a fixed monthly plan. It is not a different tool, only a different way of paying for it.

Ask list
The list in your settings file naming things Claude must stop and check with you about. It is checked after deny and before allow. An ask rule you regret prompts you forever, and there is no not-this-time option on it, so write these deliberately. See also Allow list and Deny list.

Auto mode
A permission mode where Claude runs commands on its own as well as changing files, with a separate check running behind the scenes on each command before it goes. That check blocks anything going further than you asked, anything aimed at infrastructure it does not recognise, and anything that looks like it came from content Claude read rather than from you. It reduces prompts and does not guarantee safety. The difference from accept-edits is the difference between Claude writing and Claude running.

B

Backend
The program running somewhere other than the visitor's browser, doing the remembering, the checking and the charging. A shop knowing who you are and holding what you put in your basket last week is backend work. See also Frontend and Full-stack, and note that frontend is what the browser draws while backend is what runs behind it.

Blast radius
How much damage one wrong move could cause. A large blast radius, like anything touching secrets, money or user data, is exactly when you want a human hand on each step rather than a mode that moves quickly.

Boilerplate
The standard starter code that ships with a framework. This course skips it on the portfolio build so that every line Claude writes stays readable.

Branch
A second version of a project that grows out of the real one, so you can try something without touching what already works. If you hate the result you throw the branch away and nothing is harmed. The real one is usually called main.

Breakpoint
A marker you set in code so a debugger pauses there and lets you inspect what is happening. Worth knowing the word, though this course teaches debugging by describing symptoms in plain English instead. Not to be confused with a CSS breakpoint, which is a screen width at which a layout changes.

Browser
The program that draws web pages, like Chrome, Safari or Firefox. It reads the HTML, CSS and JavaScript a site sends and turns them into what you see.

Bug
The thing that is wrong in the code. The hours spent finding out which thing it is are called debugging, so the bug is the mistake and debugging is the hunt.

Build step
A preparation stage some sites need before going live, where the files a developer wrote get assembled into the final files a browser uses. A plain HTML, CSS and JavaScript site needs none, because what you wrote is exactly what the world receives. Deploys often fail because the host assumed a build step existed and went looking for instructions that were never there.

Bypass permissions
The mode that turns off Claude Code's ordinary permission checks. It carries a formal name with the word dangerously in it and an honest nickname, YOLO mode. On a normal personal plan it does not even appear in the mode list until you go into settings and switch it on yourself, which tells you something worth keeping. Turning the guardrails off does not only trust Claude, it trusts everything Claude reads.

C

Cache
A kept copy of something, held so it does not have to be fetched or read again. Two kinds matter in this course. Your browser caches CSS and JavaScript files, which is why a change you made can refuse to show up. Claude keeps a copy of the conversation, which is what makes most turns cheaper. See also Hard refresh and Caching discount.

Cache busting
Adding a version string to file addresses so the browser treats every update as a new file and always loads the current version. It saves you from hard refreshing constantly while you work.

Caching discount
The reduced price you pay when Claude re-reads a conversation it has already kept a copy of, roughly a tenth of the full price. A timer governs it, and every turn you take resets that timer. On a Claude subscription the timer is an hour, so a phone call or a careful read of a long change costs you nothing. On an API key or a cloud platform the default is five minutes, which is where the smaller number people repeat comes from.

CI/CD
Continuous integration and continuous delivery, the practice of automatically testing and deploying code whenever it changes. You meet a small version of it in this course when connecting a repository to a host means every push goes live on its own.

Claude
The model, meaning the brain doing the thinking. Claude comes in several weights, and you pick which one is loaded for the job in front of you. See also Model and Claude Code.

Claude Code
The tool you work in, which arrived in February 2025. It reads your project, plans, writes files, runs commands and fixes its own errors, on your machine, in the folder you point it at. Claude Code and Claude sound like the same family and they are two different things: the tool is the workshop, the model is the brain you load into it.

CLAUDE.md
A plain text file you keep in your project folder telling Claude how you want it to work, things like preferring plain web files over frameworks on small builds. Claude reads it before planning anything, which is what lets it make decisions that fit your project instead of guessing. It is read once when the session starts and held from then on, so edits you make mid session load on the next clear, compact or restart.

Clear
The command that wipes the conversation so the next task starts with nothing behind it. Your files are untouched and saved on disk. It is the single command that saves the most money, because everything still in the conversation is re-read and paid for on every turn. See also Compact.

CLI
Command-line interface, a tool you use by typing commands rather than clicking buttons. That is exactly why Claude can drive one for you. The GitHub CLI and the Vercel CLI both turn up in this course.

Client
The side of a system that asks for something, usually the browser on a visitor's machine. The server is the side that answers. See also Server.

Clone
Taking your own copy of a repository from somewhere like GitHub onto your machine, history included. A cloned project can carry its own settings and instructions, which is worth remembering before you let Claude loose inside one.

Codebase
A folder of files that remembers everything that has ever happened to it. Handing somebody a codebase shows them not only what you built but how you got there.

Command line
Another name for the terminal, or more precisely for the way you interact with it by typing commands. See also Terminal, Console and Shell, which are four words people use loosely for roughly the same thing.

Commit
One saved moment in a project's history, holding what changed and a short note from you saying what you did. It lives on your own machine until you push it. You can commit ten times before you push once, so commit is saving locally and push is sharing.

Compact
The command that squeezes the conversation so far into a short summary and keeps working from that summary. Both compact and clear free up space. Compact is crushing the trash down so it takes less room in the can, and clear is carrying the bag out to the curb. A summary quietly drops details you did not know you needed, so keeping what matters in a document you control is the safer habit. You can steer it by adding an instruction after the command.

Connector
A way of giving Claude access to an outside service through the desktop app, set up once with a search and a sign-in rather than anything installed. Connecting your host, for example, lets Claude check deployments and read deploy logs in future sessions.

Console
Two meanings, and they are worth keeping apart. Loosely, another word for the terminal. Specifically in a browser, the panel where a page reports its problems, which is where you copy red error text from when something breaks.

Container
A sealed-off environment where a program runs isolated from the rest of the machine, so a mistake inside it cannot reach anything that matters. It is why even the engineers who build these tools only turn the guardrails off inside one.

Context engineering
Setting up your project so Claude understands it deeply, through instruction files, rules, memory that carries between sessions, and connections to outside tools. It is the difference between the developer who burns an evening on unfocused sessions and the one who runs a targeted workflow and closes the laptop in time for dinner. It goes considerably deeper than writing better prompts.

Context window
The space holding everything in one conversation, every sentence you typed, every file Claude read, every answer it gave. It has a size, and when it fills, the oldest part starts falling out of the back. Its size depends partly on which model you are using and partly on your plan.

CSS
The file holding how a page looks, meaning the colours, the spacing, the size of the headline against the small print. Keeping it separate from the HTML is what lets you change every colour on a site without touching a word of what it says. Also called a style sheet.

curl
A command-line program that fetches something from the internet. The install command in this course uses it to download the installer script and pipe it straight into the shell to run, which is the standard download-and-run pattern most modern tools use.

Cursor
An AI code editor, useful when you have a file open and want fast inline changes on it. It sits in a different place from Claude Code, which is built for work spanning many files and running autonomously.

D

Database
An organised store of information a program writes to and reads back. It is how a site remembers what you put in your basket last week.

Debugging
The hunt for what is wrong. The old version meant reading an error, searching it, finding a forum post from four years ago and trying three fixes. The version this course teaches is describing what you expected and what actually happened, and letting Claude find the gap between them. You never have to know what is broken before you ask.

Dependency
A piece of someone else's code your project relies on. Every dependency makes the project heavier, adds a maintenance obligation, and is one more thing that can break when the library changes or stops being maintained. Adding one for something your existing tools already handle is a pattern worth catching every time.

Deny list
The list in your settings file naming things Claude may never do. It is checked first, before ask and allow, and it cannot be overridden by anything, from anywhere: not by a rule in another file, not by a flag on the command line, and not by you in the moment you need the thing. A broad deny also cannot carry exceptions, so a narrower allow underneath it will not create one.

Deployment
Putting your project somewhere always on and always reachable, so anyone with the link can open it. Version control can undo a local file change. It cannot undo a deployment, which is why deploying sits outside the work you hand over and walk away from.

Diff
The old version of a file sitting beside the new one, so you can read exactly what is about to change before you keep it. The desktop app shows you one before anything moves on your disk, with accept and reject on each change.

Directory
Another word for a folder. Developers tend to say directory, and the two are used interchangeably throughout this course.

DNS
The system that turns a domain name people can remember into the address a machine actually connects to. You meet it if you point a domain you bought at a site you deployed.

DOM
The browser's live model of the page, built from your HTML, which JavaScript reads and changes as someone interacts with it.

Domain
The name people type to reach your site. Worth keeping distinct from an email address on a similar-looking name, because they are not the same thing and one is not a substitute for the other.

Dont-ask
A permission mode that never waits for an answer. It runs only tools you already approved and denies everything else that would have needed a prompt. You will not find it in the app or by pressing keys in a terminal. You reach it by naming it on the launch command or writing it into a settings file, and it exists for scripts that run with nobody in the room.

Drift
The quiet failure where a long run of sessions slowly starts contradicting decisions already settled, without anything announcing it. Session one feels like magic, by session three the approach has changed, and by session seven there are two versions of the same feature. Better prompting does not fix it and a bigger context window does not either, because long context is not the same as good context. See also Handoff.

E

Effort level
The setting controlling how hard Claude thinks before it answers, reached with a slash command or its own menu. The ladder runs low, medium, high, xhigh, max, and ultracode at the top, and the names do not line up with intuition, because high sits in the middle rather than near the top. Low is a quick sketch and max is an architectural blueprint, so match it to how costly the decision is to reverse.

Environment variable
A named value your machine or your project holds outside the code itself, commonly used for keys and settings that differ between machines. They usually live in a .env file. See also env file.

env file
A file named .env holding your API keys and other secrets, sitting in your project folder exactly where you are working. Claude reads files inside your working folder without any approval box appearing, which is deliberate and would otherwise make the tool unusable. It also means an empty deny list is not a decision you get to make about your keys, which is why the starter settings file blocks reading and editing it.

F

Fetch
Pulling down the latest history from a remote repository without merging it into what you have. Its cousin, pull, fetches and merges in one move.

FLIP
An animation technique standing for First, Last, Invert, Play. The code measures where every element starts, applies the change, measures where everything lands, then plays the journey between those two positions as one smooth motion. You do not need to hold onto how it works, only to notice when a page feels better and say so.

Folder
The place files sit together on your computer. It matters more than tidiness here, because whichever folder your terminal is in when you start Claude Code is the only place Claude Code can write. The folder is a fence, and you are the one who puts it up.

Fork
Leaving the current conversation exactly as it is and starting a second one from an earlier point, so you can try a different approach without losing the one you have. Both then sit in your sidebar. It is the opposite of rewind, which takes this conversation back rather than branching a new one.

Framework
A pre-built starter kit like React or Vue that comes with its own conventions and its own way of structuring a project. A library is a tool you call when you want it. A framework is a structure you build inside, which is the practical difference between the two.

Frontend
The part a visitor's browser draws, built from HTML, CSS and JavaScript. Everything else, the remembering and the checking and the charging, happens on the backend.

Full-stack
A project that has both the page you see and the program running behind it. Each of the pieces behind it, the database, the log-in and the payment handling, is big enough to be somebody's whole job, which is why a first project deliberately skips them.

Function calling
How a model asks to use a tool, by returning a structured request the surrounding program carries out and hands the result back. It is the mechanism underneath tool use.

G

Git
The program on your own machine that writes down every change ever made to a project. It stores the difference between what a file was and what it became, plus your note about it, so you can rewind, branch and share. It lives inside your project folder as thousands of tiny hidden files it rewrites constantly, which is exactly why a project folder should not sit inside a syncing cloud drive.

Git Bash
A component that comes with Git for Windows. Claude Code uses it internally for certain file operations on Windows, and without it the installation either fails outright or the tool cannot function properly afterwards.

gitignore
A file listing the things you tell git to skip, so they never end up in your snapshots or online. Machine-local settings, secret keys in env files, and clutter folders belong in it, because none of them are your work.

GitHub
A website holding a copy of your project and its history online, so it can be shared, backed up and deployed. Git and GitHub are two different things and one is not short for the other: git is the diary-keeper on your own machine, GitHub is the website that holds a copy. You can use git for years and never open GitHub once.

GitHub Copilot
An AI tool that sits inside your editor and suggests the next line as you type, appearing as grey ghost text you accept with a tab. It works line by line inside the file you are in, so it does not create files, run tests or fix its own errors.

GitHub Pages
A free hosting option for static sites, run by GitHub. It works similarly to the host used in this course and the concepts transfer.

H

Haiku
The lightest and fastest of Claude's models, and the right pick for simple repetitive passes. Paying deep-model prices for work like that is where the waste hides.

Hallucination
When a model states something confidently that is not true. It is why you never take Claude's word for the state of the world and check from outside instead. See also Trust but verify.

Handoff
Ending a session by asking Claude to write a short file covering what you were doing, what worked, what did not, the decisions you settled and why, and what comes next. Then you clear, start fresh, and point the new session at just that file. It is the deliberate alternative to letting a long session drift or letting it summarise itself when it fills.

Hard refresh
Forcing the browser to skip its saved copies and load the current files, with Cmd Shift R on a Mac or Ctrl Shift R on Windows and Linux. It is the fix when you have changed CSS, checked the file, and the page still shows the old design.

Hero section
The big intro area at the top of a web page, the part you see before scrolling.

Hook
A shell command that runs automatically in response to an event, so the output of a session stays consistent without you policing it line by line. In the loop, hooks make the execute step more reliable.

Host
A computer that is always on and always reachable, lent to you so your site can be visited. Your laptop is not one, which is the whole reason deploying exists.

Hosting
The service of providing that always-on machine. Vercel, Netlify and GitHub Pages all do it free for personal projects.

HTML
The file holding what a page says, meaning every word and every box you can point at. It is one of the three files every website is built from, alongside CSS for how it looks and JavaScript for what it does when you touch it.

HTTP and HTTPS
The rules browsers and servers use to talk to each other. HTTPS is the encrypted version and is the normal choice now. Opening a page straight from a file on your disk rather than through one of these is why you sometimes see a browser complaint that has nothing to do with your code.

I

IDE
An integrated development environment, meaning a code editor with the surrounding tooling built in. Visual Studio Code and the JetBrains editors are the ones Claude Code officially supports through an extension or plugin.

Inference
A model producing an answer from an input. What you pay for, measured in tokens, is inference.

innerHTML
A way of dropping raw HTML content into a page. It can be risky when the content is not trusted, which is why a security check flags it, and why Claude switched approach mid-build in the opening demo. See also textContent.

Integration test
A test checking that several parts work correctly together, rather than one piece in isolation. See also Unit test.

IntersectionObserver
A browser feature that watches when an element scrolls into view. It is what powers navigation links highlighting as you move down a page. You do not need to remember how it works, only that such a thing exists.

J

JavaScript
The file holding what a page does when you touch it. Clicking a filter button and watching seven projects become two is JavaScript, because no word and no colour on the page changed.

JSON
A plain text format for structured data, used for configuration files including Claude Code's own settings file. Commas matter in it, and a missing or extra one is the single most common mistake people make when editing by hand.

K

Kitchen sink session
The community's name for mixing unrelated tasks into one conversation until it collapses under its own weight. Performance degrades as the context fills with things irrelevant to what you are doing now, and you pay to carry all of it on every turn. One mission per session is the habit that prevents it.

L

Latency
The delay between asking for something and getting it back.

Library
A reusable chunk of someone else's code you call when you want it. A framework, by contrast, is a structure you build inside. See also Dependency.

Lightbox
The larger view that opens over a dimmed page, the way clicking a photo in a gallery opens it full size.

Linting
Automatically checking code for mistakes and style problems before anyone runs it.

LLM
A large language model, the kind of model Claude is. It reads text and produces text, and it has no memory of its own between turns, which is why the whole conversation is re-read every time.

localhost
Your own machine, addressed as though it were a website. When Claude starts a small local server to check its work, the page it opens is on localhost.

localStorage
The browser's own small storage drawer, used for keeping data between visits. It is what makes tasks still be there after you close the tab, and what makes a dark mode choice stick.

M

Main
The name usually given to the real branch of a project, the one that counts. Experiments grow out of it on their own branches.

Manual mode
The careful default permission mode, which asks you before it changes a file and before it runs a command, so nothing happens without your yes. The app and the editor extensions label it Manual, and inside a settings file the same mode is written as default. One mode, two names.

Markdown
A plain text format that uses simple marks for headings, lists and emphasis. Most of the files in this course, including this one, are written in it.

MCP
A way of connecting Claude to an outside tool or data source. These connections can use space in the conversation even when you are not using them, so if a plain command does the same job, prefer the command and keep the room for the work.

Merge
Bringing the changes from one branch into another. When two versions changed the same lines, you get a merge conflict, which you resolve by deciding what the result should be rather than discarding either side blindly.

Meta description
A short description of a page, written into the HTML, that search engines and link previews read. It is one of the tags you add so a link looks right when someone drops it into a chat.

Mobile-first CSS
Designing for the phone screen first, then scaling up to tablet and desktop. Naming it as a constraint up front is what makes Claude fold it into every file it creates.

Model
The brain doing the thinking, as opposed to the tool you work in. The lineup runs from the deepest and most expensive down to the fast and cheap, and you switch between them mid session. Deep models suit planning and hard reasoning, faster ones suit carrying out a plan you have already settled, and the lightest suits simple repetitive passes. Switching mid session makes Claude re-read the conversation for the new model, so the caching discount rebuilds from scratch each time.

Multimodal
A model that handles more than text, for example reading images. It is what lets Claude look at screenshots you attach, or at images you drop into a folder and ask it to place.

N

Netlify
A hosting service for static sites, an alternative to the one used in this course. The concepts transfer.

Node.js
The JavaScript runtime that lets your computer run programs written in JavaScript, including Claude Code. Checking its version is one of the two commands that tell you whether your machine is ready.

npm
The package manager that installs and updates JavaScript tools on your system. It comes with Node.js. Installing Claude Code through npm is deprecated and no longer recommended, and if you have an old npm install it can conflict with the native one.

O

Open Graph
A set of tags you add to a page so that when someone drops the link into a chat or a social post, the preview shows the title, description and image you chose rather than whatever the platform guesses.

Open source
Code published so anyone can read, use and contribute to it.

Opus
The most capable of Claude's models, and the right pick for planning and hard reasoning where getting the approach right matters most.

Orchestration
Directing the work, judging the quality, and making the decisions that matter, while Claude handles the typing. It is the same thing as agentic coding under a second name, and it is the habit that transfers to every project you work on afterwards.

Origin
The default name for the remote copy of your repository, usually the one on GitHub.

P

Package
A reusable chunk of code from someone else, published so you can install it into your project.

Package manager
A tool that installs and updates software for you. npm handles JavaScript packages, and Homebrew on a Mac, WinGet on Windows and apt inside Linux handle programs on your machine.

PATH
The list of folders your shell searches whenever you type a command. When you type a command and get command not found, it usually means the program installed correctly and its folder is not on that list. Adding one line to your shell configuration file teaches your shell where to look.

Payment processing
Taking money from a card, handled by a company in the middle so you never touch the card details yourself.

Permission mode
The setting deciding how much Claude checks with you before it acts. Four of them sit on a line from most careful to least: manual, accept-edits, auto, and bypass permissions. The gap between accept-edits and auto is the one to hold, because everything left of it is Claude writing and everything right of it is Claude running. Plan mode does not sit on that line at all, because it answers when the work happens rather than how much freedom Claude has.

Plan mode
The mode where Claude reads your files and runs commands to look around, then writes you a plan without touching your source. There is nothing to undo, because nothing was done. Approving the plan is what unblocks the editing, and the mode you land in afterwards is one of the four freedom levels. It gets misjudged as slow, and the wait at the front is what buys you the freedom to walk away from everything after it.

Port
A numbered channel on a machine that a program listens on. A local server usually announces the port it is running on, and that number appears in the localhost address.

Prompt
What you type to describe what you want. Prompt quality is not only about cleaner code, it is about budget too, because a vague prompt might take four rounds where a specific one lands on the first try.

Prompt injection
Instructions hidden inside content Claude reads, which Claude cannot always tell apart from instructions from you. If you clone someone else's project and their notes file has a hidden line telling Claude to do something, Claude might follow it with whatever permissions you have handed over. It is the second reason turning off guardrails is riskier than it looks.

Pull
Bringing the latest changes down from a remote repository into your own copy.

Pull request
A screen laying two versions side by side, every line that is about to change, before any of it becomes real. On a team, somebody else reads it and says yes. Working alone, it makes you actually read your own work before it goes live, which is a different thing from glancing at it while you write it. Not to be confused with a ticket: a ticket asks for work, a pull request offers work that is already finished.

Push
Uploading your saved snapshots to GitHub. Commit is saving locally and push is sharing, and you can commit ten times before you push once.

R

RAG
Retrieval augmented generation, meaning giving a model relevant documents to read at the moment it answers, rather than relying on what it already knows.

Rate limit
A cap on how much you can use in a window. Hitting one is a signal about the size of your plan rather than a sign you did something wrong. If you ever run Claude Code in an automated loop, rate-limit errors can look like generic failures and trigger blind retries, so handle them explicitly.

README
A file explaining what a project is and how to use it, usually the first thing someone opens.

Regex
A pattern for matching text, used for things like checking that an email address is shaped correctly.

Remote
A copy of your repository living somewhere other than your machine, usually on GitHub.

Repository
A project folder that git is tracking, history included. Often shortened to repo.

Responsive
A page that adapts to the screen it is on, so the layout works from a narrow phone up to a large desktop without horizontal scrolling.

Reversibility
Whether something can be undone. It is the more useful question than permissions, because the permission prompt is guarding the moment right before a change becomes irreversible. Version control covers local file changes. It does not undo a deployment, a secret sent somewhere else, a change to external data, or a message sent to a user.

Rewind
Going back to an earlier point in the session, opened with Escape twice on an empty input line or with a slash command. Claude saves the state of your files before each thing you ask, so every prompt in the list is somewhere you can stand. It only tracks files Claude edited through its own editing tools, and it is not version control. See also Fork, which branches instead of going back.

Runtime
The program that runs code written in a particular language. Node.js is the runtime for JavaScript outside a browser.

S

Sandbox
An isolated environment where a program can run without reaching anything that matters. See also Container.

Semantic HTML
Using tags like header, nav and article that describe what each part of a page is, instead of generic divs everywhere. It matters for accessibility, because assistive technology reads the structure.

SEO
Search engine optimisation, the work of making a page findable. In this course it turns up as the tags you add so a link previews correctly and a search engine reads the right description.

Server
A machine that answers requests. A local one is a small program serving your files to your browser the way a real website would, which is why Claude sometimes starts one to check its own work.

Session contract
A short page you write before the work starts, naming the mission, the boundaries, and the evidence that decides whether the work is complete. It pairs with a handoff, which is written at the end.

settings.json
The file holding your permission rules. Rules for one project live in a .claude folder inside that project, and rules you want everywhere live in a .claude folder in your home directory. Both files carry the same name.

settings.local.json
The file Claude Code writes to when you click Always allow on a command. It sits in a .claude folder at the top of your repository, applies to every future session anywhere in that repository, and Claude Code adds it to git's ignore list the first time it saves there so it never leaves your machine.

Shell
The program that interprets what you type in the terminal, commonly Bash or Z shell. It reads a small configuration file every time you open a new terminal window, which is the file you add a PATH line to. See also Terminal, Console and Command line.

Side chat
A conversation that can read the main conversation but never adds anything back into it. Ask the side question, close it, and the thread you are protecting carries on as though you never left.

Skill
A packaged set of instructions for a particular kind of task. Claude Code ships with some built in and pulls the right one in on its own, which is why a design request can load a front-end design skill before writing any code.

Slash command
A command you type starting with a forward slash, which operates the tool rather than sending a message to Claude. Typing the slash on its own brings up the whole list.

Snapshot
One saved state of your project, the thing a commit creates. The word turns up whenever version control is being described in plain language.

Sonnet
Claude's balanced model, sitting between the deepest and the lightest.

Stack trace
The long block of red text explaining where code broke. Worth knowing the term, though this course teaches you to hand the error back rather than read it line by line.

Static site
A site made only of files a browser can use directly, with no build step and no program running behind it. The portfolio built in this course is one, which is why deploying it needs almost no configuration.

Style sheet
Another name for the CSS file.

Subagent
A smaller helper Claude sends off to do a piece of work while the main conversation carries on, letting several parts of a job happen at once. Helpers inherit the expensive model unless you tell them otherwise, and setting a cheaper one for them is among the highest-value adjustments you can make.

System prompt
The standing instructions a model is given before your conversation starts, shaping how it behaves throughout.

T

Temperature
A setting controlling how varied a model's output is, with lower values producing more predictable answers.

Terminal
The window where you type an instruction, press enter, and the computer does it. It holds no special power over your machine, because whatever you type is checked by the same permission system as anything you double-click. What it gives you is reach, because it can run every program on the computer rather than only the ones with icons, and join one straight into the next. See also Console, Command line and Shell, which people use loosely for the same thing.

textContent
A safer way to put plain text into a page than innerHTML, because it does not interpret the content as markup.

Ticket
A written request for work, recorded somewhere with a number so it cannot get lost. A ticket asks for work and a pull request offers work that is already finished, which is the difference between the two tabs you see on GitHub.

Token
A small chunk of text, roughly a word or a piece of one. Everything you type and everything Claude writes back is counted this way, and it is how usage is measured and billed. Because the model re-reads the whole conversation every turn, a bigger conversation costs more on every single turn.

Tool use
A model calling an outside tool rather than answering from what it knows, then using the result. Reading a file, running a command and opening a browser are all tool use.

Trust but verify
The instinct of trusting the everyday work while checking the decisions that hold the structure together. Claude is reliable on project structure, standard framework patterns and common configurations, and deserves closer attention on edge cases, security-sensitive logic and integrations with outside services. It also means never taking Claude's word for the state of the world, because a model that is drifting reports success just as confidently as one that is right.

Twitter Card
Tags that control how a link looks when it is shared, alongside Open Graph.

U

Unit test
A test checking one small piece of code in isolation. See also Integration test.

URL
The address of a page on the internet.

User authentication
The log-in, meaning the part of a system that knows who someone is.

V

Vercel
The hosting service used in this course, free for personal projects. Connecting a repository to it means every push deploys on its own.

Version control
Keeping a saved history of your project so you can see what changed, go back, and share. It is what makes work safe to move quickly on, because anything Claude changed can be read in a diff and put back with one command. Git is the tool that provides it.

W

Warp
The terminal used throughout this course. It runs exactly what your own terminal runs, so nothing you learn is specific to it. What it adds is that most of it can be done by clicking, including moving between folders, which means fewer commands to carry in your head.

WCAG
The accessibility guidelines web work is measured against. AA is the level commonly aimed for, including for text contrast against a background.

WinGet
The package manager built into modern versions of Windows. It can install Claude Code, and it does not handle automatic updates, so you would upgrade manually.

Windsurf
An AI code editor sitting between an editor-driven experience and an autonomous agent, useful when you want some of each.

Working directory
The folder you were in when you started Claude, which Claude treats as yours for the rest of the session. Reading needs no approval inside it, and the same read stops and asks you outside it. When a permission rule you wrote correctly seems not to fire, this is the most common cause and the fastest to fix, and no amount of extra allow rules will change it.

Workspace trust dialog
The screen asking whether you trust a folder the first time you open a project, listing what the rules inside it would grant. Until you accept it, that project's allow rules and additional directories are read and not applied. Deny and ask are untouched by it, because those two only ever take permission away.

Worktree
A private copy of your project folder, given to each session so two sessions working at once cannot overwrite each other. The app creates them and tucks them inside your project, and archiving a session removes its copy.

WSL2
Windows Subsystem for Linux, version 2, a feature built into Windows that gives you a full Linux environment inside it. It is worth having when your work involves containers or open-source projects that assume Linux, and it means every tutorial and configuration file you find online works without translation.

Y

YAML
A plain text format for configuration, using indentation rather than brackets.

YOLO mode
The community's nickname for bypass permissions, the mode that stops asking altogether. See also Bypass permissions.

This resource is part of

Claude Code: From Beginner to Pro Agentic AI Engineer

by Arun Nagarathanam

Take your skills to the next level with

AI GEO 2026: Get Recommended by ChatGPT, Google, Perplexity

by Arun Nagarathanam