AI Coding Dictionary

AI coding can feel like it's just for experts. Unexplained jargon. Mysterious failures. Bills that don't seem to match the work.

It isn't, really. A lot of the confusion is manufactured: there's a whole VC-funded economy that benefits from keeping it hard to understand.

The basic terms of engagement are learnable in an afternoon. Once you have them, the whole thing stops feeling like guesswork.

Why does context degrade? Why is the bill so high? Why does the same prompt behave differently from one day to the next?

Each has a clean answer, once someone tells you the words to use.

That's what this dictionary is for. The vocabulary of AI coding, translated into plain English.

Want more than the vocabulary? Join 62,000+ developers at aihero.dev/newsletter for my latest skills, thinking on AI engineering, and the resources that'll keep you ahead of the curve.

---

Table of contents

Section 1 — The Model

- [AI](#ai) - [Model](#model) - [Parameters](#parameters) - [Training](#training) - [Inference](#inference) - [Effort](#effort) - [Token](#token) - [Next-token prediction](#next-token-prediction) - [Non-determinism](#non-determinism) - [Model provider](#model-provider) - [Harness](#harness) - [Model provider request](#model-provider-request) - [Input tokens](#input-tokens) - [Output tokens](#output-tokens) - [Prefix cache](#prefix-cache) - [Cache tokens](#cache-tokens)

Section 2 — Sessions, Context Windows & Turns

- [Stateless](#stateless) - [Context](#context) - [Context window](#context-window) - [Stateful](#stateful) - [Agent](#agent) - [System prompt](#system-prompt) - [Session](#session) - [Turn](#turn)

Section 3 — Tools & Environment

- [Environment](#environment) - [Filesystem](#filesystem) - [Tool](#tool) - [Tool call](#tool-call) - [Tool result](#tool-result) - [MCP](#mcp) - [Permission request](#permission-request) - [Permission mode](#permission-mode) - [Agent mode](#agent-mode) - [Sandbox](#sandbox)

Section 4 — Failure Modes

- [Sycophancy](#sycophancy) - [Hallucination](#hallucination) - [Parametric knowledge](#parametric-knowledge) - [Knowledge cutoff](#knowledge-cutoff) - [Contextual knowledge](#contextual-knowledge) - [Attention relationship](#attention-relationship) - [Attention budget](#attention-budget) - [Attention degradation](#attention-degradation) - [Smart zone](#smart-zone)

Section 5 — Handoffs

- [Clearing](#clearing) - [Handoff](#handoff) - [Primary source](#primary-source) - [Secondary source](#secondary-source) - [Handoff artifact](#handoff-artifact) - [Spec](#spec) - [Ticket](#ticket) - [Compaction](#compaction) - [Autocompact](#autocompact)

Section 6 — Memory and Steering

- [Memory system](#memory-system) - [AGENTS.md](#agentsmd) - [Progressive disclosure](#progressive-disclosure) - [Context pointer](#context-pointer) - [Skill](#skill) - [Subagent](#subagent)

Section 7 — Patterns of Work

- [Human-in-the-loop](#human-in-the-loop) - [AFK](#afk) - [Automated check](#automated-check) - [Automated review](#automated-review) - [Human review](#human-review) - [Vibe coding](#vibe-coding) - [Design concept](#design-concept) - [Grilling](#grilling) - [Prototyping](#prototyping) - [DX](#dx) - [AX](#ax) - [Software factory](#software-factory) - [Dark factory](#dark-factory)

Section 1 — The Model

AI

A moving label, not a technology. "AI" doesn't name a fixed thing the way model or token does — it points at whatever computers can newly, impressively do. Right now it points at large language models. It has pointed at very different things before:

Era	What "AI" meant
1950s	Symbolic reasoning — theorem provers, checkers programs.
1960s–70s	Rule-based symbolic programs — ELIZA, SHRDLU.
1980s	Expert systems — thousands of hand-written if-then rules encoding human expertise.
1990s	Game-tree search — Deep Blue beating Kasparov (1997). Researchers avoided the word "AI" entirely
2000s	Statistical machine learning — spam filters, recommenders. Still sold as "machine learning", not "AI"
2010s	Deep learning — image recognition (AlexNet, 2012), AlphaGo (2016).
2020s	Large language models — ChatGPT (2022) made "AI" mean chatbots

The pointer moves by a known mechanism, sometimes called the AI effect: once a technique works reliably, it gets renamed — it's "just" search, "just" statistics — and "AI" slides forward to the next unsolved thing. The observation is old. Bertram Raphael put it this way in 1971: "AI is a collective name for problems which we do not yet know how to solve properly by computer." Larry Tesler's version, from around 1979: "Intelligence is whatever machines haven't done yet."

This is why conversations about AI so often talk past each other. A claim like "AI can't reason" or "AI is overhyped" carries a hidden timestamp — it may be about expert systems, about 2010s image classifiers, or about last month's LLM, and each reference supports a different conclusion. When a discussion about AI stalls, the fix is usually to swap the word for whichever precise term is actually meant: the model, the harness, the agent, the context it was given.

Avoid: "AI" in any technical claim — name the part you mean instead. "AI coding" as a label for the practice is fine; "the AI is hallucinating" is not.

Usage:

"The CTO wants to know whether AI could handle the triage queue."

"Translate that before scoping it — she means an LLM in a harness with access to the ticket system. 'AI' on its own isn't a spec."

Model

The parameters. Stateless — does next-token prediction and nothing else. "Claude Opus 4.x" and "GPT-5.x" are models. On its own a model can't do anything agentic; it has to be harnessed.

Models can't read files, run commands, browse the web, or remember yesterday — it takes tokens in and predicts tokens out, once per model provider request. Everything that feels like an agent working — choosing tools, reading results, looping until the task is done — is the harness orchestrating many of those predictions in a row.

Model providers ship models in tiers: a large one that's smartest but slow and expensive, and smaller ones that are faster and cheaper but less capable. Picking a tier is a real decision — heavyweight for planning and hard debugging, lightweight for mechanical changes — and harnesses let you switch mid-session.

Being strict about the word also sharpens diagnosis. "The model is bad at this" is a specific claim — the same model in a different harness, or with a different context, often behaves completely differently. Before blaming the model, check what it was given: most disappointing output traces back to context or harness, not parameters.

Usage:

"Should we switch the model from Sonnet to Opus for the planning step?"

"Try it — but the harness is doing most of the lifting on this task. The model swap won't help if the system prompt and tools are wrong."

Parameters

The numbers inside a model — often billions of them — tuned during training. Everything the model "knows" lives in them. Training sets them; inference uses them unchanged. Also called weights.

Mechanically, the parameters are what turn input into output. Next-token prediction is a giant calculation: the tokens in the context window go in, get multiplied through the parameters, and a prediction for the next token comes out. There is no database of facts inside the model, no code lookup table — just these numbers, arranged so that the calculation tends to produce useful output. Facts the model can recite from training, like a standard library API, are parametric knowledge: stored in the parameters, not retrieved from anywhere.

The detail worth internalising is that parameters are frozen after training. Nothing you do in a session changes them — no correction you make, no codebase you show it, no mistake it learns from. Every session runs on the same numbers. This is why the model is stateless, why its built-in knowledge stops at the knowledge cutoff, and why anything project-specific has to arrive via context instead. The only way parameters change is more training — which produces, in effect, a different model.

Usage:

"Can we fine-tune it on our codebase?"

"That'd update the parameters — different model afterwards. For one project it's almost always cheaper to load the codebase as context than to retrain."

Training

The process that sets a model's parameters, by exposing it to vast amounts of text and adjusting parameters to improve next-token prediction. A one-time, expensive process done by the model provider. Encompasses both pre-training (the bulk run) and post-training (later refinements like instruction-following and safety); the distinction doesn't matter at this glossary's level.

The mechanism is repetition at scale: show the model a stretch of text, have it predict the next token, nudge the parameters toward whatever the actual next