Glossary

Glossary

When I started with AI, half of every article read like code. Agent, token, MCP — jargon everywhere, human explanations nowhere. So here's the glossary the way I understand these terms and use them on this site. The first sentence is always plain language; the detail sits underneath.

This isn't an encyclopedia. These are the words you'll actually run into — here, in AI podcasts and while building your own things. I keep adding entries; if one's missing, write to me.

A

Agent (AI agent)

A program built on a language model that doesn't just answer — it acts: makes decisions, uses tools and sees tasks through. I give my agents work in a plain sentence and they do it for me. What that looks like day to day is in How I work.

Agent team

Several agents running at once, each on its own slice of the task. It only works when they stay out of each other's way — everyone owns their piece and nobody touches someone else's work in progress.

Agentic

Describes systems and workflows where agents do the main work, not the human. You'll hear the word everywhere these days — now you know what's behind it.

Agentic engineering

The craft of building systems where agents do the work: splitting up tasks, giving agents rules and guardrails, sorting out their memory. A discipline being invented as we go — and you can learn it without writing code.

Agentic loop

The cycle an agent works in: gather information, do something, check the result, decide the next step. Repeat until done. That's the difference from a plain chat — an agent comes back to the work on its own.

Anthropic

The company behind Claude, founded in 2021 by people who previously worked at OpenAI.

API

The rules two programs use to exchange data — an agreed language between machines. With AI you'll mostly meet it around pricing: “via the API” means paying for each use separately instead of a monthly subscription.

API key

A secret code your program uses to identify itself to a service — like a key to your flat. Whoever holds it spends your money, so it never belongs in code or anywhere public. More in Watch out for.

Astro

The web framework this site runs on. It generates pages ahead of time, so they're fast and hosting costs next to nothing. Why I picked it is in My stack.

B

Backend

The invisible half of a website or app — it runs on the server and handles data, accounts and logic. Visitors never see it, but nothing works without it. The opposite of the frontend.

Backup

A copy of your data kept somewhere else for the day something breaks. My rule: data that exists in one place only doesn't really exist. Most of my backups happen through Git — every change is stored on GitHub too.

Benchmark

A standardized test that measures how smart a model is, so models can be compared. Take them with a grain of salt: a good score doesn't mean the model suits your particular work.

C

Cache

A temporary copy of data a machine keeps so it doesn't have to compute or download the same thing over and over. It speeds things up — and occasionally serves you a stale version, hence the classic advice to “try refreshing the page”.

CDN

A network of servers around the world holding copies of a site close to its visitors. Someone in Prague gets the page from Europe, someone in New York from America — both fast.

CI/CD

Automation around shipping: every change triggers checks, and when they pass, the change goes live on its own. For me that's GitHub + Vercel — I don't touch it.

Claude

The family of AI models made by Anthropic — and the name of the assistant I spend my days with.

Claude Code

My main working environment. An app where I tell Claude what should exist, and it reads files, writes code, runs tools and reports back. There's a terminal version too; I use the desktop app on Windows — I type into it like a chat. How to get started, step by step: Getting started.

CLAUDE.md

The rules file for Claude Code: what the project is, what's allowed, how things are done here. Claude loads it by itself at the start of every conversation. I don't maintain it by hand — I say “add to CLAUDE.md that…” and Claude keeps it up to date. Five minutes of writing rules saves hours of explaining later. Details in My setup.

CLI

The command line, also called the terminal — the black text window where programmers type commands. I mention it because every tutorial does. I don't use it — whatever used to be typed there, I just say to Claude.

Cloud

Other people's computers in a data center, rented over the internet. “In the cloud” means “not on my machine” — the provider worries about the hardware, power and upkeep.

Commit

A saved snapshot of changes with a note on what changed and why. Commits make up a project's entire history — when something breaks, you can roll back to the last working state.

Computer use

An AI's ability to operate a computer or browser like a person: look at the screen, click, type. Useful for things that have no proper integration — but slower and more fragile than going through an API or MCP.

Connector

A bridge between Claude and one outside service — Notion, GitHub, a calendar, e-mail. Technically it runs over MCP. Which ones I have plugged in and why: What I use.

Context

Everything the model can “see” at a given moment: your request, the conversation so far, attached files, the rules. Context quality decides output quality more than anything else — before I ask for results, I hand the agent its materials. How much fits is set by the context window.

