Large Language Models (LLMs)
A Large Language Model (LLM) processes natural language by predicting what token comes next. Given your input, it computes a probability distribution over candidates, then picks the next token—sometimes the most likely one, sometimes with deliberate randomness.
In casual AI talk, people ask which "model" you prefer. Usually they mean which LLM.
If you like ChatGPT, you might say "I use the ChatGPT model"—but that is not quite right.
Open ChatGPT, Gemini, or Claude and you will often see a model picker. In ChatGPT you might choose GPT-5.4, GPT-5.4 mini, or GPT-5.4 nano, among others. ChatGPT is an AI chat product, not a single model.
So how do OpenAI and ChatGPT relate? OpenAI is the company. ChatGPT is their chat product—and inside it you pick from models like GPT-5.4, GPT-5.4 mini, or GPT-5.4 nano.
The same pattern applies elsewhere:
Claude comes from Anthropic. Current flagship options include Opus 4.6, Sonnet 4.5, and Haiku 4.5.
Gemini is Google's AI product, with models such as Gemini 3.1 Pro, Gemini 3 Flash, and Nano Banana Pro.
Agent Applications
Why can ChatGPT, Gemini, and Claude answer questions and take action? Behind the UI, an Agent handles your instructions.
These apps do more than pipe your text to an LLM. They manage prompts, shape outputs, and let the model use tools—reading files, editing code, calling APIs.
Many people call any software that understands language and gets work done an Agent.
I prefer Agent Application for products like ChatGPT, Gemini, and Claude. The Agent is the persona inside the app—its goals, tools, and identity—not the app shell itself.
Agents
Compared with a chatbot, an Agent is less "encyclopedia that talks" and more "virtual employee that ships." It is goal-directed software with autonomy and the ability to interact with its environment.
GitHub Copilot defines an agent this way:
An agent is an AI system that autonomously plans and executes coding tasks.
You give the agent a high-level goal, and it breaks the goal down into steps, executes those steps with tools, and self-corrects when it hits errors.In Copilot you can define custom agents—personality, working style, tool access—so each one feels like a specialist for a particular job.
Prompts
A prompt is the most direct way to talk to AI.
Whether you use ChatGPT, Gemini, Claude, or something else, you type (and sometimes attach files) into a box. What you send is the prompt.
Context
Modern Agent Applications are smarter than a single message in, reply out. Besides your current prompt, they may inject INSTRUCTIONS, SKILLS, AGENTS.md, and more before the LLM sees anything.
What the app assembles behind the scenes + conversation history + your prompt = the context the model actually works from.
Without enough relevant context, the model is like an employee handed a vague task—guessing what the boss wanted.
Attention
The paper that introduced the Transformer—the backbone of modern LLMs—is titled Attention Is All You Need. In AI, attention is the math that teaches a model what to focus on.
Early models treated every word equally. Humans do not. In "Xiao Ming bought coffee; it smelled great," we know "it" means the coffee. Attention lets the model weigh how much each token matters to the one being processed.
Attention is a big reason modern LLMs handle pronouns, rhetoric, and nuance as well as they do.
AGENTS.md
Before 2025, every Agent Application had its own way to store standing rules—GEMINI.md for gemini-cli, Cursor Rules, and so on.
Since then, many apps have adopted AGENTS.md, so teammates on different tools can share one "constitution" file.
INSTRUCTIONS
In GitHub Copilot, INSTRUCTIONS are scoped rule files: when the agent touches matching paths, it must follow them.
Different folders can load different instructions—domain knowledge, business constraints, coding conventions. In a large modular repo, a Coding Agent working in one module can get rules tailored to that module.
Here is an example that applies only to TypeScript files under test/:
---
applyTo: test/**/*.ts
---
# Core goal
When working in this scope, keep tests readable, maintainable, and independent.
# Rules and conventions
- **Naming**: Use "should [expected behavior] when [condition]" for test titles.
- **Structure**: Follow Arrange-Act-Assert; label each block with comments.
- **Framework**: Prefer Vitest with `vi.mock()` for module mocks.
- **Assertions**:
- Prefer `expect(...).toBe(...)` for primitives.
- Use `toStrictEqual` over `toEqual` for objects.
- **Do not**:
- Use `any` in test files.
- Share state across tests—each `it` / `test` must stand alone.
- Mock the unit under test.INSTRUCTIONS load deterministically: if a file matches applyTo, the agent gets them.
SKILLS
A SKILL loads on demand. The app first puts only the SKILL's name and description into context. During the task, the LLM decides whether to pull in the full SKILL.md.
Skills got attention because they showed people you can give AI tools and resources—not just text—and that opened a different way of working.
Lost in the Middle (Context Rot)
"Lost in the Middle" means models remember the start and end of long inputs best—and forget or distort the middle. Like a three-hour tech talk where you recall the opening joke and the final takeaway, not the implementation details. That degradation is often called context rot.
Vendors advertise million-token windows, but the problem persists. It is tied to how LLMs work; no perfect fix exists yet.
For the research, see Lost in the Middle: How Language Models Use Long Contexts.
MCP (Model Context Protocol)
MCP (Model Context Protocol) is Anthropic's standard for connecting LLMs to databases, docs, and tools without bespoke glue for every pair.
Think USB-C for AI integrations: follow the protocol, and new models can talk to data sources the same way. That lowers the cost of building agents and widens what they can touch.
Examples:
- Figma MCP—let an LLM work on the canvas
- Miro MCP—organize whiteboard content
- Notion MCP—query, create, and update Notion pages
- Atlassian MCP—reach Jira, Confluence, and other Atlassian SaaS
These used to require custom API work. With MCP, users install a server and the LLM can operate the tool directly.
Specification-Driven Development (SDD)
Specification-Driven Development (SDD) means nailing the spec first— requirements, constraints, acceptance criteria, interface contracts— then letting humans and AI implement against it.
In AI-assisted coding, SDD turns fuzzy asks into executable context, cutting rework from guesswork. Draw the blueprint, then let the Coding Agent build fast.
A common loop: Specify → Plan → Task → Implement. Humans align on goals and key decisions; agents accelerate output and feedback.
SDD tooling people talk about lately:
Harness
LangChain's Anatomy of an Agent Harness puts it simply: Agent = Model + Harness. The harness is everything beyond the model that makes work actually happen.
System prompts, tools, skills, MCP, filesystems, sandboxes, orchestration, hooks, verification loops—the model generates; the harness sets boundaries, supplies capabilities, and feeds back results.
I picture it like this:I am an Agent; the LLM is my mind; the harness is my body, methods, tools, and rules.
RAG
RAG (Retrieval-Augmented Generation) combines search with generation.
A model trained months ago only knows its training data—stale facts and hallucinations are real risks. RAG is like letting the model open the textbook: on each question, the system retrieves fresh, relevant passages, then the model synthesizes an answer.
Common in customer support, education, legal research, and technical documentation assistants—anywhere you need timeliness, accuracy, and traceability.
For a deeper dive, see my article on retrieval-augmented generation.
Closing thoughts
This glossary covers 16 terms that show up constantly in AI work. New ones will land—I will update this post as they do. Bookmark it if jargon keeps moving faster than you can.