Glossary

Every term the program uses, in plain language.

New here? Read the free first lesson. No account needed.

AI concepts

Agent: An AI system that takes multiple steps on its own toward a goal, choosing tools and adapting as it goes.
AGI: Artificial general intelligence, a hypothetical AI as capable as a person across most tasks. Much debated and not here yet.
Closed model: A proprietary model you can reach only through a provider's API or app.
Coding agent: An AI assistant with hands. It reads files, edits them, and runs commands, checking results as it goes.
Compaction: Summarizing earlier parts of a conversation to free up space in the context window.
Completion / response: What the model sends back after your prompt.
Context: Everything the model can see right now: your prompt, the conversation, attachments, and any injected notes.
Context rot: A loop failure where history grows until the signal drowns. Fix it by summarizing old turns and pinning the goal.
Context window: The most tokens a model can hold at once, covering your prompt plus everything it has already read.
Embedding: A numerical representation of text that lets a system search by meaning instead of exact words.
Embedding models: Models that turn text into numbers so tools can search it by meaning. They work under the hood of assistants connected to your documents.
Fine-tuning: Extra, specialized training on top of a base model to fit a specific use case.
Frontier model: The biggest, newest, most capable model a provider offers.
Generation: The final RAG step: stuffing retrieved chunks into the prompt and letting the AI answer using that context.
Gradient descent: The training process where a model slowly adjusts billions of internal parameters until it predicts the next word well.
Image models: Models that generate images from text descriptions, like DALL-E, Midjourney, or Stable Diffusion.
Inference: Each time you actually use the model. You send a prompt, it runs through frozen parameters and produces output.
LLM: Large language model, the technology behind chat assistants like ChatGPT, Gemini, and Claude.
Long context: How much an assistant can hold in one conversation. A long context fits the equivalent of a small library at once.
MCP (Model Context Protocol): A standard way for AI apps to plug into outside tools, data, and services. Think USB for AI.
Memory: A feature that saves selected facts about you and places them back into context at the start of future conversations.
Multimodal: Models that handle more than text, like images and sometimes audio or video.
Next-word prediction: How an LLM works at its core. It predicts the most likely next word over and over to form a useful response.
Open weights: A model whose parameters you can download and run yourself.
RAG (Retrieval-Augmented Generation): The system searches your documents or the web first, then the model answers from what it found.
Session: One continuous conversation. A new chat starts with an empty context.
Source corpus: Where the truth lives for a RAG setup: the pages, docs, contracts, or past tickets you retrieve from.
Speech models: Models that convert speech to text and back, like Whisper for transcription and ElevenLabs for voice synthesis.
System prompt: Instructions that set the AI's role and rules at the start of a conversation.
Token: The small chunks of text an assistant reads and writes, roughly 3/4 of a word. Length and cost are counted in tokens.
Tool: A connector that lets AI do something beyond writing text, like search, calculate, or reach another system.
Training: The expensive, one-time process where a model learns patterns from huge amounts of text. Providers do this, you don't.
Training cutoff: The date after which a model knows nothing from training, so it misses later events unless you tell it.

Prompting & techniques