Context window

How much the model can hold at once — its short-term memory, measured in tokens. The strongest Claude (Opus 4.8 as I write this) takes up to a million tokens, roughly several books at once. The important part: whatever doesn't fit in the window, the model simply doesn't know.

Crawler

A search engine's robot that walks the internet page by page, reading content. What it finds goes into the index — without a crawler visit, the search engine doesn't know you exist.

D

Database

A warehouse for data — accounts, articles, anything an app needs to store and search through fast. This site uses one for the forum and user accounts. What I run exactly: My stack.

Deep research

A mode where the AI skips the quick answer, works through dozens of websites, weighs the sources and returns a report with references. Great for research — just expect minutes, not seconds.

Deployment

Publishing a change to the internet so others can see it. Mine runs itself: Claude pushes the change to GitHub and Vercel puts it live within minutes. I just check the result.

DNS

The internet's phone book — it translates a domain name (euphronic.com) into the numeric address of the server where the site actually lives.

Domain

The address you type into the browser — like euphronic.com. You rent it by the year, and it's one of the few things here I actually pay for. More in My stack.

E

Effort (extended thinking)

How much “thinking” the model allows itself before answering. More effort means better results on hard problems, but slower and pricier answers. I keep it on high permanently — I'd rather wait.

Embedding

Turning text into numbers that capture its meaning. That's what makes searching by meaning instead of exact words possible — the foundation of semantic search.

Encryption

Encoding data so only someone with the key can read it. The foundation of HTTPS, passwords and safe backups — without it, the internet would be an open postcard.

F

Few-shot and zero-shot

Two ways to ask: zero-shot = just do it, no example; few-shot = here are two or three samples first, now do the same. A couple of good examples often improves the result more than a long explanation.

Fine-tuning

Further training a finished model on your own data so it fits a specific use. For everyday work you won't need it — a good prompt and the right context solve most of it.

Framework

A ready-made skeleton apps are built on, so nobody reinvents the same basics every time. This site stands on Astro.

Free tier

The free layer of a service — limited, but often enough for trying things out or running something small. A good chunk of my stack runs exactly like that.

Frontend

The visible half of a website — what the browser renders: text, buttons, design. The opposite of the backend.

G

Git and GitHub

Git keeps the history of every change in a project. GitHub is the service where projects live online. Together: backup, history and the place the site deploys from. Claude handles both for me — I just know why they're there. More in My stack.

GPU

The graphics card — a chip that can run an enormous number of calculations at once. Built for games, but today all of AI stands on it: training and running models alike. That's why they're so expensive and so wanted.

Guardrail

A rule that stops an agent from doing something dangerous — deleting data, spending money, sending things out without permission. I wouldn't let agents work on their own without guardrails. What happened to me and what came of it: Watch out for.

H

Hallucination

When a model generates something untrue with complete confidence. It sounds plausible — that's exactly what makes it treacherous. The rule: if it can be verified, verify it. How I catch hallucinations: Watch out for.

Hook

A small script that fires by itself on a given event — before every agent action, say, or at the end of a session. It's how I enforce rules that would otherwise depend on the model remembering them. Mine are in My setup.

Hosting

Where a website physically lives — a computer that's always on and answers visitors. You can run your own server or leave it to a service. I've tried both — how that went is in Own server.

HTTPS

The padlock in the browser: the connection between you and the site is encrypted, so nobody along the way can read or tamper with it. A site without it has no business being public today.

Human-in-the-loop

A safety setup where the agent prepares the work and a human approves it before anything gets sent, deleted or paid. For actions that are hard to undo, I insist on it — the agent does the work, the signature is mine.

I

IDE

A development environment — the program programmers write code in: editor, tools and previews in one. I mention it because you'll run into the word. I don't need one — writing to Claude is enough.

Indexing

Getting a page into a search engine's database. Until a site is in the index, it doesn't exist in the results — no matter how good it is. Pages get in via a crawler visit; a sitemap speeds it up.

Inference

The model running — the moment it reads your request and generates the answer. Training is school, inference is the job. And the job is what you pay for.

IP address

The numeric address of a machine on the internet. People type domains; machines translate them to IPs via DNS and only then connect.

J

Jailbreak

An attempt to get around a model's safety rules and make it do something it refuses to. You won't need it for honest work — I mention it so the word doesn't surprise you.

JSON

