The AI concepts every engineer should know.

1. 01

   Generative AI

   Remember it as
   “The artist, not the critic”

   Got it: Generative AI

   In one line

   AI that creates new content, such as text, images, code, audio or video, instead of only analyzing data.

   Think of it like

   The difference between a critic and an artist. Older AI judged things (“is this email spam?”). Generative AI makes things (“write me a reply”).

   Why it matters

   It is the umbrella for ChatGPT, Claude, Gemini, image generators and coding assistants. Every other concept here sits under it.

2. 02

   Large Language Models (LLMs)

   Remember it as
   “Autocomplete, scaled a million times”

   Got it: Large Language Models (LLMs)

   In one line

   A model trained on huge amounts of text that predicts the next word, and through that learns to write, reason and answer.

   Think of it like

   Your phone’s autocomplete, scaled up a million times. It has read so much that predicting the next word starts to look like understanding.

   Why it matters

   LLMs are the engine inside almost every AI product today. Knowing they predict, rather than look up facts, explains both their power and their mistakes.

3. 03

   Tokens & Tokenization

   Remember it as
   “The LEGO bricks of text”

   Got it: Tokens & Tokenization

   In one line

   Tokens are the small chunks of text a model actually reads; tokenization is how text gets cut into them.

   Think of it like

   LEGO bricks. The model never sees whole sentences, only bricks. “Unbelievable” might become “un” + “believ” + “able”. In English, one token is roughly three-quarters of a word.

   Why it matters

   You pay per token, limits are counted in tokens, and speed is measured in tokens per second. Tokens are the currency of AI.

4. 04

   Embeddings

   Remember it as
   “GPS coordinates for meaning”

   Got it: Embeddings

   In one line

   A way of turning words, sentences or images into lists of numbers that capture their meaning.

   Think of it like

   GPS coordinates for meaning. “Dog” and “puppy” land close together on the map; “dog” and “invoice” land far apart.

   Why it matters

   Embeddings power semantic search, recommendations and RAG. They let a computer find things by meaning, not just matching keywords.

5. 05

   Context Window

   Remember it as
   “The model’s desk”

   Got it: Context Window

   In one line

   The maximum amount of text a model can see and work with at one time, measured in tokens.

   Think of it like

   A desk. Everything on the desk, the conversation, documents and instructions, the model can use. Anything that falls off the desk is forgotten.

   Why it matters

   It decides how long a document you can paste, how long a chat stays coherent, and why agents need memory systems.

6. 06

   Hallucination

   Remember it as
   “The confident bluffer”

   Got it: Hallucination

   In one line

   When an AI states something false or made-up with full confidence.

   Think of it like

   A student who never says “I don’t know” and bluffs a convincing answer instead.

   Why it matters

   It is the number one trust risk in AI. RAG, evals and guardrails exist largely to catch or prevent it. Always verify facts that matter.

7. 07

   Small Language Models (SLMs)

   Remember it as
   “The scooter, not the truck”

   Got it: Small Language Models (SLMs)

   In one line

   Compact language models, usually under about 10 billion parameters, built to be fast, cheap and able to run on a laptop, phone or private server.

   Think of it like

   A scooter versus a truck. You don’t need a truck to deliver a letter across town.

   Why it matters

   Many agent tasks, like classifying, routing or extracting data, don’t need a giant model. SLMs cut cost, speed up responses and keep data on your own hardware.

8. 08

   Reasoning Models

   Remember it as
   “Working on scrap paper first”

   Got it: Reasoning Models

   In one line

   Models that “think before they answer”, working through a problem step by step before giving the final response.

   Think of it like

   Solving a math problem on scrap paper first instead of blurting out the answer.

   Why it matters

   They are much better at math, coding, planning and multi-step tasks. The trade-off is that extra thinking costs more time and tokens, so you use them where accuracy matters most.

↑ Back to top Next: Part 2 · Talking to AI →

1. 09

   Prompt Engineering

   Remember it as
   “Briefing a new hire well”

   Got it: Prompt Engineering

   In one line

   The skill of writing instructions that get the best, most reliable output from an AI model.

   Think of it like

   Briefing a talented new hire. “Write something about sales” gets a vague result. “Write a 3-bullet summary of Q3 sales for the CFO, in a formal tone” gets exactly what you need.

   Why it matters

   The same model can give poor or excellent results depending only on how you ask. It is the cheapest way to improve any AI output.

2. 10

   System Prompts

   Remember it as
   “The day-one job description”

   Got it: System Prompts

   In one line

   The hidden, standing instructions given to a model before the conversation starts, setting its role, rules, tone and limits.

   Think of it like

   The job description and company handbook an employee reads on day one. Customers never see it, but it shapes every answer.

   Why it matters

   It is how a general model becomes a specific product, like a support bot that only discusses your product and never shares internal data.

