Appendix E: Glossary

Comprehensive definitions of key terms used throughout this book. Terms are listed alphabetically. Cross-references to other glossary entries are shown in bold. Chapter references indicate where the term is primarily discussed.

Abstract Base Class (ABC) — A class that cannot be instantiated directly and is designed to be subclassed. In Python, created using the abc module. Defines a contract that subclasses must fulfill by implementing required abstract methods. (Ch. 25)

Acceptance Testing — Testing that verifies a system meets its business requirements and is acceptable for delivery. Often written from the user's perspective. (Ch. 21)

Adapter Pattern — A design pattern that allows objects with incompatible interfaces to work together by wrapping one object's interface to match what another object expects. (Ch. 25)

ADR (Architecture Decision Record) — A document that captures an important architectural decision, including the context, options considered, and rationale for the choice. AI can help generate and maintain ADRs. (Ch. 23, 24)

Agent — In the context of AI coding, a system that can autonomously plan tasks, execute actions (like reading files, running commands, and writing code), observe results, and iterate. Distinguished from a simple assistant by its ability to take multi-step actions. See also agent loop. (Ch. 36)

Agent Loop — The plan-act-observe cycle that AI coding agents follow: plan what to do, take an action (read a file, run a command, edit code), observe the result, and decide the next step. This cycle repeats until the task is complete. (Ch. 36)

Agile — A family of iterative software development methodologies that emphasize incremental delivery, collaboration, and responsiveness to change. Includes frameworks like Scrum and Kanban. (Ch. 33)

Aider — An open-source, terminal-based AI coding assistant that works with multiple LLM providers. Known for strong Git integration and transparency. (Ch. 3)

Alembic — A database migration tool for SQLAlchemy. Manages schema changes to databases through versioned migration scripts. (Ch. 18)

Algorithm — A step-by-step procedure for solving a problem or performing a computation. The efficiency of an algorithm is typically described using Big-O notation. (Ch. 28)

API (Application Programming Interface) — A defined interface that allows different software components to communicate. In web development, typically refers to REST API endpoints that accept requests and return responses, usually in JSON format. (Ch. 17, 20)

API Key — A secret string used to authenticate requests to an API. Must be kept secure and never committed to version control. (Ch. 4, 27)

Argument Parsing — The process of reading and interpreting command-line arguments passed to a CLI application. In Python, typically done with argparse or click. (Ch. 15)

Async/Await — Python syntax for writing asynchronous code that can handle concurrent operations (like network requests) without blocking. Central to frameworks like FastAPI. (Ch. 17, 28)

Attention Mechanism — The core innovation of the transformer architecture. Allows the model to weigh the relevance of different parts of the input when processing each element. Enables the model to "focus" on relevant context regardless of distance in the text. (Ch. 2)

Authentication — The process of verifying who a user is (proving identity). Distinct from authorization. Common methods include passwords, tokens, and OAuth. (Ch. 17, 27)

Authorization — The process of determining what an authenticated user is allowed to do (checking permissions). Distinct from authentication. (Ch. 17, 27)

Benchmark — A standardized test or set of tests used to evaluate and compare the performance of AI models, tools, or code. Examples include HumanEval, MBPP, and SWE-bench. (Ch. 3, Appendix A)

Big-O Notation — A mathematical notation that describes the upper bound of an algorithm's growth rate as input size increases. Written as O(f(n)), where f(n) describes the growth function. Common complexities include O(1), O(log n), O(n), O(n log n), and O(n^2). (Ch. 7, 28, Appendix A)

Boilerplate — Repetitive, standardized code that is required by a framework or language but does not contain unique logic. AI assistants are particularly effective at generating boilerplate. (Ch. 1)

Branch (Git) — An independent line of development in a Git repository. Branches allow parallel work on features, bug fixes, or experiments without affecting the main codebase. (Ch. 31)

Builder Pattern — A design pattern that constructs complex objects step by step, allowing the same construction process to create different representations. (Ch. 25)

Caching — Storing the results of expensive computations or data retrieval so they can be reused without repeating the original operation. Strategies include in-memory caching, Redis, and HTTP caching. (Ch. 28)