The text format programs use to pass structured data around — labels and values in curly braces. You'll meet it in every other settings file and output.

L

Library

A finished piece of code a project pulls in instead of writing it again — a player, a calendar, charts. Modern building is mostly assembling proven parts.

LLM (large language model)

A model trained on a huge amount of text that can generate text and “reason” about it. Claude, ChatGPT and Gemini are all LLMs — they differ in ability, behavior and price.

Local model

A model running directly on your machine — no internet, no data leaving the house. Free and private, but weaker than the big cloud models; for serious work it hasn't been enough for me yet.

Localhost

The “here at my place” address — a site or app running only on your own computer, for testing, before it ships. Nobody else can see it.

M

Markdown

A simple text format: a hash means heading, a dash means list. Nearly everything around AI is written in it — and my agents' entire memory is plain Markdown files. No database, just text.

MCP (Model Context Protocol)

The standard that connects outside services and tools to Claude. Think USB: one type of socket you plug Notion, GitHub or a database into — and suddenly the agent can work with them on its own. Anthropic invented it, by the way, and the whole industry uses it now.

Memory

A model remembers nothing on its own — after every conversation it has amnesia. So I keep a “notebook” next to it: files the agent reads at the start to learn where we left off and what's true. How mine is built: How I work.

Migration

A controlled move — of data, a site or a service — from one place to another without losing anything. With databases, the word also covers every change to their structure.

Model (Opus / Sonnet / Haiku)

The Claude variants: Opus is the most capable, Sonnet faster and cheaper, Haiku the lightest. I picture a model as a brain that can be placed into different bodies — a chat, an app, a browser. You pick the brain to match the job.

Multimodality

A model's ability to work with more than text — images, audio, video. Send a screenshot and the model reads it like you would.

N

Neural network

A mathematical structure loosely inspired by the brain: an enormous number of numbers wired into layers that learn patterns through training. The foundation under every AI model today.

No-code and low-code

Tools where you build apps by clicking (no-code) or with a minimum of code (low-code). Vibe coding goes a step further — instead of clicking, you talk, and the code takes shape under the agent's hands.

O

Open source

Open code: anyone can read it, use it and improve it. With AI you'll also hear “open weights” — you download the whole model and run it as a local model. The opposite of closed services like Claude.

Orchestration

Coordinating multiple agents: who does what, how they hand off results, how you keep them out of each other's way. Sounds complicated; in practice it mostly means one thing — split the work well and give everyone their own piece.

P

Parameters (weights)

The numbers inside a model, set during training — hundreds of billions of them in the big ones. A rough measure of size: more parameters usually means a smarter but pricier and slower model.

Planning (plan-first)

The “plan first, build second” routine: the agent writes up what it'll do and how, I approve the plan, and only then does the building start. On bigger jobs this removes most of the missteps. How I do it: How I work.

Plugin

An extension that adds a ready-made bundle of features to Claude Code — commands, agents, service hookups. Installed with one sentence to Claude. Which ones I run: What I use.

Production vs. development

Two versions of the same project: development is the playground where things get tried, production is the live version visitors see. You experiment on the playground — only what's proven goes to production.

Prompt

The instruction you send the model. To me, the most underrated part of working with AI — answer quality lives and dies with instruction quality. Bad input, bad output, and the model isn't to blame.

Prompt engineering

The craft of writing instructions that get you what you actually want: be specific, give an example, break the task into steps. It's not science — it's a craft, and you can learn it.

Prompt injection

An attack where someone hides instructions for the AI inside text the agent reads — an e-mail, a web page, a document — and tries to hijack it. The main reason agents need guardrails and why outside input is never trusted. More in Watch out for.

Q

Quantization

Shrinking a model by “rounding” its numbers so it runs cheaper and faster — at the cost of a bit of intelligence. Incidentally the reason a model with the same name can feel smarter or dumber depending on who's serving it.

R

RAG

A setup where the model first looks up the relevant documents and only then writes the answer from them. Instead of relying on what it “remembers”, it gets source material — fewer hallucinations, answers backed by sources.

Rate limit

A cap on requests per period of time — not the same thing as a usage limit: rate limits guard frequency, usage limits guard total consumption. It protects services from overload, and in practice it's why even a paid tool sometimes says “please wait”.

Reasoning

When the model visibly thinks step by step before answering instead of firing off its first idea. It ties into effort — more thinking means better results on hard problems and a longer wait.