AI step: A process step that needs judgment varying with the input. Spend your AI budget here.
Always-on layer: The small set of things read every turn: hard constraints, house rules, and the active task.
Chain (prompt chaining): A sequence of prompts where each output becomes the next input. You manage the chain while the AI runs each stage.
Chain of thought: Asking the model to reason step by step before answering, which improves accuracy on multi-step problems.
Chunking: Breaking a corpus into bite-sized pieces (256 to 512 tokens, with 10 to 20% overlap) so they can be retrieved.
Determinism vs judgment: Determinism means a step gives the same output every time. Judgment means a step can legitimately vary. Mark each stage.
Deterministic step: A process step handled by fixed logic: a formula, a database property, or a script.
Few-shot: Giving the model a few examples of the input to output pattern you want, which boosts reliability.
Four-Element Framework: The reliable prompt structure Role, Context, Task, Format (also called CRAFT or RCTF).
Golden rule: Give the AI as much context as possible, always. Better inputs reliably produce better outputs.
Handoff (the seam): The moment one step's output becomes the next step's input. Most chain breaks happen here, so put checks at the seam.
Iterative refinement: Treating AI as a conversation and improving the output over a few rounds instead of expecting the first draft to be perfect.
Meta-prompting: Asking the AI to critique and rewrite your prompt so it produces more reliable output.
Multi-step prompting: Break work into stages instead of one big prompt. Each stage produces a clean, named output the next uses.
Negative constraints: Telling the AI what not to do. This pushes against its defaults and is often easier than describing what you want.
On-demand loading: Loading schemas, specs, runbooks, or docs only when a task needs them, fetched by name.
Output formatting: Keeping intermediate outputs machine-friendly (tables, JSON, consistent fields). Free-form prose breaks chains.
Persona: Assigning the model a role to raise its quality bar. It shapes how the model answers, leaving whether it's right unchanged.
Persona prompts: Give each stage a role (a paralegal, a compliance officer). The persona shifts vocabulary, depth, and tone.
Plan, then execute: Asking the model to plan and flag gaps first, then produce the deliverable, so it doesn't fill gaps with guesses.
Pre-filling the response: Starting the AI's answer for it, which locks in the format and tone and cuts down on drift.
Process decomposition: Breaking a multi-team process into steps and deciding which are AI, deterministic, or need a human.
Progressive disclosure: Loading a little always and the rest only when relevant. Keep the always-on layer small.
Prompt: What you type to an assistant. Prompting is the craft of asking well.
Prompt journal: A saved collection of prompts that worked, built up over time into reusable templates for your own work.
Retrieval: Picking the right chunks for a query. Hybrid retrieval (semantic plus keyword) with a reranker is the production default.
Role stacking: Having the AI analyze something from several expert viewpoints in turn, then synthesize one recommendation.
Structured outputs: Asking for a specific schema like JSON or a table, so the output is clear and easy for other tools to reuse.
Zero-shot: Asking the model to do a task with no examples. Fine for simple, well-known tasks.

Building & shipping

