Glossary
Every technical term from the course, defined in plain English. Organized by the lesson where each concept is introduced.
- Compute
- The processing power of a computer: the CPU running instructions, performing calculations, executing functions.
- Storage
- Persistent data that survives when the power goes off. Hard drives, SSDs, databases.
- RAM
- Random Access Memory. Fast, temporary storage that gets erased when the power goes off. Like the bed of a pickup truck: small, fast, holds what you are actively working on.
- Operating System (OS)
- The software layer (Windows, macOS, Linux) that provides a user-friendly interface for managing compute, storage, and networking.
- Networking
- The ability for computers to communicate with each other over a network (WiFi, Ethernet, the internet).
- Terminal
- A text-based interface for interacting with your computer by typing commands instead of clicking. The same thing as Finder, just with text.
- IDE
- Integrated Development Environment. A program combining a file browser, code editor, and terminal in one window (e.g., VS Code, Cursor).
- File Path
- The address of a file on your computer, e.g., /Users/you/Documents/my-project/index.html. Each slash is a folder boundary.
- Claude Code
- An AI agent that runs inside your terminal. It reads files, writes code, runs commands, and deploys changes directly in your project.
- Vibe Coding
- Describing what you want in plain English and having AI generate the code. The workflow of describe, watch, adjust, repeat.
- Debugging Loop
- The workflow of: something breaks, copy the error, paste it to Claude, watch it fix. Repeat until it passes.
- CLAUDE.md
- A plain text file in the root of your project that Claude Code reads at the start of every session. Persistent project memory, like the glossary in front of a textbook.
- /init
- A Claude Code slash command that scans your project and generates a starter CLAUDE.md automatically.
- CRUD
- Create, Read, Update, Delete. The only four operations you can ever do with data. No exceptions.
- Function
- A set of instructions that performs one or more CRUD operations. The 'how' of computing.
- Trigger
- What kicks off a function: manual (click), cron (timer), webhook (external message), or event-driven (data change).
- Cron
- A scheduled trigger that fires at set times. From the Greek word for time (chronos).
- Webhook
- An external service sending your system a notification that something happened.
- HTML
- HyperText Markup Language. Text with tags that browsers render into visual web pages.
- CSS
- Cascading Style Sheets. A text file that tells the browser how HTML elements should look (colors, fonts, spacing).
- Markdown
- A lightweight text format using symbols (# for headings, ** for bold) that renderers turn into formatted text.
- JSON
- JavaScript Object Notation. A structured data format with key-value pairs. The lingua franca of web APIs. Readable by a baby.
- Rendering
- The process of interpreting raw data (like HTML tags) and displaying it visually. Chrome is a renderer.
- API
- Application Programming Interface. A contract between two systems: one asks, the other answers. Like a restaurant menu.
- Base URL
- The street address of the restaurant, meaning the root address of an API server.
- Endpoint
- The menu item. A specific path on an API that performs a specific action.
- Parameters
- Your order details. The specific data you send with an API request (coordinates, date range, filters).
- Request
- A message sent to a server asking for data or an action.
- Response
- What the server sends back after processing a request.
- HTTP Method
- The verb in an API request: GET (read), POST (create), PUT (update), DELETE (delete).
- Status Code
- A three-digit number indicating what happened. 200 good, 404 bad, 500 server broke.
- API Key
- An unauthenticated bearer token, a secret string included with requests. Whoever has the key can use it.
- .env File
- An environment file that stores secrets (API keys, passwords) outside your code. Never committed to version control.
- .gitignore
- A file that tells Git which files to never track or upload. Used to keep secrets out of repositories.
- Rate Limiting
- APIs throttling how many requests you can make in a time period to prevent abuse.
- MCP
- Model Context Protocol. A standardized way to give AI models pre-built instruction manuals for APIs and tools. An API is a door; MCP is the instruction manual for that door.
- MCP Server
- A service that implements MCP for a specific tool or API, giving Claude named tools with defined parameters instead of making it guess.
- Harness
- The connection layer that wires Claude to your project, tools, MCPs, skills, and codebase. The model reasons; the harness acts.
- Agentic Loop
- The cycle Claude Code runs: gather context, take action, verify results, repeat. Powered by the harness.
- Slash Command
- A command prefixed with / that talks to the harness, not the model. Examples: /init, /mcp, /clear, /resume, /usage, /remote.
- /mcp
- Shows which MCP servers are connected and what tools they provide in the current session.
- /usage
- Shows token usage and billing status for the current Claude Code session.
- /remote
- Runs a Claude Code session on a remote server instead of your local machine.
- Skill
- A reusable instruction set (text file) that teaches Claude a specific workflow. MCP teaches how to use a tool; a skill teaches how to do a job.
- Scheduled Agent
- Claude Code running on a timer, automatically, in the background, on a recurring schedule. Like a cron job but with AI.
- Variable
- A labeled container that holds a piece of data: a name, a number, true/false.
- Loop
- Code that repeats the same instruction multiple times, once for each item in a list.
- If/Else
- How computers make decisions. Check a condition: if true, do one thing; if false, do another.
- Codebase
- All the code files for a project, organized into folders.
- TypeScript
- JavaScript with type-checking guardrails that catch mistakes earlier.
- Python
- A programming language popular for data, AI, and scripting. Reads almost like English.
- Compiled Language
- A language (Go, Rust, C) translated entirely to machine code before running. Like translating a whole book before publishing.
- Interpreted Language
- A language (Python, JavaScript) translated line-by-line at runtime. Like a live interpreter translating as someone speaks.
- Runtime
- The environment that makes code run: the interpreter plus memory management, file access, etc.
- Static Site
- Pre-built HTML files served as-is. No code runs at request time.
- SSR
- Server-Side Rendering. Code runs on the server for every request to build fresh HTML.
- SSG
- Static Site Generation. Code runs once at deploy time to generate all HTML pages.
- Repository (Repo)
- A folder of code with full version history. Every change ever made is recorded.
- Git
- The version control tool that tracks changes to code. A time machine for your project.
- Commit
- A snapshot, a save point in your code's history, with a message explaining what changed.
- Branch
- A parallel copy of the codebase where you can work on changes without affecting the main version.
- Pull Request (PR)
- A request to merge your branch's changes into the main branch, with review and discussion.
- CI/CD
- Continuous Integration / Continuous Deployment. Automated pipelines that test and deploy code when it's merged.
- GitHub
- A website that hosts Git repositories online, with collaboration features like PRs, issues, and Actions.
- Database
- An organized collection of data with rules, like a spreadsheet with enforced structure.
- SQL
- Structured Query Language. The language for talking to relational databases. Reads like English.
- Table
- A single collection of related data in a database, like one tab in a spreadsheet.
- Relational Database
- A database (like PostgreSQL) with strict tables where data references other tables.
- Document Database
- A database (like MongoDB, Firestore) that stores flexible JSON-like documents.
- Cache
- Frequently-used data kept in fast memory so you don't have to fetch it from the database every time.
- Framework
- A pre-built structure that handles common patterns so you focus on your specific logic.
- Library
- A collection of reusable code that does one thing well (e.g., date formatting, chart rendering).
- Stack
- The combination of technologies used to build an app: language, framework, database, hosting.
- package.json
- A file listing a JavaScript project's dependencies and scripts. The recipe card.
- Next.js
- A React framework for building web apps with server-side rendering and routing.
- Cloud
- Other people's computers in a warehouse, sliced up so you rent exactly the pieces you need. Hardware stores for computers.
- Bare Metal
- A physical server you rent entirely. Fixed cost whether you use 1% or 100%.
- AWS
- Amazon Web Services. The largest cloud provider.
- GCP
- Google Cloud Platform. Strong in AI/ML and developer tooling.
- Azure
- Microsoft's cloud. Tightly integrated with the Microsoft ecosystem.
- Server
- A computer running code, waiting for requests. Your laptop could be one.
- Serverless
- Cloud hosting where you don't manage servers. Code runs only when needed, and you pay per execution. Uber vs. owning a car.
- Container
- Everything your code needs to run, packed into one portable box (runtime, libraries, config, code).
- Docker
- The most common tool for building containers. A Dockerfile is the recipe.
- CDN
- Content Delivery Network. Servers distributed globally that serve files from the location nearest to the user.
- Cold Start
- The delay when a serverless container needs to wake up after being idle.
- LLM
- Large Language Model. A program that predicts the next word to generate text responses. Autocomplete on steroids.
- Token
- The unit an LLM processes, roughly 3/4 of a word. Both input and output are measured in tokens.
- Temperature
- Controls randomness in AI output. 0 = deterministic and factual, 1 = creative and varied.
- Context Window
- The maximum amount of text an LLM can consider at once, like the size of its working desk.
- Prompt
- The instruction you give an LLM. The input text that shapes the output.