Chain-of-Thought (CoT) Prompting — A prompting technique that asks the AI to show its reasoning step by step before giving a final answer. Improves performance on complex tasks requiring logic or multi-step reasoning. (Ch. 12)

Characterization Test — A test written to document the current behavior of existing code, not its intended behavior. Used when refactoring legacy code to ensure existing functionality is preserved. (Ch. 26)

CI/CD (Continuous Integration / Continuous Deployment) — Practices where code changes are automatically built, tested, and deployed. CI runs tests on every commit; CD automatically deploys passing changes to production. (Ch. 29)

Claude Code — Anthropic's CLI-based AI coding agent. Operates in the terminal, can read and modify files, run commands, and perform complex multi-step tasks. Supports the Model Context Protocol (MCP). (Ch. 3, 4)

Clean Code — Code that is easy to read, understand, and maintain. Principles include meaningful naming, small functions, single responsibility, and minimal duplication. (Ch. 25)

CLI (Command-Line Interface) — A text-based interface for interacting with software through typed commands. Python CLI tools are typically built with argparse or Click. (Ch. 15)

Click — A Python package for creating command-line interfaces with decorators. An alternative to argparse with a more composable design. (Ch. 15)

Code Completion — An AI feature that predicts and suggests the next characters, lines, or blocks of code as you type. GitHub Copilot pioneered mainstream inline code completion. (Ch. 3)

Code Review — The practice of examining code changes before they are merged, to identify bugs, improve quality, and share knowledge. AI can serve as a first-pass reviewer. (Ch. 30)

Code Smell — A surface-level indicator in code that suggests a deeper problem. Examples include long functions, excessive parameters, duplicate code, and feature envy. Not bugs themselves, but hints that refactoring may be needed. (Ch. 25, 30)

Command Pattern — A design pattern that encapsulates a request as an object, allowing parameterization, queuing, logging, and undo operations. (Ch. 25)

Commit (Git) — A snapshot of all tracked files in a Git repository at a point in time, along with a message describing the changes. (Ch. 31)

Comprehension — A concise Python syntax for creating lists, dicts, sets, or generators from iterables. Example: [x**2 for x in range(10)]. (Ch. 5, Appendix C)

Constraint Satisfaction Prompting — A prompting technique where you specify explicit constraints (performance requirements, style rules, API boundaries) that the generated code must satisfy. (Ch. 12)

Container — A lightweight, standalone, executable package that includes everything needed to run a piece of software: code, runtime, system tools, libraries, and settings. Docker is the most common container platform. (Ch. 29)

Context Priming — The practice of providing relevant background information at the beginning of a conversation with an AI assistant to improve the quality of subsequent responses. (Ch. 9)

Context Window — The maximum amount of text (measured in tokens) that an AI model can consider at once, including both the input prompt and the generated output. Larger context windows allow more code and conversation history to be included. (Ch. 2, 9)

CRUD — An acronym for Create, Read, Update, Delete -- the four basic operations for persistent data storage. Most web applications are fundamentally CRUD applications. (Ch. 17, 18)

CSS (Cascading Style Sheets) — The language used to describe the presentation and layout of HTML documents. AI assistants can generate CSS from natural language descriptions of desired visual designs. (Ch. 16)

Cursor — An AI-native IDE built as a fork of VS Code. Features include Composer (multi-file editing), Tab completion, and agentic capabilities. (Ch. 3)

Dataclass — A Python decorator (@dataclass) that automatically generates __init__, __repr__, __eq__, and other methods for classes that primarily store data. Reduces boilerplate. (Ch. 5)

Database Migration — A version-controlled change to a database schema. Managed by tools like Alembic to ensure database structure evolves consistently across environments. (Ch. 18)

Dead Code — Code that exists in the codebase but is never executed. A form of technical debt that adds maintenance burden without providing value. (Ch. 34)

Decorator — In Python, a function that modifies the behavior of another function or class. Applied using the @decorator syntax. Common examples include @property, @staticmethod, and @dataclass. (Ch. 5, Appendix C)