50-Inputs Rule: Test an agent on 50 different real inputs before trusting it to run unattended. Categorise every failure.
Agent loop: The runtime cycle: read context, decide, call a tool, read the result, decide again, until the task is done.
AGENTS.md: The cross-tool standard instruction file. Put your conventions here as the single source of truth.
Anatomy of a brief: The parts a good agent brief needs: role, trigger, inputs, steps, output format, and guardrails.
Branch: A parallel line of work inside the same repo. You experiment on a branch without disturbing the main one.
Budget cap: A stop condition setting a hard ceiling on turns, tokens, or tool calls.
Changelog: A short running note at the bottom of a brief recording each version's changes, so others see how it evolved.
Checkout: Switching your working folder to show a particular branch or commit. Same repo, different view.
CLAUDE.md: Claude Code's instruction file, at the project root or in ~/.claude for global. Often a pointer to AGENTS.md.
Commit: One saved change, with a note saying what changed and why. A repo's history is a chain of commits.
Context budget: Treating the context window as a budget you allocate on purpose, spending the most on what changes the answer.
Cost: The price of every token in money, latency, and diluted attention.
Cost per useful output: Total spend divided by outputs that didn't need rework. The spend metric to internalise.
Coverage: A force in harness design: giving the model enough to act correctly. Too little and it guesses or invents an API.
Deferred tools: Listing tools by name and letting the model pull a full definition on demand, keeping context lean.
Design flaw: A failure rooted in the workflow's architecture. The fix is to re-stage or redesign it.
Edge cases: Inputs that are valid but unusual. A brief should say what to do about missing fields, contradictions, and sensitive data.
Forking: Copying someone's shared agent or assistant and adapting it, inheriting the lessons the original author learned.
Format drift: The AI returns output in a slightly different shape than specified, breaking anything downstream that expected the exact format.
Frontmatter: A small YAML block at the very top of a file, holding facts about the file itself.
Goal test: A stop condition the agent runs rather than asserts: the build passes, or the endpoint returns 200.
Harness: Everything you build around a model: the context you feed it, the tools it can call, and the loop it runs in.
Hidden context: System prompts, reference files, conversation history, and retrieved chunks all spend tokens on every run.
Idempotency: An agent is idempotent if running it twice on the same input is safe. It produces the same output or skips.
Infrastructure (vs a tool): A build many people depend on. At that scale it needs a named owner, documented behavior, HITL gates, and a maintenance plan.
Instruction file: A file of standing rules an agent reads before it starts working. AGENTS.md is the common name.
Maintenance plan: A short document naming the owner, a backup, review cadence, known failure modes, and how to test changes.
Maturity tiers: Labels for shared workflows: try-at-your-own-risk, featured (reviewed), and official (maintained, production-grade).
Merge: Folding a branch's changes back into the main line once they're ready.
Model limitation: A failure where the AI isn't reliable enough at the task. The fix is a deterministic check or a tighter HITL gate.
Output dominance: Output tokens typically cost 3 to 5 times more than input tokens, so a verbose default multiplies spend fast.
Output schema: A precise written definition of an output's fields and types, set before writing the prompt.
Production-ready: A workflow tested on real inputs, with failure modes and HITL gates in the brief, documented, owned, and logged for drift.
Pull request: A bundle of commits offered for review before it merges.
Recall: How reliably the model acts on a given rule. Rules buried in the middle of a long context get missed.
Reference files: Stable documents (regulations, style guides, glossaries) attached to a custom assistant so it reasons with them consistently.
Repository (repo): A project folder with a memory. It holds files, tests, and a log of every change, so nothing is ever really lost.
Seam: The point where information passes from one person, team, or system to another. Seams leak time and quality.
Seam map: A map of a process's handoffs: who hands off, who picks up, what's lost, the time cost, and where AI could fit.
Skill: A bundle of instructions and reference material that teaches an assistant to do one job well, reusable in every future chat.
SKILL.md: A skill's one required file: YAML frontmatter (name and description) at the top, then the procedure in the body.
Symlink: A shortcut file that points at another file, so one real copy can appear in several places.
Templating with variables: Production briefs are templates with named variables, which makes them inspectable, versionable, and forkable.
Terminal (shell): The text window where you type commands instead of clicking buttons. Coding agents live here.
Test suite: A project's self-checks, run by a single command that reports pass or fail.
The build rule: When you find yourself doing the same work twice, build it as an agent so the third time it runs itself.
Triggers: How an agent starts: on a schedule, on demand, or on an event like a new database row.
Trusted inputs: Inputs already validated upstream, like a database row with an enforced schema. You can act on them.
Usable vs accurate: Usable means downstream stages can parse the output. Accurate means the content is correct. Both matter.
Validation stage: The first chain stage that checks each required field is present and valid. If a check fails, it stops and flags a human.
Vibe coding: Building something by describing what you want in plain words and letting AI write the code, steering by feel.
Worktree: A second working copy of the same repo in its own folder, with its own branch, so two efforts never trip over each other.
YAML: Settings written as labeled lines, like name: pdf-export. Read it like a form rather than like code.

Risk & safety

