Glossary of Dev & AI Terms

One concept per page, short enough to quote and linked to its deep-dive. Retired terms redirect to the page that absorbed them.

Pages

• ACID: Atomicity, Consistency, Isolation, Durability guarantees for transactions.
• Agent loop: Model call, tool run, and result feedback, repeated until no tool is requested.
• ai.txt: Proposed file declaring a site’s AI training and use preferences; advisory only.
• Atomic commit: One logical change per commit, revertible without collateral.
• BASE: Basically Available, Soft state, Eventually consistent trade-off model.
• Box Model: Content, padding, border, and margin areas of every CSS element.
• B-tree Index: PostgreSQL’s default index for equality, range, and ordering queries.
• Canonical URL: Preferred address for duplicated content, declared with rel=canonical.
• Cascade: CSS algorithm that resolves conflicting rules by origin, layer, specificity, and order.
• Chain-of-thought: Prompting a model to write reasoning steps before its answer.
• citext: PostgreSQL type for case-insensitive text comparison.
• CLS (Cumulative Layout Shift): Layout-stability metric; good is 0.1 or less (also layout shift).
• Code splitting: Loading JavaScript in smaller on-demand chunks.
• Completion: The text a model generates for a prompt; check stop_reason.
• Connection Pool: Reused database connections that avoid per-query setup cost.
• Container Query: CSS rules that respond to an ancestor’s size, not the viewport.
• Context window: Maximum tokens per request, input and output together.
• Conventional Commits: Structured commit prefixes that drive changelogs and version bumps.
• Core Web Vitals: LCP, INP, and CLS field metrics at the 75th percentile (also Web Vitals).
• CORS (Cross-Origin Resource Sharing): Browser mechanism controlling cross-origin reads through HTTP headers.
• Crawl budget: URLs Googlebot can and wants to crawl; matters only at scale.
• CSP (Content Security Policy): HTTP header listing trusted sources for scripts and resources.
• CSR (Client-Side Rendering): Rendering pages in the browser from JavaScript.
• CSS Flexbox: One-dimensional CSS layout along a single axis.
• CSS Grid: Two-dimensional CSS layout in rows and columns.
• Custom Property: CSS --name variables read with var().
• Deadlock: Transactions waiting on each other’s locks in a cycle.
• Debouncing and throttling: Delaying a call until activity pauses.
• Dependency injection: Supplying a component’s dependencies from outside.
• Distillation: Training a small student model on a larger teacher’s outputs.
• E-E-A-T: Google’s quality framework: experience, expertise, authoritativeness, trust.
• em vs rem: em scales from the element’s font size, rem from the root’s.
• Embedding: A vector that places similar meanings close together.
• Evaluation harness: The runner that scores a model against a fixed test set.
• Eventual Consistency: Replicas converge once writes stop, with no timing promise.
• Few-shot prompting: Examples in the prompt that teach a format by demonstration.
• Fine-tuning: Further training on curated examples for format, style, or task skill.
• Foreign Data Wrapper: PostgreSQL extension that queries external sources as local tables.
• Foreign key: A column referencing another table’s key to enforce integrity.
• GIN Index: PostgreSQL inverted index for JSONB, arrays, and full-text search.
• Golden set (eval set): Fixed hand-verified eval cases with ground truth (also eval set, ground truth).
• Guardrails: Checks in your code, outside the model, on inputs, tool calls, and outputs.
• Hallucination: Confident output unsupported by the input or facts, and its rate.
• Has Selector: CSS :has() relational (parent) selector.
• Hash routing: Client-side routes stored after # in the URL.
• Cold Storage: Tiering frequently and rarely used data to cut cost.
• Hydration: Attaching JavaScript behavior to server-rendered HTML.
• Idempotent: An operation that is safe to repeat with the same result.
• Immutable data: Data changed by creating new values, never edited in place.
• IndexNow: Push protocol that tells Bing, Yandex, and others when URLs change.
• INP (Interaction to Next Paint): Interaction-latency metric; good is 200 ms or less.
• ISR (Incremental Static Regeneration): Regenerating static pages in the background after a revalidation window.
• Jailbreak: User input that defeats safety training; distinct from prompt injection.
• JSONB Path: PostgreSQL jsonpath for navigating and filtering JSONB.
• LCP (Largest Contentful Paint): Loading metric for the largest element; good is 2.5 s or less.
• LLM-as-judge: A model scoring another model’s output against a rubric.
• llms.txt: Proposed Markdown index of a site’s key pages for LLM agents.
• Materialized Path: Storing each tree node’s full ancestor path as a string.
• Materialized view: Stored query results kept as an indexable table.
• MCP (Model Context Protocol): Open protocol exposing tools, resources, and prompts to AI clients.
• Monorepo and polyrepo: One repository holding multiple projects.
• Multimodal: Models that accept images or documents as well as text.
• MVCC (Multiversion Concurrency Control): Row versioning that gives each statement a consistent snapshot, so reads never block writes.
• N+1 query: One query for a list plus one more per row, so cost grows with list size.
• Optimistic locking: Detecting write conflicts at commit with a version counter.
• Partition Key: Column that routes each row to a partition or shard.
• Planner-executor: Agent design that separates planning from step execution.
• Prompt cache: Reusing a processed prompt prefix to cut cost and latency.
• Prompt injection: Attacker instructions smuggled in through untrusted content.
• Query Plan and Planner: The execution strategy the database chose for a statement.
• Read replica: A synchronized database copy that serves reads.
• Reasoning model: Models that think before answering, tuned by effort, not sampling.
• Replication Lag: Delay before a primary’s write is visible on a replica.
• Reranker: Cross-encoder that reorders retrieval results by joint relevance.
• Retrieval-augmented generation (RAG): Retrieving passages at query time to ground answers (also RAG).
• Secondary index: An index on non-primary-key columns.
• Semantic cache: Reusing stored answers for semantically similar prompts.
• Semantic versioning (SemVer): MAJOR.MINOR.PATCH numbering that signals breaking changes.
• Sequential Scan: Reading every row of a table in storage order.
• Server component: React component that renders only on the server.
• Sharding: Splitting a database horizontally across nodes.
• Side effect: A state change outside a function’s return value.
• Specificity: CSS weight that decides which rule wins.
• SSG (Static Site Generation): Pre-rendering pages to static HTML at build time.
• SSR (Server-Side Rendering): Generating HTML on the server for each request.
• Stop sequence: A string that halts generation when the model emits it.
• Structured output: Schema-constrained model output plus validation (also structured prompt, schema-validated).
• Suspense boundary: React boundary that shows a fallback while children load.
• System prompt: Operator instructions setting role, rules, and format (also system message, role priming).
• Temperature: Sampling randomness control; rejected by most current Claude models.
• Token: The unit of text models read, bill, and limit by.
• Tool use (function calling): A model requesting function calls that your code runs (also function calling, tool call, tool result).
• Top-p (nucleus sampling): Nucleus sampling cutoff, with the same availability limits as temperature.
• Transaction isolation: How visible concurrent transactions’ changes are to each other.
• Tree shaking: Removing unused ES module exports at bundle time.
• Twelve-factor app: Twelve rules for portable, deployable web services.
• Vacuum and autovacuum: PostgreSQL command that reclaims space from dead tuples.
• Vector similarity: Cosine, dot product, or L2 closeness between embeddings.
• Viewport: The visible area of a page in the browser.
• Virtual DOM: In-memory DOM tree diffed to minimize real DOM changes.
• Write-ahead log (WAL): Sequential change log written before the data files.
• Write Amplification: Physical bytes written per logical byte.