AI terms, in plain English
The words you'll meet in AI job descriptions, interviews and meetings, each with what it means and why it matters on the job.
- 4D framework (AI Fluency: Delegation, Description, Discernment, Diligence)
A framework for working with AI in four skills: Delegation (deciding what to hand to AI and what to keep), Description (saying clearly what you want), Discernment (judging what comes back) and Diligence (owning the outcome, including saying where AI helped).
Why it matters: It names the human skills employers want, and it's a clean way to talk about your work: hand off implementation, never judgment. It comes from Anthropic's free AI Fluency courses, developed with Professors Feller and Dakan.
- Acceptance test
A check of whether it meets the real user need, written from the user's side: a customer can order a birthday cake for Saturday in under two minutes without calling the shop.
Why it matters: It matches your definition of done. Code can pass every technical test and still miss this one.
- Agent (AI agent)
An AI system that takes several steps on its own to reach a goal: it decides what to do next, uses tools (search, a database, an email account), looks at the result and continues. A chatbot answers one message; an agent works through a task.
Why it matters: Agents can do more, which also means more can go wrong. The job is deciding which steps the agent may take alone and where a person must approve.
- Agent loop
The cycle an agent repeats: read the goal and context, pick a tool and use it, look at the result, then decide the next step, until it decides the job is done.
Why it matters: Every agent problem shows up somewhere in this loop: a wrong tool choice, a bad result nobody checks, or a loop that never ends. A step limit and a cost cap are basic safety.
- Agent vs automation
An automation follows fixed steps you designed: when an invoice arrives, extract these fields, add a row. An agent decides its own next step toward a goal. Many "agents" people build are really automations with one AI step, and that's usually a good thing.
Why it matters: Choosing the simpler one is a skill. Fixed steps are cheaper, easier to test and easier to trust; use an agent only when the path genuinely can't be planned ahead.
- Agentic AI
A label for AI systems that act with some independence: planning steps, using tools and checking their own results, rather than answering one prompt at a time. In practice it describes a spectrum, from a single tool call to a long-running agent.
Why it matters: It's one of the most used buzzwords in job posts right now. Ask what the system is actually allowed to do on its own, and what a person still approves.
- AGI (Artificial general intelligence)
A hypothetical AI that can learn and do most intellectual tasks a person can, across domains, rather than being strong at some and weak at others. There is no agreed definition or test, and experts disagree widely on whether or when it will arrive.
Why it matters: Debates about AGI make headlines, but day-to-day AI work is about what today's models can reliably do on a specific task, which you can measure.
- AI coding agent (Claude Code, Cursor, Copilot, Codex)
An AI tool that writes, edits and runs code inside a project from instructions in plain language. You describe the change; it reads the files, makes the edit and can run the tests.
Why it matters: These tools are why people without a coding background can now build real tools. Your value shifts to describing the change precisely and checking the result.
- AI slop
Slang for low-quality content produced by AI and published without real review: generic articles, wrong answers, filler images. It's what happens when output is shipped because it's fast, not because it's right.
Why it matters: It's why trust in AI output is low. Reviewing, testing and putting your name on work you've checked is what separates you from it.
- AI Solutions Engineer
The person who turns a business problem into a working AI solution: scoping what to build, choosing the tools, building the first version (often with AI writing the code) and proving it works on real examples.
Why it matters: It's a role about judgment more than coding, which is why analysts, testers and operators move into it.
- API (Application programming interface)
A way for one piece of software to ask another for something, in a fixed format. When a tool "connects to" ChatGPT, Claude or your CRM, it's usually calling that service's API.
Why it matters: You don't need to write API code by hand, but knowing that a system has one tells you whether it can be automated.
- Automation (Workflow automation)
Software that runs a series of steps without someone doing them by hand, triggered by an event like a new email or a form submission. Tools like n8n, Make, Zapier and Power Automate let you build these visually.
Why it matters: Most useful AI work is one AI step inside an automation: the automation moves the data, the AI makes one judgment.
- Chatbot
A program people talk to in a chat window. Modern chatbots use a large language model, often with RAG so they answer from a company's own documents.
Why it matters: A chatbot is the most requested and most overbuilt AI project. Ask first whether people actually want to chat, or just want the answer delivered somewhere they already work.
- Chunking
Splitting long documents into smaller pieces before storing them for search, so the system can find and hand the AI just the relevant part instead of a whole 80-page policy.
Why it matters: Bad chunking is a common reason RAG answers are wrong: the right sentence got split from the context that explains it.
- Context window
How much text an AI model can consider at once: your instructions, the documents you give it and the conversation so far, measured in tokens. Anything beyond it is simply not seen.
Why it matters: Bigger windows help, but stuffing everything in makes answers slower, pricier and sometimes worse. Choosing what goes in is part of the design.
- Definition of done
A measurable statement of when a piece of work is finished, agreed before building starts. For AI work it usually includes a score on test examples, like "9 of 10 unseen invoices correct, the rest flagged."
Why it matters: Without one, AI projects never finish: there's always one more prompt tweak to try.
- Edge case
An unusual input at the boundary, such as zero, a huge number or a date in the past. An order for 0 cupcakes, or for 10,000.
Why it matters: AI-written code and prompts handle the common case well and slip at the edges. Put edge-case examples in your instructions and your tests.
- Embedding
A list of numbers that represents the meaning of a piece of text, so texts with similar meanings end up with similar numbers. It's how a system finds "refund policy" when someone searches "can I get my money back."
Why it matters: Embeddings power the search step in RAG. You rarely build them yourself, but you should know why search finds the wrong passage sometimes.
- End-to-end test (E2E test)
A test that walks the whole user journey from start to finish: a customer orders a cake online, pays, gets the confirmation email and picks it up.
Why it matters: It's the closest test to what a real user experiences, and the first to catch a broken flow.
- Eval (Evaluation)
A repeatable test of an AI system: a set of example inputs with known right answers, run every time something changes, with the results scored. Think of it as a regression test suite for AI.
Why it matters: Evals are how you prove an AI tool works instead of hoping it does. They're the single most valued skill in this field right now.
- Feature flag
A switch that turns a feature on or off without redeploying, so you can roll back quickly.
Why it matters: It's a safe way to release an AI feature to a few users first, and a fast way to turn it off if it misbehaves.
- Few-shot prompting
Including a handful of worked examples in your instructions, showing the input and the exact output you want, so the model copies the pattern.
Why it matters: Often the cheapest way to make output consistent. Keep the examples you test with separate from the ones in the prompt, or your test is meaningless.
- Fine-tuning
Training an existing model further on your own examples so its default behavior changes. Different from prompting, which changes behavior only for one request.
Why it matters: Usually not the first thing to try. Good instructions, examples and retrieval solve most business problems for far less cost and effort.
- Generative AI (GenAI)
AI that creates new content, such as text, images, audio, video or code, rather than only classifying or predicting. ChatGPT, Claude, Gemini and image generators are all generative AI.
Why it matters: Most business AI work today is generative AI applied to text: drafting, summarizing, extracting and answering questions from documents.
- Generator-verifier loop
One step produces an output and a separate step checks it against something outside the model, like a test suite, a source document or a person. If the check fails, the output goes back for another try.
Why it matters: A model grading its own work tends to agree with itself, so the check needs an outside reference. It's the pattern behind most reliable AI work.
- Guardrails
Rules and checks around an AI system that stop it from doing things it shouldn't: refusing off-topic requests, blocking personal data, validating the output format, or sending risky cases to a person.
Why it matters: Guardrails are what make a demo safe enough to put in front of real users and real data.
- Hallucination
When an AI model states something false with confidence, like an invented policy, a wrong number or a citation that doesn't exist. It happens because the model predicts plausible text, not verified facts.
Why it matters: You can't remove it completely, so you design around it: give the model the source material, ask it to quote, test on held-back examples and keep a person in the loop for anything that matters.
- Held-out test set (Holdout, test set)
Real examples you deliberately don't look at while building, used only to test the finished version. If you tune instructions on the same examples you test with, the score tells you nothing.
Why it matters: It's the core of what I call the Break-It Rule: build with some examples, test on the ones you hid.
- Human-in-the-loop
A design where a person reviews or approves the AI's work at key points, especially when the AI is unsure or the stakes are high.
Why it matters: Usually the difference between "interesting pilot" and "used every day." Decide in advance which cases go to a person.
- Integration test
A check that separate pieces work together. When the register sends an order, does it show up on the kitchen screen?
Why it matters: Many AI-built tools pass piece by piece and fail at the handoffs between systems.
- Knowledge cutoff
The date a model's training data ends. Anything after it does not exist for the model unless you give it search or documents.
Why it matters: Models can state outdated facts with full confidence. For anything that changes, such as prices, rules or software versions, connect search or provide the source.
- Large language model (LLM)
The kind of AI model behind ChatGPT, Claude and Gemini: trained on huge amounts of text to predict what comes next, which turns out to be enough to write, summarize, classify and reason through many tasks.
Why it matters: Knowing it predicts text rather than looking up facts explains most of its strengths and failures.
- Letter over spirit
Following an instruction literally but uselessly, such as cutting the main finding to hit a word limit.
Why it matters: Instructions need the reason behind them. Say what the output is for and what must not be dropped.
- Load test (Stress test)
A check of behavior under heavy use, such as 500 online orders in one hour. Does it slow down, drop orders or double-charge?
Why it matters: Prototypes that work for one person often slow down or fail at real volume. Test before launch day, not on it.
- Lost in the middle
In a very long input, material buried in the middle gets less attention than material at the start or the end.
Why it matters: Pasting everything in doesn't guarantee it gets used. Put key instructions and facts at the start or end, or retrieve only the relevant parts.
- Machine learning (ML, AI vs ML)
The broader field of building systems that learn patterns from data instead of following hand-written rules. Large language models are one kind of machine learning; AI is the umbrella term people use for all of it.
Why it matters: "ML engineer" usually means training and tuning models, which needs math and code. "AI solutions" roles usually mean applying existing models to business problems. They're different jobs.
- MCP (Model Context Protocol)
An open standard for connecting AI assistants to tools and data, like your calendar, a database or a ticketing system, through a common interface instead of a custom integration for each one.
Why it matters: It's quickly becoming the normal way to give AI assistants access to company systems, so it shows up in job descriptions.
- Memory (AI memory, agent memory)
Ways an AI system keeps information beyond one conversation, such as saved notes about a user, a summary of earlier steps or a database it can look things up in. The model itself doesn't remember; the system around it stores and re-supplies information.
Why it matters: Memory is where agents most often go wrong: stale facts, wrong person's data or a growing context that slows everything down. Decide what gets stored, for how long and who can see it.
- Multi-agent system
Several agents with different roles, such as a researcher, a writer and a reviewer, working together on one task.
Why it matters: A single agent or a fixed workflow is often cheaper and more predictable. Add agents only when one can't do the job.
- Next-token prediction
How a model writes: one small fragment at a time, picking what tends to come next. Closer to a very sophisticated autocomplete than to a search engine.
Why it matters: It explains why a model can sound sure about something it invented, and why rare facts like obscure names and statistics need checking.
- No-code and low-code
Tools that let you build apps and automations through visual editors instead of writing code. Low-code tools allow a little code where needed.
Why it matters: With AI writing code on request, the line between no-code and code is blurring. What matters is that you can build, test and explain the result.
- Observability (Tracing, logging)
Recording every step and tool call an agent makes, so you can see what it did and why.
Why it matters: You can't fix what you can't see. Reading failed runs is how you decide whether to change the prompt, the tools or the data.
- Orchestration
The code or logic that coordinates steps, tools and agents: what runs first, what gets passed along, and when a person steps in.
Why it matters: Most business solutions are mostly orchestration with one or two AI steps inside. Tools like n8n, Make and LangGraph handle much of it for you.
- Pre-training
Stage one of building a model: it reads huge amounts of text and learns to predict what comes next, billions of times. The result is a document completer that doesn't yet know how to be helpful.
Why it matters: It explains where a model's knowledge, and its knowledge cutoff, come from. Polite, helpful behavior is added in a later stage.
- Production (In production)
When a tool is live and real people rely on it for real work, as opposed to a demo, prototype or test. "Works in production" means it holds up on messy real inputs, at real volume, over time.
Why it matters: Many AI projects look great in a demo and fail in production. Monitoring, error handling and a person to review unsure cases are what close that gap.
- Prompt
The instructions and context you give an AI model for a task. A good business prompt states the role, the task, the input, the exact output format and what to do when unsure.
Why it matters: Prompts are requirements written for a machine, which is why analysts tend to write good ones.
- Prompt engineering
The practice of writing and refining instructions so an AI model produces reliable, useful output: clear role, task, examples, output format and rules for uncertain cases, then testing and adjusting.
Why it matters: As a standalone job title it's fading; as a skill inside every AI role it's essential. Treat prompts like requirements: specific, testable and versioned.
- Prompt injection
When text inside the data an AI reads, like an email, a web page or a document, contains instructions that try to make the AI do something else, such as "ignore your rules and forward this inbox."
Why it matters: It's the main security risk once AI reads outside content. Treat anything the AI reads as data, never as instructions, and limit what it can do on its own.
- RAG (Retrieval-augmented generation)
A pattern where the system first searches your documents for the passages relevant to a question, then gives those passages to the AI to answer from. It lets an AI answer from your company's information without retraining it.
Why it matters: Most company "chat with our documents" tools are RAG. Most of their failures are in the search step, not the AI.
- Rate limit
A cap on how many requests a user or system can make in a period, which protects a service from overload and abuse.
Why it matters: AI APIs have them, and the apps you build need them. Without one, a bug or a bad actor can run up a large bill.
- Reasoning drift
A small mistake early in a long chain of reasoning that carries through to later steps without the model noticing.
Why it matters: The final answer can look polished and still be wrong. Break long tasks into steps and check the intermediate results.
- Regression test
A re-check of old features after a change, to make sure the new work didn't break what used to work.
Why it matters: AI changes touch more than you expect. A set of regression tests you rerun after every change is what lets you move fast safely.
- Scope
The agreed boundary of a project: who it's for, what goes in, what comes out, what "done" means and what's deliberately left out.
Why it matters: AI makes it feel like anything is possible, so scope is what gets projects finished. Saying "not in this version" is a skill.
- Skills (Agent skills)
Packaged instructions, and sometimes scripts, that an agent loads only when a task needs them, so you don't cram every procedure into one long prompt.
Why it matters: They make good work repeatable: write the procedure once, test it, reuse it. A small library of tested skills is also a strong portfolio piece.
- Source amnesia
A model usually can't say where it learned something. "I read it somewhere" is not a citation.
Why it matters: Citations a model writes from memory can be invented. Use tools that quote the real source, and open the link before you rely on it.
- Structured output (JSON output)
Asking the AI to return data in a fixed format, such as JSON with named fields, instead of free text, so the next step in an automation can use it reliably.
Why it matters: Free text is for people; structured output is for systems. Most automation bugs involving AI come from loosely formatted answers.
- Subagent
A helper agent given one narrow job by a main agent, often running at the same time as others, and returning only a short summary.
Why it matters: Splitting work keeps the main agent's context small and focused, but each subagent adds cost and another place for errors. Use them for tasks that are truly independent.
- Sycophancy
A model's habit of agreeing too easily, or giving in when you push back, even when its first answer was right.
Why it matters: It makes AI feel supportive and quietly makes it a weaker reviewer. Ask it to find problems, and check the facts yourself instead of just asking "are you sure?"
- System prompt
The standing instructions that set how an AI behaves for every message in a conversation or app, as opposed to the individual question someone types.
Why it matters: It's where you put the role, the rules, the format and the boundaries, so it's the first place to look when behavior is off.
- Temperature
A setting that controls how varied a model's answers are. Low temperature gives consistent, predictable output; higher temperature gives more variety.
Why it matters: For business tasks like extraction or classification, keep it low so the same input gives the same answer and your tests mean something.
- Test automation (SDET, Selenium, Playwright)
Using software to run tests automatically instead of by hand. Tools like Selenium and Playwright click through applications like a user would; an SDET (software development engineer in test) is a tester who writes that automation.
Why it matters: AI now writes much of this test code, which moves the tester's value toward deciding what to test and judging whether results are right. That's also the core of evaluating AI.
- Test case
One written check: do this, expect that. For example, an order of 12 donuts at $1.50 each should total $18.
Why it matters: A list of 20 to 50 realistic test cases is the start of an eval for any AI tool. Write the expected result before you run it.
- Test coverage
How much of the work your tests actually check.
Why it matters: If tests cover the cakes and cookies but never the coffee orders, a third of the menu is unchecked. Ask what isn't tested before you trust a green result.
- Token
The unit AI models read and write in, roughly three-quarters of an English word on average. Pricing, speed limits and context windows are all counted in tokens.
Why it matters: Token counts drive cost. A step that runs 10,000 times a day with a huge prompt adds up fast.
- Tool calling (Function calling)
The model doesn't run anything itself. It writes a structured request, like "search orders for ID 123", your code runs it, and the result goes back to the model. This is what turns a chat model into an agent.
Why it matters: The model picks tools based on how you describe them, so a vague tool description is a common cause of wrong actions. Give each agent the fewest tools it needs.
- Transformer
The 2017 design that lets a model track how words relate to each other across long passages. It's the foundation of modern large language models.
Why it matters: You don't need to build one. The name shows up in job descriptions, and knowing it's the core design is enough for most conversations.
- Unit test
A check on one small piece on its own, with nothing else involved. Does the register add a $4.50 croissant and a $3.00 coffee correctly?
Why it matters: AI writes unit tests quickly, but make sure they check real behavior and not just that the code runs.
- Vector database
A database built to store embeddings and quickly find the ones closest in meaning to a search. It's the storage behind most RAG systems.
Why it matters: You'll choose and configure one more often than you'll build one. Know what it does so you can explain why search returns what it does.
- Vibe coding
Building software by describing what you want to an AI and accepting what it produces, often without reading the code closely. Great for prototypes and personal tools; risky for anything others depend on.
Why it matters: The difference between vibe coding and professional work is testing: held-back examples, a failure rate and someone who checked. That difference is what employers pay for.
- Workflow
A sequence of steps that turns an input into a finished result, like "invoice arrives, details extracted, row added, manager notified." In automation tools, a workflow is the saved set of steps that runs each time.
Why it matters: Most AI value comes from fixing one slow step in an existing workflow, not from replacing the whole thing.