Adversarial testing: Deliberately feeding an agent tricky, conflicting, incomplete, or malicious inputs during testing to find where it breaks.
Adversarial verification: Splitting making from judging. One pass creates, another attacks with orders to refute, and only what survives ships.
AI slop: Low-effort, mass-produced AI text or images. The thing good prompting avoids.
Always-HITL actions: Things that always need human sign-off: money, health, safety, contracts, legal terms, government submissions, legal status.
Audit logs: A record of every MCP tool call with timestamp, caller, scope, and result. What you check to see what the AI did.
Auto-pause: A circuit breaker that halts an agent when sampled accuracy drops below a set threshold, until a human re-enables it.
Blast radius: The range of systems an agent can affect if something goes wrong. A connected agent needs tighter gates.
Confidence calibration: Making the AI rate its own confidence (high, medium, low) with a reason, so you know which outputs need review.
Confidence floor: A threshold below which the agent stops and escalates instead of acting.
Confidently wrong: An answer that sounds authoritative but is wrong in a subtle way, with the same tone as correct answers.
Data hygiene: Habits for handling private information with AI. Keep sensitive data where it lives rather than pasting it into a tool you don't control.
Drift: When a model's outputs slowly degrade because the input pattern shifted. Silent, and only visible across many outputs.
Drift (loop): A loop failure where the agent forgets the goal and optimizes a sub-task. Restate the goal near the end of context.
Escalation path: The defined route for a flagged case: who gets notified, how, and with what context. Every HITL gate needs one.
Guardrails: Rules and checks that stop AI from doing risky things.
Hallucination: When an assistant states something false with full confidence. Always worth a quick check.
HITL gate: A human-in-the-loop checkpoint where a person reviews before the agent acts. Required for irreversible or low-confidence actions.
Human-in-the-loop (HITL): A person reviews or approves AI output before any action, especially on steps that are regulated, irreversible, or high-impact.
Jailbreak: A prompt crafted to bypass an AI's safety guardrails. Don't try it; guardrails protect you and others.
No progress: A loop failure where the agent retries the same failing action. Track what's been tried and cap retries.
Prompt injection: Malicious instructions hidden inside content the AI reads, trying to hijack what it does.
Revocation: Removing an MCP connection's scopes when a workflow is retired, so dormant connections don't accumulate.
Scopes: Per-action permissions an MCP server exposes, like read_employees separate from update_employee. Grant only the minimum.
Spot-checking: Sampling a share of a workflow's outputs (say 10%) and reviewing them yourself.
The hard rule: Never paste bank details, credentials, government IDs, or anything private and not yours into a general AI tool.
Wrong stop: A loop failure where the agent quits early or never quits. Fix it with an explicit termination test.

Tools & assistants

AI agent: A saved brief that runs a recurring job on its own, on a schedule, on demand, or on an event.
AI assistant: Your standalone chat tool (ChatGPT, Gemini, Claude, or Grok). Reactive: you ask, it answers.
Artifacts: A Claude feature that generates code, documents, slides, and interactive outputs in an editable side panel.
Automation platform: A no-code tool (Zapier, Make) that copies data between apps on a schedule.
Built-in (in-app) assistant: AI built inside an app you already use, like Gmail, Notion, or Word. It acts on the open page.
ChatGPT: OpenAI's assistant, free at chatgpt.com. A dependable all-rounder with the largest user community.
Claude: Anthropic's assistant, free at claude.ai. Strong for long-form writing, heavy document analysis, and hard reasoning.
Claude Projects: Persistent Claude workspaces holding reference documents Claude remembers across every conversation.
Co-pilot: AI that works beside you inside a tool, suggesting as you go while you stay in control.
Connectors: Links that let Claude connect to tools like Drive, Gmail, Slack, GitHub, and Linear, with your permission.
Custom GPTs: ChatGPT's saved, reusable assistants that you configure once and reuse.
Deep Research: A mode that runs an extended, multi-source investigation over several minutes and returns a written, cited report.
Gemini: Google's assistant, free at gemini.google.com. Strongest when input is large, mixed, or visual, and runs inside Google Workspace.
Gems: Gemini's saved, reusable custom assistants that you configure once and reuse.
Grok: xAI's assistant, free at grok.com. Wired into X and the live web, strongest on current events.
Saved (reusable) assistant: A custom assistant you configure once and reuse, such as a Custom GPT, Gem, or Claude Project.
Workspace-integrated agent: An agent that lives inside a tool like Notion, reading and writing its pages and databases.

Working with AI

AI fluency: The ability to work with, build on, and think alongside AI. The highest-return skill of the decade.
AI-first default: Spending 30 seconds on every new task thinking about how AI could help before doing it manually.
AI-pilled: Won over by AI. Once it clicks for one task, you start reaching for it everywhere. Usually said with a wink.
Cross-checking: Run the same important question through two tools and compare. Agreement raises confidence; disagreement flags something to investigate.
Everyone is a builder now: Anyone who builds a workflow with AI is a builder, whatever their job title.
Relearn to learn: The meta-skill of continuing to learn as old expertise gets automated. The new moat.
The 100x mindset: The new pace: months become days, days become hours. New things become possible when cost drops 100 times.
The 80% rule: Start with your AI assistant for everything. The in-app tool is a handy shortcut you can skip.
Work must disappear: The mindset that AI should erase whole categories of work, deleting tasks outright.