Decorator Pattern — A design pattern that dynamically adds responsibilities to an object by wrapping it, providing a flexible alternative to subclassing. Distinct from Python's decorator syntax, though related in spirit. (Ch. 25)

Dependency Injection — A technique where an object receives its dependencies from external code rather than creating them internally. Improves testability and flexibility. Related to SOLID principles (Dependency Inversion). (Ch. 24, 25)

Design Pattern — A reusable solution to a commonly occurring problem in software design. Cataloged in categories: creational (Factory, Builder, Singleton), structural (Adapter, Decorator, Facade), and behavioral (Observer, Strategy, Command). (Ch. 25)

DevOps — A set of practices that combines software development and IT operations, aiming to shorten the development lifecycle and deliver high-quality software continuously. (Ch. 29)

Diff — A representation of the differences between two versions of a file or set of files. AI coding tools often show proposed changes as diffs before applying them. (Ch. 31)

Docker — A platform for building, sharing, and running applications in containers. Uses Dockerfiles to define container images and docker-compose for multi-container applications. (Ch. 29)

Docstring — A string literal placed at the beginning of a Python module, class, or function to document its purpose, parameters, and return value. Accessed via help() or __doc__. (Ch. 23)

DRY (Don't Repeat Yourself) — A software principle that aims to reduce duplication of logic. Every piece of knowledge should have a single, authoritative representation. (Ch. 25)

Edge Case — An input or situation at the extreme boundary of expected operating parameters. AI-generated code often handles the "happy path" well but may miss edge cases. (Ch. 1, 14)

Embedding — A numerical vector representation of text (or other data) that captures semantic meaning. Used in RAG systems and vector databases to find similar content. (Ch. 39)

Endpoint — A specific URL in a REST API that accepts requests and returns responses. For example, GET /api/users/123 is an endpoint that retrieves user 123. (Ch. 17)

Exception — An event that disrupts the normal flow of a program. In Python, handled with try/except blocks. Custom exceptions should inherit from Exception. (Ch. 5, Appendix C)

F-string — Python's formatted string literal syntax (introduced in 3.6). Allows embedding expressions inside string literals using {expression} syntax: f"Hello, {name}!". (Ch. 5)

Facade Pattern — A design pattern that provides a simplified interface to a complex subsystem, making it easier to use. (Ch. 25)

Factory Pattern — A design pattern that creates objects without specifying their exact class, delegating the creation logic to a factory method or class. (Ch. 25)

FastAPI — A modern, high-performance Python web framework for building APIs, based on type hints and Pydantic for data validation. Supports async/await. (Ch. 17)

Feature Flag — A technique that allows enabling or disabling features in production without deploying new code. Useful for gradual rollouts and A/B testing. (Ch. 29)

Few-Shot Prompting — A prompting technique that provides the AI with several examples of the desired input-output pattern before asking it to handle a new input. Teaches by example. (Ch. 12)

Fine-Tuning — The process of further training a pre-trained AI model on a specific dataset to specialize its behavior for particular tasks or domains. (Ch. 2)

Flask — A lightweight Python web framework for building web applications and APIs. Known for its simplicity and extensibility. (Ch. 17)

Frozen Dataclass — A Python dataclass with frozen=True, making instances immutable and hashable. Useful for value objects that should not change after creation. (Ch. 5)

Function Calling — An AI capability where the model can identify when a function (tool) should be called, generate the appropriate arguments, and use the result. Fundamental to agent behavior. (Ch. 36, 37)

Generator — A Python function that yields values one at a time using the yield keyword, producing items lazily rather than computing all values at once. Memory-efficient for large datasets. (Ch. 5, Appendix C)

Git — A distributed version control system that tracks changes to files. The standard tool for managing source code history and collaboration. (Ch. 31)

GitHub Actions — GitHub's built-in CI/CD platform. Automates workflows triggered by events like pushes, pull requests, or schedules. (Ch. 29)

GitHub Copilot — GitHub's AI coding assistant, primarily known for inline code completion in the editor. Supports chat and agentic features. (Ch. 3)

Guard Clause — An early return at the beginning of a function that handles special cases, reducing nesting and improving readability. (Ch. 25, Appendix C)

Hallucination — When an AI model generates content that sounds plausible but is factually incorrect. In coding, this often manifests as references to APIs, methods, or libraries that do not exist. (Ch. 14)

Happy Path — The default scenario in which everything works as expected, with no errors, exceptions, or unusual inputs. AI often handles the happy path well but may miss edge cases. (Ch. 14)

Hash Table — The data structure underlying Python's dict and set types. Provides O(1) average-case lookup, insertion, and deletion. (Ch. 28)

Hot Reload — A development feature that automatically updates a running application when source code changes, without requiring a full restart. Supported by frameworks like Flask (debug mode) and React. (Ch. 16)

HTML (HyperText Markup Language) — The standard markup language for creating web pages. Defines the structure and content of a webpage. (Ch. 16)

HTTP (Hypertext Transfer Protocol) — The protocol used for communication between web browsers/clients and servers. Methods include GET, POST, PUT, DELETE, and PATCH. (Ch. 17)

HumanEval — A benchmark of 164 Python programming problems used to evaluate AI code generation models. Measures pass@k rates. (Ch. 3, Appendix A)

Hypothesis — A Python library for property-based testing that automatically generates test inputs to find edge cases and failures. (Ch. 21)

IDE (Integrated Development Environment) — A software application that provides comprehensive facilities for software development, typically including a code editor, debugger, terminal, and file explorer. Examples: VS Code, Cursor, Windsurf, PyCharm. (Ch. 4)

Idempotent — An operation that produces the same result regardless of how many times it is performed. HTTP PUT and DELETE should be idempotent. Important for reliable API design. (Ch. 17)

Infrastructure as Code (IaC) — Managing and provisioning infrastructure through machine-readable configuration files rather than manual processes. Tools include Terraform, CloudFormation, and Pulumi. (Ch. 29)

Integration Testing — Testing that verifies multiple components work correctly together. Tests interactions between modules, services, or systems. (Ch. 21)

Iterative Refinement — The core practice of vibe coding: generating code with AI, reviewing it, providing feedback, and requesting improvements through multiple conversation turns. (Ch. 11)

JavaScript — The programming language of the web browser. Essential for frontend web development and increasingly used on the server side (Node.js). (Ch. 16)

JSON (JavaScript Object Notation) — A lightweight data interchange format that is easy for humans to read and for machines to parse. The standard format for REST API request and response bodies. (Ch. 17)

Kanban — An agile methodology that visualizes work on a board with columns representing stages (To Do, In Progress, Done). Focuses on limiting work in progress. (Ch. 33)

Knowledge Cutoff — The date after which a language model has no training data. The model cannot know about events, APIs, or library versions released after this date. (Ch. 2, 14)

Lambda Function — An anonymous, single-expression function in Python: lambda x: x * 2. Commonly used as arguments to sorted(), map(), and filter(). (Ch. 5)

Linter — A static analysis tool that checks code for errors, style issues, and potential bugs without executing it. Examples: Ruff, Flake8, ESLint. (Ch. 30)

LLM (Large Language Model) — A neural network trained on vast amounts of text data that can generate, understand, and manipulate natural language and code. Examples: Claude, GPT-4, Gemini. The technology underlying all AI coding assistants. (Ch. 2)

Logging — Recording events, errors, and information during program execution. Python's logging module provides configurable logging with levels (DEBUG, INFO, WARNING, ERROR, CRITICAL). (Ch. 15, 22)

Match Statement — Python's structural pattern matching syntax (3.10+). Similar to switch/case in other languages but with pattern matching capabilities including type checking and destructuring. (Ch. 5)

MCP (Model Context Protocol) — An open protocol developed by Anthropic that standardizes how AI models connect to external tools, data sources, and services. Enables extending AI capabilities with custom integrations. (Ch. 37)

Memoization — Caching the results of function calls to avoid redundant computation. In Python, commonly implemented with @functools.lru_cache. (Ch. 28)

Merge Conflict — A situation in Git where changes in different branches affect the same lines of code and cannot be automatically combined. Requires manual resolution. (Ch. 31)

Meta-Prompting — A prompting technique where you ask the AI to generate or improve prompts, rather than directly generating code. "Write me a prompt that would produce a well-structured REST API." (Ch. 12)

Microservices — An architectural style where an application is composed of small, independently deployable services, each responsible for a specific business capability. Contrasted with monolith. (Ch. 24)

Middleware — Software that sits between the raw request and your application logic, processing requests and responses. Common uses include authentication, logging, and CORS handling. (Ch. 17)

Mock — A simulated object that mimics the behavior of a real object in controlled ways. Used in testing to isolate the code under test from its dependencies. (Ch. 21)

Model — In AI/ML context: a trained neural network that can make predictions or generate outputs. In software architecture: a representation of data and business logic (as in MVC). (Ch. 2)

Monolith — An architectural style where an entire application is built as a single, unified codebase and deployed as one unit. Contrasted with microservices. (Ch. 24)

Multi-Agent System — An architecture where multiple AI agents, each with specialized roles (architect, coder, tester, reviewer), collaborate to accomplish development tasks. (Ch. 38)

MVP (Minimum Viable Product) — The simplest version of a product that delivers core value and can be used to gather feedback. Vibe coding accelerates MVP development significantly. (Ch. 1, 33)

Normalization — In databases, the process of organizing data to reduce redundancy. Normal forms (1NF, 2NF, 3NF, BCNF) define progressively stricter criteria. (Ch. 18)

NoSQL — A category of databases that do not use the traditional relational table model. Includes document stores (MongoDB), key-value stores (Redis), and graph databases (Neo4j). (Ch. 18)

OAuth — An open standard for authorization that allows users to grant third-party applications limited access to their resources without sharing credentials. (Ch. 20, 27)

Observer Pattern — A design pattern where an object (subject) maintains a list of dependents (observers) that are automatically notified of state changes. (Ch. 25)

ORM (Object-Relational Mapping) — A technique that maps database tables to programming language objects, allowing database operations through object methods rather than raw SQL. SQLAlchemy is Python's primary ORM. (Ch. 18)

Pair Programming — A practice where two developers work together at one workstation. In vibe coding, the AI serves as a tireless pair programming partner. (Ch. 1)

pass@k — A benchmark metric that measures the probability of generating at least one correct solution within k attempts. pass@1 measures first-try success; pass@10 measures success within 10 tries. (Ch. 3)

PEP (Python Enhancement Proposal) — The process for proposing changes to Python. PEP 8 defines the standard style guide; PEP 484 introduced type hints. (Ch. 5)

Pip — Python's package installer. Installs packages from the Python Package Index (PyPI). Usage: pip install package_name. (Ch. 4)

Pre-commit Hook — A Git hook that runs automatically before a commit is created. Used to enforce code quality by running linters, formatters, and tests. (Ch. 29, 31)

Pre-training — The initial training phase of an LLM where it learns from massive amounts of text data to predict the next token. Produces general language understanding before fine-tuning for specific tasks. (Ch. 2)

Profiling — Measuring the performance of code to identify bottlenecks. Python profiling tools include cProfile, line_profiler, and py-spy. (Ch. 28)

Prompt — The natural language input given to an AI model. In vibe coding, prompts are the primary interface for communicating what code you want generated, how it should work, and what constraints it should satisfy. (Ch. 1, 8)

Prompt Engineering — The skill of crafting effective prompts to get desired outputs from AI models. Encompasses clarity, specificity, context provision, constraint definition, and output formatting. The core skill of vibe coding. (Ch. 8)

Prompt Library — A personal or team collection of reusable prompt templates for common coding tasks. Built up over time through experience. (Ch. 12, 32)

Property-Based Testing — A testing approach where you define properties (invariants) that should hold for all inputs, and the testing framework generates random inputs to verify those properties. Implemented in Python by Hypothesis. (Ch. 21)

Pull Request (PR) — A request to merge changes from one Git branch into another. Serves as a review checkpoint where code changes are discussed, reviewed, and approved. (Ch. 31)

Pydantic — A Python library for data validation using type annotations. Models define expected data shapes and automatically validate input. Used extensively by FastAPI. (Ch. 17)

pytest — The most popular Python testing framework. Provides simple test discovery, fixtures, parametrization, and a rich plugin ecosystem. (Ch. 21)

Python Package Index (PyPI) — The official repository of third-party Python packages. Packages are installed from PyPI using pip. (Ch. 4)

RAG (Retrieval-Augmented Generation) — A technique that enhances AI responses by first retrieving relevant information from a knowledge base, then including that information in the prompt. Combines search with generation. (Ch. 39)

React — A JavaScript library for building user interfaces, based on component composition and declarative rendering. The most widely used frontend framework. (Ch. 16)

Refactoring — Restructuring existing code without changing its external behavior. The goal is to improve code quality, readability, and maintainability. AI can assist with identifying opportunities and executing refactorings. (Ch. 25, 26)

Regex (Regular Expression) — A pattern-matching language for searching and manipulating text. In Python, used via the re module. Useful but often hard to read -- a good candidate for AI generation. (Ch. 5)

Replit Agent — An AI coding agent integrated into Replit's browser-based IDE. Can build and deploy applications from natural language descriptions. (Ch. 3)

REST (Representational State Transfer) — An architectural style for designing networked applications. Uses HTTP methods (GET, POST, PUT, DELETE) to operate on resources identified by URLs. (Ch. 17)

RLHF (Reinforcement Learning from Human Feedback) — A training technique that uses human evaluations of model outputs to teach the model to generate more helpful, honest, and harmless responses. (Ch. 2)

Role-Based Prompting — A prompting technique that asks the AI to adopt a specific persona or expertise: "Act as a senior security engineer reviewing this code." Focuses the model's responses. (Ch. 12)

Rubber Duck Debugging — The practice of explaining a problem step by step to find the solution. AI assistants serve as an intelligent "rubber duck" that can also offer suggestions. (Ch. 11, 22)

Sampling — The process by which an AI model selects the next token from the predicted probability distribution. Temperature controls the randomness of sampling. (Ch. 2)

Schema — A structured definition of data organization. Database schemas define tables and relationships; API schemas define request and response formats; JSON Schema defines JSON structure. (Ch. 18)

Scope Creep — The gradual expansion of a project's requirements beyond the original plan. AI tools can accelerate development but also enable scope creep by making "one more feature" seem easy. (Ch. 33)

Serverless — A cloud computing model where the cloud provider manages the infrastructure and automatically scales resources. Developers deploy functions that run on demand. Examples: AWS Lambda, Vercel Functions. (Ch. 24, 29)

Singleton Pattern — A design pattern that ensures a class has only one instance and provides a global point of access to it. Often considered an anti-pattern in modern Python. (Ch. 25)

SOLID Principles — Five object-oriented design principles: Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, and Dependency Inversion. Guide the creation of maintainable, extensible software. (Ch. 24, 25)

Specification-Driven Prompting — A prompting technique where you provide a formal or semi-formal specification (requirements document, API contract, schema, or test cases) and ask the AI to generate code that satisfies it. (Ch. 10)

SQL (Structured Query Language) — The standard language for interacting with relational databases. Operations include SELECT, INSERT, UPDATE, DELETE, and JOIN. (Ch. 18)

SQL Injection — A security vulnerability where untrusted input is incorporated into SQL queries without proper sanitization, allowing attackers to execute arbitrary SQL commands. Prevented by using parameterized queries. (Ch. 27)

SQLAlchemy — Python's most widely used ORM and database toolkit. Provides both high-level ORM mapping and low-level SQL expression building. (Ch. 18)

Stack Trace — A report of the active function calls at a specific point in program execution, typically displayed when an unhandled exception occurs. Essential for debugging. (Ch. 22)

Static Analysis — Analyzing code without executing it. Includes type checking (mypy), linting (Ruff), and security scanning. (Ch. 30)

Strangler Fig Pattern — A strategy for incrementally replacing a legacy system by gradually building new functionality alongside the old system, routing more traffic to the new system over time, until the old system can be removed. (Ch. 26)

Strategy Pattern — A design pattern that defines a family of interchangeable algorithms, encapsulating each one and making them interchangeable at runtime. (Ch. 25)

SWE-bench — A benchmark that evaluates AI models on their ability to resolve real-world GitHub issues from popular open-source Python repositories. (Ch. 3)

System Prompt — Instructions provided to an AI model that define its behavior, personality, and constraints for an entire conversation. Distinct from user messages. (Ch. 9)

Technical Debt — The implied cost of future rework caused by choosing a quick or easy solution instead of a better but more time-consuming approach. AI-generated code can accumulate technical debt if not reviewed carefully. (Ch. 34)

Temperature — A parameter that controls the randomness of AI model output. Lower temperatures (near 0) produce more deterministic, predictable responses; higher temperatures increase diversity and creativity but also randomness. (Ch. 2)

Test Coverage — The percentage of code that is executed during testing. Measured by tools like coverage.py. Higher coverage generally indicates more thorough testing, but 100% coverage does not guarantee correctness. (Ch. 21)

Test-Driven Development (TDD) — A development methodology where tests are written before the code they test. The cycle is: write a failing test, write code to make it pass, then refactor. AI can participate in each step. (Ch. 21)

Token — The fundamental unit of text that AI models process. A token might be a complete word, a word fragment, a punctuation mark, or a code symbol. Roughly, 1 token equals about 4 characters or 0.75 English words. (Ch. 2, 9)

Transformer — The neural network architecture underlying all modern LLMs. Introduced in the "Attention Is All You Need" paper (2017). Uses attention mechanisms to process input in parallel, enabling efficient training on massive datasets. (Ch. 2)

Type Hints — Python annotations that specify the expected types of function parameters, return values, and variables. Used by static type checkers like mypy and by frameworks like Pydantic and FastAPI. (Ch. 5, Appendix C)

TypeScript — A typed superset of JavaScript that compiles to plain JavaScript. Adds optional static typing, interfaces, and other features. Widely used in modern web development. (Ch. 16)

Unit Test — A test that verifies the behavior of a single, isolated unit of code (typically a function or method). Should be fast, independent, and deterministic. (Ch. 21)

Vector Database — A database optimized for storing and querying embedding vectors. Enables semantic search -- finding items by meaning rather than exact text match. Used in RAG systems. Examples: Pinecone, Chroma, Weaviate. (Ch. 39)

Vibe Coding — A development approach where programmers express their intent in natural language and collaborate with AI to generate, refine, and ship code. Coined by Andrej Karpathy in February 2025. The central subject of this book. (Ch. 1)

Virtual Environment — An isolated Python environment with its own set of installed packages, separate from the system-wide Python installation. Created with python -m venv or tools like uv. (Ch. 4)

VS Code (Visual Studio Code) — A popular, extensible code editor by Microsoft. The foundation for Cursor and Windsurf (both forks). Supports AI coding through extensions like GitHub Copilot. (Ch. 4)

Webhook — A mechanism where one service sends an HTTP request to another service when a specific event occurs. Enables real-time integrations between systems. (Ch. 20)

WebSocket — A protocol that provides full-duplex communication channels over a single TCP connection. Used for real-time features like chat, live updates, and collaborative editing. (Ch. 19)

Windsurf — An AI-native IDE by Codeium (VS Code fork) featuring "Cascade" for multi-step agentic coding flows. (Ch. 3)

XSS (Cross-Site Scripting) — A security vulnerability where malicious scripts are injected into web pages viewed by other users. Prevented by output encoding and Content Security Policies. (Ch. 27)

YAML (YAML Ain't Markup Language) — A human-readable data serialization format commonly used for configuration files. Used by Docker Compose, GitHub Actions, and many other tools. (Ch. 29)

Zero-Shot Prompting — Asking the AI to perform a task without providing examples, relying on the model's training to understand what is needed. Contrasted with few-shot prompting. (Ch. 12)