4.8 — Vocabulary: The Complete Lexicon
Every term from every phase, organized by when it was introduced. Know these and you can hold your own in any technical conversation.
Previous vocabulary pages: Phase 0 | Phase 1 | Phase 2 | Phase 3
Phase 0 — Environment + Orientation
Section titled “Phase 0 — Environment + Orientation”Terms introduced in Phase 0: See the Matrix.
| Term | Definition |
|---|---|
| AI | Software that makes predictions and generates content by learning patterns from data |
| LLM (Large Language Model) | The type of AI behind ChatGPT, Claude, etc. — trained on text, predicts the next word |
| Model | The trained AI brain itself — Claude Opus, GPT-5, Gemini are different models |
| Generative AI | AI that creates new content vs. AI that classifies or sorts existing data |
| Vibe coding | Building software by describing what you want in natural language and letting AI generate the code |
| Terminal / CLI | A text-based way to talk to your computer by typing instructions |
| IDE | A specialized text editor for working with code — VS Code is the most common |
| Git | A system that tracks every change you make to files so you can undo anything |
| GitHub | A website where people store and share Git-tracked projects |
| Repository (Repo) | A project folder tracked by Git |
| Frontend | What the user sees and touches — the app, the website, the buttons |
| Backend | What runs behind the scenes — logic, database, AI calls |
| API | How two pieces of software talk to each other |
| Database | Where data lives permanently — users, messages, settings |
| Server | A computer that’s always on, waiting to respond to requests |
| Local vs. Remote | Local = on your computer. Remote = on someone else’s server. |
| Open source | Software whose code is public — anyone can read, use, improve it |
| Harness | The tool between you and the AI model — Claude Code, Cursor, ChatGPT |
| Context | Everything the AI can “see” when answering you |
| Context window | The size limit on how much the AI can see at once |
| Token | The unit AI uses to measure text — roughly 3/4 of a word |
| Provider | The company that built and runs the model |
| Bug | Something that doesn’t work as intended |
| Debug | Finding and fixing the bug |
| Deploy | Making your software live and available to users |
| Dependency | Software your project relies on that someone else built |
| Config | Settings that control how software behaves |
| Flag | An option added to a command to modify behavior |
| Path | The address of a file on your computer |
| Root | The top-level folder of a project |
| Script | A file containing commands that run automatically |
| Runtime | The environment where code actually executes |
| Package | A bundle of code someone else wrote that you install and use |
| Stack | The combination of technologies used to build something |
| Boilerplate | Starter code or template that gives you a foundation to build on |
| Localhost | Your own computer acting as a server — only you can see it |
| Markdown | Formatted text format — documentation, notes, README files |
| JSON | Structured data format for config, settings, data exchange |
| YAML | Same job as JSON, more human-readable — used in config files |
| .env | File containing secret settings — API keys, passwords. Never shared publicly. |
Phase 1 — First Build
Section titled “Phase 1 — First Build”Terms introduced in Phase 1: First Build.
| Term | Definition |
|---|---|
| npm | Node Package Manager — installs JavaScript packages and tools from the internet |
| Prompt | The instruction you give to an AI |
| Hallucination | When AI confidently generates something that’s wrong |
| Iteration | Refining results through multiple rounds of feedback |
| Commit | A saved snapshot of your project at a specific moment |
| Push / Pull | Send to / download from a remote server |
| Staging | Marking which changes should go into the next commit |
| Working directory | The folder you’re currently in |
| README | A file explaining what a project is and how to run it |
| Entry point | The file where a program starts running |
| Hosting | A service that runs your project on a server so others can access it |
| Port | A numbered channel on your computer for network traffic — localhost:3000 means “my computer, channel 3000” |
| DNS | Translates human-readable names (google.com) to computer addresses |
Phase 2 — Builder’s Toolkit
Section titled “Phase 2 — Builder’s Toolkit”Terms introduced in Phase 2: Builder’s Toolkit.
| Term | Definition |
|---|---|
| Context engineering | Deliberately shaping what the AI can see to get better output |
| CLAUDE.md | Project-level instruction file Claude Code reads automatically every session |
| Branch | A parallel version of your project for making changes safely |
| Pull Request (PR) | A proposal to merge a branch, with description and review process |
| Merge conflict | Two branches changed the same line — you decide which to keep |
| Diff | A view showing exactly what changed between two versions |
| Stack trace | A list showing the chain of function calls that led to an error |
| Regression | A fix that breaks something that was previously working |
| Edge case | An unusual or extreme input that exposes bugs normal inputs don’t |
| YAGNI | You Ain’t Gonna Need It — don’t build features you might need later |
| DRY | Don’t Repeat Yourself — one source of truth for each piece of logic |
| Architecture | The high-level structure of how a system is organized |
| Component | A self-contained, reusable piece of an interface |
| Route | A URL path that maps to a specific page or action |
| State | Data that can change over time and affects what the user sees |
| Environment variable | A setting stored outside your code so it can change between environments |
| Refactor | Restructuring code without changing what it does |
| Technical debt | Shortcuts taken now that create more work later |
| Scope creep | When a project gradually grows beyond its original boundaries |
| MVP | Minimum Viable Product — the smallest version that delivers value |
| Monorepo | One repository containing multiple related projects |
| Microservice | Architecture where the system is split into small, independent services |
| Monolith | Architecture where everything lives in one application |
| Changelog | A record of what changed between versions |
| Middleware | Software that sits between two systems and processes requests as they pass through |
Phase 3 — Agent Architect
Section titled “Phase 3 — Agent Architect”Terms introduced in Phase 3: Agent Architect.
| Term | Definition |
|---|---|
| Agent | AI system with tools, decision-making ability, and multi-step execution |
| Tool use / Function calling | Mechanism letting AI take actions beyond generating text |
| MCP (Model Context Protocol) | Standard protocol for connecting AI to external tools and data sources |
| MCP Server | Program that exposes tools from an external system to AI |
| Hook | Script that runs automatically on a specific event |
| RAG (Retrieval-Augmented Generation) | Retrieving relevant info and injecting it into AI context |
| Embedding | Numeric representation of text for measuring similarity between documents |
| Vector database | Database optimized for storing and searching embeddings |
| Semantic search | Search by meaning, not exact keywords |
| Knowledge base | An organized collection of information an AI system can draw from |
| Partition | A section within a knowledge base — like folders within a filing cabinet |
| Guardrail | A constraint placed on an agent to limit its actions |
| Human-in-the-loop | Agent pauses for human approval at critical decision points |
| Autonomy | The degree to which an agent can act without human direction |
| Orchestration | Coordinating multiple agents or systems to accomplish a goal |
| Pipeline | A sequence of processing steps where output of one becomes input of the next |
| Inference | When an AI model processes input and generates output — every response = one inference call |
| Latency | Time between sending a request and getting a response |
| Throughput | How many requests a system can handle in a given time period |
| Token budget | The maximum tokens allocated for a task or session — controls cost |
| Deterministic | Same input always produces same output — traditional code is deterministic |
| Non-deterministic | Same input can produce different outputs each time — AI models are non-deterministic |
Phase 4 — Orchestrator
Section titled “Phase 4 — Orchestrator”Terms introduced in Phase 4: Orchestrator.
| Term | Definition |
|---|---|
| Subagent | An agent spawned by another agent to handle a specific subtask |
| Delegation | Assigning a task from one agent to another |
| Fan-out / Fan-in | Splitting work across multiple agents (fan-out), then combining results (fan-in) |
| Graceful degradation | System continues working when a component fails, rather than crashing entirely |
| Principle of least privilege | Each component gets only the minimum access it needs — nothing more |
| Idempotent | An operation that produces the same result whether run once or ten times |
| Race condition | Two processes trying to change the same thing simultaneously, producing unpredictable results |
| Scalability | A system’s ability to handle growth — more users, more data, more requests |
| Load balancer | Distributes incoming requests across multiple servers |
| Cache | Storing frequently accessed data in fast, temporary storage |
| CDN (Content Delivery Network) | Servers distributed worldwide storing copies of your content close to users |
| Rate limit | Maximum number of requests allowed in a time period |
| Webhook | A URL that receives automatic notifications when something happens in another system |
| Queue | A list of tasks waiting to be processed in order |
| Container | Packaged unit of software that includes everything needed to run, anywhere |
| Docker | The most common tool for creating and running containers |
| CI/CD | Automated pipeline that tests and deploys code when you push changes |
| Production (prod) | The live environment real users interact with |
| Staging | A copy of production used for testing before deploying |
| Sandbox | An isolated environment for safe experimentation |
| SSH (Secure Shell) | A secure way to connect to and control a remote computer via terminal |
| VPN (Virtual Private Network) | Encrypted tunnel between your computer and a private network |
| Firewall | Security system controlling what network traffic is allowed in and out |
| SSL/TLS | Encryption that makes web traffic secure — the “S” in HTTPS |
| IP address | A computer’s unique address on a network |
| Code review | Another developer examining your code before it’s merged |
| Linting | Automated checking of code style and common errors |
| Unit test | Tests a single function or component in isolation |
| Integration test | Tests how multiple components work together |
| End-to-end (E2E) test | Tests the entire application flow as a user would experience it |
| Coverage | Percentage of code tested by automated tests |
| SemVer (Semantic Versioning) | Version numbering: MAJOR.MINOR.PATCH — major = breaking, minor = new features, patch = fixes |
| Breaking change | A change that makes existing things stop working |
| Backward compatible | A change that works with existing code without requiring updates |
| Deprecation | Marking something as “still works but will be removed in a future version” |
| API endpoint | A specific URL where an API accepts requests |
| Payload | The data sent with an API request |
| Authentication (AuthN) | Verifying who someone is — login |
| Authorization (AuthZ) | Verifying what someone is allowed to do — permissions |
| JWT (JSON Web Token) | A compact token used for authentication — carries user info in encoded form |
| OAuth | Standard for giving one app limited access to your account on another service |
| Uptime | Percentage of time a system is operational |
| SLA (Service Level Agreement) | A commitment to a specific level of reliability |
| Incident | An unplanned event that disrupts service |
| Rollback | Reverting to a previous working version after a bad deploy |
| Monitoring | Continuous automated checking of system health |
| Alert | An automated notification when something goes wrong |
| Audit trail | A record of who did what and when |
| Spec (Specification) | A document describing exactly what needs to be built and what “done” looks like |
| Sprint | A fixed time period (usually 1–2 weeks) during which a set of tasks is completed |
| Backlog | A prioritized list of work that hasn’t been started yet |
| Blocker | Something preventing progress on a task |
| Standup | A brief status update meeting or report |
| Acceptance criteria | Specific conditions that must be true for a task to be considered complete |
Total vocabulary: ~150 terms. This is the shared language between vibe coders and traditional engineers. Know these, and you can hold your own in any technical conversation.
Phase overview: Phase 4