Glossary

A reference for the technical terms you'll encounter when building with Claude. These definitions focus on what you need to know, not comprehensive technical detail.

Code & Programming

API (Application Programming Interface) — A way for different software to talk to each other. When your app fetches weather data or sends a notification, it's using an API. Think of it like a waiter taking your order to the kitchen — you don't need to know how the kitchen works.

Component — A reusable piece of UI. A button is a component. A card is a component. A navigation bar is a component. You build interfaces by composing components together, like assembling with building blocks.

Dependency — Code that your project relies on but didn't write. If you use a date-formatting library, that's a dependency. Dependencies are managed through package managers.

Endpoint — A specific URL where your app can request or send data. Like /api/users or /api/weather. Each endpoint does one thing.

Function — A named block of code that does a specific thing. Like saveNote() or calculateContrast(). Functions take inputs, do something, and often return outputs.

Hooks — In React, special functions that let components have memory and respond to changes. useState remembers values between renders. useEffect runs code when things change. You'll see these a lot in web projects.

Package — A bundle of code you can add to your project. Packages provide ready-made functionality so you don't have to build everything from scratch. A package for handling dates, a package for animations, etc.

Props (Properties) — Data passed into a component. If a Button component has props for label and color, you can create buttons with different labels and colors from the same component.

State — Data that can change and affects what's displayed. If a toggle is on or off — that's state. If a list has 3 items or 5 items — that's state. When state changes, the UI updates.

Variable — A named container for storing data. Like userName = "Alex" or itemCount = 42. Variables let you reference and update values throughout your code.

Git & Version Control

Branch — A separate line of development. The main branch is the "official" version. You create branches to work on features without affecting main, then merge when ready.

Clone — Making a copy of a repository on your computer. When you clone a repo, you get all the files and the complete history.

Commit — A saved snapshot of your code at a point in time. Like a save point in a video game. Each commit has a message describing what changed. Good commit messages help you find your way back if needed.

Git — The version control system that tracks changes to your code. It lets you save snapshots, undo mistakes, and collaborate with others. Git is the tool; GitHub is a place to store Git repositories online.

Merge — Combining changes from one branch into another. When your feature branch is ready, you merge it into main. Sometimes merge conflicts happen when the same lines were changed in both branches.

Pull — Getting the latest changes from a remote repository. If someone else pushed changes, you pull them to update your local copy.

Push — Sending your local commits to a remote repository. After you commit locally, you push to share your changes with others (or back them up).

Repository (Repo) — A folder containing your project's files plus all the Git history. Every commit ever made lives in the repo.

Staging — Marking files to be included in your next commit. You make changes, stage the ones you want to commit, then commit. This lets you be selective about what goes into each snapshot.

Building & Deployment

Build — Converting your source code into something that can run. For web, this might mean bundling JavaScript files. For macOS, creating an app package. For iOS, compiling into a format devices can run.

Bundle — Combining multiple files into fewer files for production. A bundler takes your 50 JavaScript files and turns them into 1 or 2 optimized files for faster loading.

Compile — Translating code from one form to another. Swift code compiles into machine code the CPU can run. TypeScript compiles into JavaScript browsers can understand.

Deploy — Making your app available to users. For web apps, this means putting files on a server. For native apps, this means submitting to an app store or distributing the application.

Environment — The context where code runs. "Development environment" is your computer while building. "Production environment" is where real users access it. Different environments might have different settings.

Local — On your computer, as opposed to on a server somewhere. "Running locally" means running on your machine. "Pushing to remote" means sending to a server.

Production — The live, real-world version of your app that users actually use. "Deploying to production" means making changes live.

Frameworks & Platforms

Framework — A collection of pre-built code that provides structure for building apps. React is a framework for web interfaces. SwiftUI is a framework for Apple platforms. Frameworks make decisions for you so you can focus on your specific features.

React — A JavaScript framework for building web interfaces. Made by Facebook. Uses components and a syntax called JSX that looks like HTML inside JavaScript.

SwiftUI — Apple's framework for building native apps across all Apple platforms (macOS, iOS, watchOS, tvOS). Uses declarative syntax — you describe what you want, not how to build it step by step.

TypeScript — JavaScript with type checking. Catches errors before your code runs. Many web projects use TypeScript because it prevents common bugs.

Miscellaneous

CRUD — Create, Read, Update, Delete — the four basic operations for data. Most apps are CRUD apps: they let you create things, view them, edit them, and delete them.

JSON — A format for storing and exchanging data. Looks like: {"name": "Alex", "age": 30}. APIs typically send and receive JSON.

Terminal / Command Line — A text-based interface for controlling your computer. Instead of clicking, you type commands. Claude Code runs in the terminal.

UI (User Interface) — What users see and interact with. Buttons, forms, navigation, layouts — that's all UI.

UX (User Experience) — How users feel when using your product. The overall experience, not just individual interface elements.

Using This Glossary

When Claude uses a term you don't know, look it up here. If it's not listed, just ask Claude:

What does "middleware" mean in this context?

Technical vocabulary can feel intimidating, but remember: these are just labels for concepts. The concepts themselves are usually simpler than the jargon makes them sound.

Exercises

1. Without looking, write one-sentence definitions for five terms you expect to use most (e.g. component, state, props, commit, deploy), then check them against this glossary.
2. The next time Claude uses a term you don't recognize, paste the "What does ___ mean in this context?" prompt and add the new term and its plain-language meaning to your own running list.
3. Pick three Git terms (branch, commit, merge) and describe, in your own words, the sequence you'd follow to work on a feature without breaking your main version.