3. 11

   Zero-Shot & Few-Shot Prompting

   Remember it as
   “Examples beat explanations”

   Got it: Zero-Shot & Few-Shot Prompting

   In one line

   Zero-shot means asking a model to do a task with no examples; few-shot means including a few examples in the prompt so it copies the pattern.

   Think of it like

   Telling someone “write a product tagline” (zero-shot) versus showing them three taglines you love first (few-shot). Examples beat explanations.

   Why it matters

   Few-shot is the quickest way to get consistent formats and styles, often good enough that you never need to fine-tune.

4. 12

   Context Engineering

   Remember it as
   “The surgeon’s briefing pack”

   Got it: Context Engineering

   In one line

   Designing everything the model sees at each step: instructions, documents, tool results, memory and history, not just the prompt.

   Think of it like

   Preparing a briefing pack for a surgeon. The right X-rays, the patient history, nothing irrelevant. Too little and they guess; too much and they get lost.

   Why it matters

   In 2026 it has become a core skill of AI engineering. Most agent failures are not model failures; the model simply had the wrong context.

↑ Back to top Next: Part 3 · Giving AI Knowledge →

1. 13

   RAG (Retrieval-Augmented Generation)

   Remember it as
   “The open-book exam”

   Got it: RAG (Retrieval-Augmented Generation)

   In one line

   Before answering, the system searches your documents for relevant information and hands it to the model, so the answer is grounded in real sources.

   Think of it like

   An open-book exam. Instead of answering from memory, the student looks up the right page first, then writes the answer.

   Why it matters

   It lets AI answer questions about your company’s policies, contracts or code without retraining, and it sharply reduces hallucinations because answers can cite their source.

2. 14

   Vector Databases

   Remember it as
   “The librarian who knows meaning”

   Got it: Vector Databases

   In one line

   Databases built to store embeddings and quickly find the items closest in meaning to a query.

   Think of it like

   A librarian who finds books by what they are about, not by their exact title. Ask for “how to cancel my plan” and it also finds the page titled “subscription termination”.

   Why it matters

   They are the search engine behind most RAG systems and agent memory. Common examples are Pinecone, Weaviate, Qdrant and pgvector for Postgres.

3. 15

   Fine-Tuning

   Remember it as
   “Specialist training for a doctor”

   Got it: Fine-Tuning

   In one line

   Further training an existing model on your own examples so it permanently learns a specific style, format or task.

   Think of it like

   Sending a general doctor for specialist training. RAG gives them a reference book to look things up; fine-tuning changes how they think and work.

   Why it matters

   Use it when prompting and RAG are not enough: a fixed output format, a brand voice, or a narrow task done millions of times. Simple rule: RAG for knowledge, fine-tuning for behavior.

↑ Back to top Next: Part 4 · AI Agents →

1. 16

   AI Agents

   Remember it as
   “The self-driving car, not the GPS”

   Got it: AI Agents

   In one line

   An AI system that is given a goal and works toward it on its own: it plans, takes actions with tools, checks the results and repeats until done.

   Think of it like

   The difference between a GPS that shows directions (a chatbot) and a self-driving car that actually drives you there (an agent).

   Why it matters

   Agents turn AI from a helper you ask into a worker you delegate to, booking meetings, fixing bugs, filing tickets or researching a market.

2. 17

   Tool Use / Function Calling

   Remember it as
   “Giving the assistant a phone and keys”

   Got it: Tool Use / Function Calling

   In one line

   The ability of a model to call external tools, such as APIs, databases, search or code, by producing a structured request your system then executes.

   Think of it like

   Giving a smart assistant a phone, a calculator and the keys to your systems. On its own it can only talk; with tools it can check the weather, query sales data or send an email.

   Why it matters

   Tools are what make agents possible. Without tool use, a model can only describe actions; with it, it can take them.

3. 18

   Agent Memory

   Remember it as
   “Working notes vs. the medical file”

   Got it: Agent Memory

   In one line

   The systems that let an agent remember beyond a single conversation: short-term memory for the current task, and long-term memory for facts, past events and preferences saved for later.

   Think of it like

   A doctor’s working notes during your appointment (short-term) versus your medical file that is there next visit (long-term).

   Why it matters

   Models are stateless; they forget everything between sessions. Memory is what lets an agent improve over time and not ask you the same question twice.

