20 AI Concepts Every Developer Should Actually Understand

Every “must-know AI terms” glossary makes the same mistake: it alphabetizes. Agents next to Bayesian learning next to Computer vision — sorted for a dictionary, not for understanding. But these twenty concepts aren’t independent facts to memorize. They’re a dependency graph. Fine-tuning only makes sense once you know what “training” means. Agents only make sense once you know what a single LLM call can’t do. Sort by dependency instead of the alphabet, and the whole field stops looking like a wall of buzzwords and starts looking like a stack — four layers, each one built on the last.

Layer 1: Foundations — the math underneath everything

Nothing above this layer works without it. Skip it and you can still use an LLM API, but you won’t be able to reason about why it behaves the way it does.

Two more foundational ideas that trip people up because they sound similar to terms above:

• Supervised vs. self-supervised learning. Supervised learning trains on labeled examples — input paired with a known correct output. LLM pretraining is technically self-supervised: the “label” is just the next word in a sentence the model already has, so no human labeling was needed to generate billions of training examples.
• Bayesian learning. Instead of a single point prediction, Bayesian methods model uncertainty explicitly — “70% confident” instead of just “yes.” Less common in day-to-day LLM work, but foundational to how model confidence and calibration are reasoned about.

Layer 2: Architectures — what gets built on the foundations

This is where the foundations turn into things you actually recognize: transformers, LLMs, computer vision systems.

• Transformers. The self-attention architecture that replaced recurrent networks (RNNs) as the default for sequence data. Attention lets every token look at every other token in parallel, which is both why transformers train faster than RNNs and why they have hard context-length limits — attention cost grows with sequence length.
• LLMs (Large Language Models). Transformers trained at massive scale on huge text corpora to predict the next token. Everything from GPT to Claude to Llama is this same architecture at different scales and with different post-training recipes.
• NLP (Natural Language Processing). The broader field of processing and understanding language. LLMs are the current dominant approach to NLP, but NLP existed for decades before transformers (regex, n-grams, and rule-based parsers were all “NLP”).
• Computer Vision. The same pattern, applied to pixels instead of tokens — convolutional networks and, increasingly, vision transformers (ViTs) that treat an image as a sequence of patches.
• Multimodal Models. Architectures that share a representation space across text, images, and audio, so a single model can reason about a photo and a question about it together. This is why modern assistants can describe a screenshot without a separate “vision API” bolted on.
• Generative Models. The umbrella category both LLMs and image diffusion models belong to — models that produce new samples resembling their training distribution, rather than just classifying or scoring existing input.
• Reinforcement Learning. Learning via a reward signal instead of labeled examples. Its most consequential use in this stack isn’t robotics — it’s RLHF (reinforcement learning from human feedback), the technique that turns a raw next-token predictor into an assistant that follows instructions and refuses harmful requests.

Layer 3: Adaptation — making a general model useful for your problem

A pretrained model is general-purpose. This layer is how you narrow it to your actual use case, and it’s where most of the day-to-day engineering decisions live.

• Embeddings. Turning any input — text, image, audio — into a vector, so “similarity” becomes a computable distance instead of a fuzzy human judgment. Every downstream retrieval technique depends on this conversion existing.
• Fine-Tuning. Updating a pretrained model’s actual weights on a narrower, task-specific dataset. Expensive relative to prompting, but the behavior change is durable and doesn’t need to be re-stated in every request.
• Prompt Engineering. Shaping model behavior through the input text itself, with the weights untouched. The zero-cost lever, and usually the correct first move.
• AI Agents. The 2025-2026 shift worth dwelling on: a single LLM call takes text in, text out — one shot, no state, no ability to check its own work. An agent wraps that call in a loop with tools, memory, and a decision procedure for its next step, so it can plan, call an API, read the result, and act again. The agent isn’t the model — it’s the loop and the tools around it.

Layer 4: Production — making it a system, not a notebook demo

The concepts that separate a working prototype from something that survives real traffic.

Why the order matters more than the definitions

Here’s the test that actually separates understanding from vocabulary: can you explain why fine-tuning comes after supervised learning in this list, and why agents come after prompt engineering? If a glossary just alphabetizes twenty terms, you can memorize all twenty definitions and still not know when to reach for RAG versus fine-tuning versus a longer prompt — because that’s a layer question, not a definition question.

The dependency order is the actual mental model:

1. You can’t have deep learning without machine learning underneath it.
2. You can’t have transformers without neural networks underneath them.
3. You can’t fine-tune a model you don’t have — foundations and architectures come first.
4. You can’t build a reliable agent on top of a model whose outputs you can’t evaluate — production concepts aren’t optional polish, they’re what makes the layer above trustworthy.

Read the list once as four layers instead of twenty flashcards, and every “concepts you should know” post you scroll past afterward reads as one of these four buckets — which is the actual point of learning a glossary in the first place.