Glossary

Plain-English definitions, in roughly the order the course introduces them.

agent: an AI model connected to tools (read files, write files, run commands) that works in a loop until a task is done. Claude Code is one.

LLM (large language model), the AI itself: an extremely well-read text predictor. The agent is an LLM plus tools plus a loop.

one-shot: building something from a single prompt, no iteration.

token: the unit AI text is measured (and billed) in; roughly ¾ of a word.

context window, the agent's short-term memory: your messages, files it has read, command outputs. Finite. Fills fast.

context rot: the quality decay as the context window fills with noise; why long sessions get dumber and fresh ones feel sharp.

hallucination: the model confidently inventing something that doesn't exist: a package, a function, a "fact". The reason you verify by running, and spot-check any facts it generates, flashcards included.

context engineering, controlling what's in the window: everything needed, nothing else. /clear, focused sessions, CLAUDE.md, save/restore.

prompt engineering, writing requests that don't leave gaps to guess at: intent, constraints, acceptance criteria, examples.

acceptance criteria: the concrete, checkable definition of "done".

plan mode: Claude Code mode where the agent proposes a written plan and changes nothing until you approve.

CLAUDE.md: a file of standing instructions the agent reads at the start of every session. Keep tiny: index, not archive.

context save/restore: ending a session with /context-save (a written summary: done / decided / next) and opening the next with /context-restore, so fresh sessions continue cleanly instead of starting cold.

spec (specification): the full written decision of what is being built. /spec produces one by interviewing you; in waterfall it's the project's foundation document.

baseline: a plan or spec formally frozen at a point in time. After baselining, changes are exceptions to be decided, not edits to be slipped in.

stage gate: a formal checkpoint where a project may not proceed until a reviewer, looking at evidence, signs off. Session 5 runs four of them.

debug bridge: scaffolding code added to an iPhone app during development so the agent can observe it running on a real device (/ios-sync installs it; /ios-clean removes it at closure).

git: the snapshot ("version control") system for code. commit = snapshot; diff = what changed; repo = a watched folder.

GitHub: the website where repos live; also hosts sites (GitHub Pages).

deploy / ship: put software where users can reach it.

SDLC (software development lifecycle): brainstorm → requirements → plan → build → review → verify → ship. The shape of professional work.

TDD (test-driven development): write the test first, then the code that passes it. With agents: the test becomes the agent's self-check.

harness, everything wrapped around the model: tools, permissions, CLAUDE.md, skills, hooks. Harness engineering = improving the agent's environment rather than its brain.

skill: a markdown file teaching the agent a workflow or knowledge; loads only when relevant. Invoked like /revision-cards.

hook: a script that runs automatically at a fixed point in the agent's workflow (e.g. after every file edit). Guaranteed, unlike instructions.

subagent: a helper agent with its own separate context; does research or review and reports back a summary without cluttering your window.

MCP (Model Context Protocol): a standard for plugging external tools into an agent. Powerful, but each connected server costs context in every session, hence "prefer CLIs".

CLI (command-line interface): a tool driven by typed commands (like git). Costs the agent nothing until used.

verification loop: giving the agent a check it can run (test, build, screenshot) so it iterates to passing, not to looking done.

code review: reading changes before trusting them; done by you, a fresh agent session, or a different model, the verdict is always yours.

retrospective (retro), the after-the-work look at how you worked: went well / harder than it should've been / surprised me / do differently.

sprint, agile's fixed time-box (yours: one session; at work, usually a week or two) that ends with something shipped and a look back.

backlog: everything the product might someday need, as ordered slices. A living list, never a baseline.

increment: one shipped slice of product; the unit agile delivers in.

Definition of Done (DoD): the quality bar every increment must clear before it counts: yours is QA'd clean, deployed, canary green.

canary: watching a deployment right after it ships so problems are caught while they're minutes old, not weeks. Named for the mine bird.

scrape: pulling structured data out of a web page (/scrape), the raw material for dashboards and automations.

backend: the part of your software that doesn't run on the user's machine: a database and services it talks to. The line between a page and a service. (Supabase is the hosted backend this course reaches for when a project needs one.)