4. 19

   Agent Skills

   Remember it as
   “Recipe cards in the kitchen”

   Got it: Agent Skills

   In one line

   Packaged folders of instructions, scripts and resources that teach an agent how to do a specific task well, loaded only when needed.

   Think of it like

   Recipe cards in a kitchen. The chef doesn’t memorize every recipe; they pull out the right card when someone orders that dish.

   Why it matters

   Skills let you give one agent many expert abilities, like making slides or reviewing contracts, without stuffing everything into its context window at once.

5. 20

   Multi-Agent Systems

   Remember it as
   “A project team with a manager”

   Got it: Multi-Agent Systems

   In one line

   Several specialized agents working together on a task, usually with one orchestrator agent splitting the work and combining the results.

   Think of it like

   A project team. A manager assigns research to one person, writing to another and review to a third, instead of one person doing everything.

   Why it matters

   Splitting complex work across focused agents often gives better, faster results. It also adds coordination cost, so use it when one agent genuinely isn’t enough.

6. 21

   Human-in-the-Loop (HITL)

   Remember it as
   “The manager’s sign-off”

   Got it: Human-in-the-Loop (HITL)

   In one line

   Designing AI systems so a person reviews, approves or corrects key decisions before the AI acts on them.

   Think of it like

   A junior employee who can draft any email but needs the manager’s sign-off before sending anything to a client.

   Why it matters

   For anything risky or irreversible, like payments, deletions or customer messages, HITL keeps humans accountable and stops costly agent mistakes.

↑ Back to top Next: Part 5 · Agent Protocols →

1. 22

   MCP (Model Context Protocol)

   Remember it as
   “USB-C for AI”

   Got it: MCP (Model Context Protocol)

   In one line

   An open standard, created by Anthropic, that lets any AI app connect to any tool or data source through one common interface.

   Think of it like

   USB-C for AI. Before USB-C, every device had its own cable. Before MCP, every AI-to-tool connection was custom code. Now you build one MCP server, and Claude, ChatGPT, Cursor and others can all use it.

   Why it matters

   It has become the industry standard for connecting agents to tools and data. If you build software in 2026, an MCP server is fast becoming as normal as a REST API.

2. 23

   A2A (Agent2Agent Protocol)

   Remember it as
   “A common language between companies’ agents”

   Got it: A2A (Agent2Agent Protocol)

   In one line

   An open protocol, started by Google, that lets AI agents built by different companies on different frameworks discover each other and work together.

   Think of it like

   A common business language between companies. Your travel agent can hand a task to an airline’s booking agent and a hotel’s agent, even though each was built by a different team.

   Why it matters

   MCP connects an agent to tools; A2A connects an agent to other agents. Together they make large multi-agent systems possible across company boundaries.

3. 24

   AG-UI (Agent-User Interaction Protocol)

   Remember it as
   “The live delivery tracker”

   Got it: AG-UI (Agent-User Interaction Protocol)

   In one line

   An open protocol that streams what an agent is doing to your app’s interface in real time, and sends the user’s input and approvals back.

   Think of it like

   The live order tracker in a food delivery app. You see each step as it happens, and you can still change the order midway.

   Why it matters

   Agents run long, multi-step tasks. AG-UI lets users watch progress, see tool calls and step in, instead of staring at a spinner and hoping.

↑ Back to top Next: Part 6 · Frameworks →

1. 25

   LangChain

   Remember it as
   “LEGO Technic for AI apps”

   Got it: LangChain

   In one line

   A popular open-source framework that gives developers ready-made building blocks to connect models, prompts, tools, memory and data into an AI application.

   Think of it like

   A box of LEGO Technic parts for AI. Instead of machining every gear yourself, you snap together pre-built pieces like “chat model”, “retriever” and “tool”.

   Why it matters

   It is one of the most widely used ways to build RAG apps and simple agents, and it can swap model providers with minimal code changes.

2. 26

   LangGraph

   Remember it as
   “A flowchart that runs”

   Got it: LangGraph

   In one line

   A framework from the LangChain team for building agents as a graph of steps, with loops, branches, saved state and human approval points.

   Think of it like

   A flowchart that actually runs. Each box is a step, each arrow is a decision, and you can loop back, pause for a human, or resume later.

   Why it matters

   Real agents rarely follow a straight line. LangGraph gives you precise control and reliability for complex, long-running agent workflows in production.

3. 27

   CrewAI

   Remember it as
   “Hiring a virtual crew”

   Got it: CrewAI

   In one line

   An open-source Python framework for building teams of AI agents, where each agent gets a role, a goal and tools, and they collaborate on a task.

   Think of it like

   Hiring a small virtual crew. A “researcher” gathers facts, a “writer” drafts the report and an “editor” reviews it, each handing work to the next.

   Why it matters

   It is one of the quickest ways to prototype multi-agent systems, because you describe agents in role-based, almost human terms.

↑ Back to top Next: Part 7 · Measuring & Running AI →