Repository (repo)

The folder with everything that belongs to a project, watched over by Git. One project = one repository. When I tell Claude “start a new project”, this is what appears.

Reverse prompting

Flipping the roles: instead of crafting the perfect prompt, you let the AI interview you about what it needs to know. One of the simplest tricks that genuinely works. More of them in Tips & tricks.

Routine

A scheduled task that runs by itself — every morning, every hour, whatever you need. The agent works while you're away from the computer. What I have scheduled: Routines.

S

SaaS

Software as a service: a program you don't install but use in the browser for a monthly fee. Notion, Vercel and Claude are all SaaS — and so is most of what people build with vibe coding.

Sandbox

An isolated space where code runs without being able to damage the rest of the computer. A fenced playground — whatever happens inside, stays inside. It's why I'm not afraid to let agents experiment.

Secrets

Passwords, API keys, tokens — everything that must never leak. They live outside the code, in dedicated places, and agents get hard rules for handling them. Why it matters: Watch out for.

Semantic search

Searching by meaning, not exact words. It finds “car” even though you searched for “vehicle”. Under the hood it runs on embeddings.

SEO

Search engine optimization — making sure Google understands a page and offers it for the right queries. No tricks: clear content, a tidy structure, patience.

Serverless

Instead of your own server, the code runs on the provider's infrastructure and you pay only for actual use. That's how I run this site for next to nothing. I did try a real server once — how that went is in Own server.

Sitemap

A machine-readable list of every page on a site, read by search engines so they don't miss any. It generates itself and you submit it once — after that the search engine keeps an eye on it.

Skill

A package with instructions for how Claude should do one specific thing: the steps, the rules, the examples. Write it once instead of explaining every time, and Claude pulls it out when needed. Mine: What I use.

Slash command

A shortcut typed as /something that triggers a prepared action in Claude Code. I barely use them — I'd rather say what I want in plain words. Still good to know they exist: Commands.

Stack

The set of tools a project is built from — framework, database, hosting, all of it. My complete one, with prices and reasons, is in My stack.

Static site

Pages generated ahead of time instead of being assembled on every visit. Fast, cheap, and there's barely anything to break. This site is static — built with Astro.

Subagent

A specialist agent the main agent calls in for a defined slice of work — “search the project”, say, or “check security”. The main agent directs, subagents do the legwork, results flow back up.

Subscription

The monthly flat fee for AI: you buy a budget and draw it down through limits. The other route is paying for actual consumption via the API.

System prompt

The opening instruction a model receives before your first message — it shapes its whole behavior: role, rules, boundaries. As a user you usually don't see it, but there's always one there.

T

Temperature

A setting for how much the model should gamble: low = it stays close to the safe answer, high = more creative and wilder output. In everyday apps you never touch it; over the API you do.

Token

The unit a model reads and writes text in — chunks of words. One page of text is roughly 300 to 500 tokens. And since limits and prices are counted in tokens, it's also the unit of consumption — something like kilowatt-hours for electricity.

Training

The model's schooling: its parameters get tuned on a huge amount of text until it knows the language and the world described in it. It costs a fortune and happens once — you then use the finished result at inference time.

Transformer

The neural network architecture from 2017 that made today's language models possible — it's the T in GPT. You don't need the details; just know the word names the “blueprint” today's AI grew out of.

Two-factor authentication (2FA)

A second lock on your account: password plus a code from your phone. If the password leaks, the attacker still doesn't get in. Turn it on everywhere you can — it's the cheapest insurance there is.

U

Usage limit

The consumption cap on a subscription. Picture a prepaid buffet you eat with a small spoon — empty the spoon too fast and you wait a while. During heavier vibe coding, a several-hour limit can be gone within the hour.

V

Version control

Keeping a history of changes so you can always tell what changed when — and step back when something goes wrong. In practice Git does the job; for me it's one of the biggest safety nets in all of building.

Vibe coding

Building software by describing in plain language what should exist, while AI writes the code and you steer and check the result. Exactly what I do — no programming, but my own head stays on. The whole Vibe coding section is about how.

W

Webhook

A doorbell between services: instead of a program asking “anything happen yet?” over and over, the other service rings when something does. The backbone of most automations.

Workflow

A settled way of working — steps that repeat the same way every time. My basic one: plan, build, check, ship. The whole thing is in How I work.