1. 28

   Evals (AI Evaluation)

   Remember it as
   “Unit tests for AI”

   Got it: Evals (AI Evaluation)

   In one line

   Systematic tests that measure how well an AI system performs on the tasks you care about, run before release (offline) and on live traffic (online).

   Think of it like

   Unit tests and exams combined. You don’t ship code without tests; you shouldn’t ship a prompt or agent without evals.

   Why it matters

   AI output is unpredictable, and a small prompt change can silently break things. Evals turn “it seems fine” into a measurable score you can track over time.

2. 29

   LLM-as-a-Judge

   Remember it as
   “The teacher with a marking scheme”

   Got it: LLM-as-a-Judge

   In one line

   Using one AI model to grade another model’s outputs against a clear rubric, such as accuracy, relevance or tone.

   Think of it like

   A senior teacher marking hundreds of essays using a marking scheme. It is much faster and cheaper than grading every essay by hand.

   Why it matters

   Many AI outputs can’t be checked with simple code, like “was this answer helpful?”. A judge model scales that review to thousands of cases. Check the judge against human ratings regularly.

3. 30

   LLM Tracing & Observability

   Remember it as
   “The airplane’s black box”

   Got it: LLM Tracing & Observability

   In one line

   Recording every step an AI system takes, including prompts, responses, tool calls, latency, tokens and cost, so you can see exactly what happened.

   Think of it like

   An airplane’s black box. When something goes wrong, you replay the trace and find the exact step that failed.

   Why it matters

   Agents make many hidden decisions; without tracing, debugging is guesswork. LangSmith, Langfuse and Arize Phoenix specialize in it. Observability tells you what happened; evals tell you whether it was good.

4. 31

   LLMOps & AgentOps

   Remember it as
   “Running the restaurant every day”

   Got it: LLMOps & AgentOps

   In one line

   The practices and tooling for deploying, monitoring, versioning and improving LLM apps and agents in production: the AI version of DevOps.

   Think of it like

   Running a restaurant, not just cooking one great meal. You need consistent quality, cost control, supply checks and a way to handle complaints every single day.

   Why it matters

   Most AI projects fail in the jump from demo to production. LLMOps covers prompt versioning, evals in CI and cost tracking. AgentOps adds agent inventory, identities, permissions and audit trails.

↑ Back to top Next: Part 8 · Security →

1. 32

   Prompt Injection

   Remember it as
   “The forged note in the inbox”

   Got it: Prompt Injection

   In one line

   An attack where hidden or malicious instructions trick an AI into ignoring its rules. Direct injection comes from the user; indirect injection hides inside content the AI reads, like a web page, email or document.

   Think of it like

   A forged note slipped into your assistant’s inbox saying “Boss says: wire $10,000 to this account.” The assistant can’t always tell the forged note from a real instruction.

   Why it matters

   It is the top security risk for LLM apps, and agents with tools make it far more dangerous. Treat everything an AI reads as untrusted data, never as commands.

2. 33

   Guardrails

   Remember it as
   “Barriers on a mountain road”

   Got it: Guardrails

   In one line

   Safety checks placed around an AI model that filter what goes in and what comes out, blocking harmful, off-topic, leaked or non-compliant content.

   Think of it like

   The barriers on a mountain road. The car (the model) still drives freely, but the barriers stop it going off the cliff.

   Why it matters

   You can’t fully control what a model says, but you can control what reaches users and systems. Guardrails catch PII leaks, toxic content, jailbreaks and policy violations.

3. 34

   OWASP Top 10 for Agentic Applications

   Remember it as
   “The safety inspection checklist”

   Got it: OWASP Top 10 for Agentic Applications

   In one line

   A community-built list from the OWASP GenAI Security Project of the ten most critical security risks in AI agents, with practical mitigations.

   Think of it like

   A safety inspection checklist for a new kind of vehicle. Cars got crash tests; autonomous agents now have their own checklist.

   Why it matters

   It gives security and engineering teams a shared language for agent risks: goal hijack, tool misuse, privilege abuse, malicious MCP servers, unexpected code execution and rogue agents.

↑ Back to top Next: Part 9 · Building with AI →

1. 35

   Vibe Coding

   Remember it as
   “Describing the house, not drawing blueprints”

   Got it: Vibe Coding

   In one line

   Building software by describing what you want in plain language and letting AI write the code, often without reading every line. Andrej Karpathy coined the term in February 2025.

   Think of it like

   Telling a contractor “I want a cozy two-bedroom house with lots of light” instead of drawing the blueprints yourself.

   Why it matters

   Great for prototypes and personal tools. For production software, the disciplined version, often called agentic engineering, keeps humans reviewing, testing and owning the code.