Dictionary of AI Coding

---
name: dictionary-of-ai-coding
description: AI coding jargon dictionary with plain English explanations of models, tokens, agents, context windows, and more
triggers:
  - what does context window mean in AI coding
  - explain AI coding terminology
  - what is a token in AI
  - explain agent mode and tool calls
  - what does hallucination mean for AI
  - AI coding jargon explained
  - what is a harness in AI coding
  - explain prefix cache and cache tokens
---

# Dictionary of AI Coding

> Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection.

**mattpocock/dictionary-of-ai-coding** is a plain-English reference glossary for AI coding terminology. It explains the vocabulary behind models, tokens, agents, context windows, failure modes, memory systems, and workflow patterns — without assuming prior ML expertise.

---

## Installation

```bash
# Clone the repo
git clone https://github.com/mattpocock/dictionary-of-ai-coding.git
cd dictionary-of-ai-coding

# Install dependencies
npm install

# Generate the README from source markdown files
npm run generate

Project Structure

dictionary-of-ai-coding/
├── dictionary/          # Individual term .md files (source of truth)
├── internal/
│   ├── Curriculum.md    # Section ordering and term grouping
│   └── README.template.md  # README template
├── README.md            # GENERATED — do not edit directly
└── package.json

Important: README.md is auto-generated. All term definitions live in dictionary/*.md. Edit those files, then run npm run generate.

---

Core Concepts Quick Reference

Section 1 — The Model

Term	Plain English
Model	The parameters. Stateless — does next-token prediction and nothing else.
Parameters / Weights	Billions of numbers tuned during training. Everything the model "knows."
Training	One-time process by the provider that sets the parameters.
Inference	Running the model to generate output. Billed per token.
Token	Atomic unit — roughly word-sized. Cost, latency, context size all in tokens.
Next-token prediction	All the model does: sample one token, append, repeat.
Non-determinism	Same input → different output. No setting eliminates this.
Model provider	Service that runs inference (Anthropic, OpenAI, Ollama locally).
Harness	Everything around the model: tools, system prompt, permissions.
Model provider request	One round-trip from harness to provider. Tool calls spawn many.
Input tokens	Tokens sent to the model. Billed at lower rate.
Output tokens	Tokens the model generates. Billed ~5× higher than input.
Prefix cache	Provider-side cache of shared request prefixes — much cheaper tokens.
Cache tokens	Input tokens reused from cache; billed at reduced rate.

Section 2 — Sessions, Context & Turns

Term	Plain English
Stateless	Model has no memory between requests. The harness provides all context.
Context	Everything sent to the model in a single request.
Context window	Maximum tokens the model can process at once.
Stateful	An agent that maintains history across turns (via the harness).
Agent	A harnessed model that loops: plan → tool call → observe → repeat.
System prompt	Instructions prepended before user messages. Part of input tokens.
Session	One continuous thread of turns in a harness.
Turn	One user message + one model response cycle.

Section 3 — Tools & Environment

Term	Plain English
Environment	Everything the agent can read/write: filesystem, shell, APIs.
Filesystem	Files the agent can read and edit via tools.
Tool	A function the model can call by emitting structured output.
Tool call	The model's structured request to invoke a tool.
Tool result	Data returned to the model after a tool runs.
Permission request	Prompt asking the user to approve a tool action.
Permission mode	How strictly the harness gates tool use (ask/auto/deny).
Agent mode	Harness config enabling autonomous multi-step tool use.
Sandbox	Isolated environment limiting what tools can affect.

Section 4 — Failure Modes

Term	Plain English
Sycophancy	Model agrees with you instead of being accurate.
Hallucination	Model generates plausible-sounding but false information.
Parametric knowledge	What the model learned during training. May be outdated.
Knowledge cutoff	Date after which training data stops. Model doesn't know newer things.
Contextual knowledge	Information loaded into context for this session only.
Attention relationship	How strongly the model connects two parts of context.
Attention budget	Finite capacity to maintain relationships across the context window.
Attention degradation	Quality drops when context is too long or key info is buried.
Smart zone	Region of context where attention is strongest (typically start/end).

Section 5 — Handoffs

Term	Plain English
Clearing	Ending a session to reset context before starting fresh.
Handoff	Transitioning work between sessions or agents with a summary.
Handoff artifact	Document capturing state for the next session.
Spec	Written description of what to build, used as context.
Ticket	Discrete unit of work described well enough for an agent.
Compaction	Summarising history to free context window space.
Autocompact	Harness-triggered compaction when context nears the limit.

Section 6 — Memory & Steering

Term	Plain English
Memory system	How the harness persists information across sessions.
AGENTS.md	File the harness injects as standing instructions (like system prompt).
Progressive disclosure	Loading context incrementally rather than all at once.
Skill	Reusable block of context/instructions for a specific task type.
Subagent	Agent spawned by another agent to handle a subtask.

Section 7 — Patterns of Work

Term	Plain English
Human-in-the-loop	Workflow where a human reviews/approves agent actions.
AFK	Running the agent unattended without human oversight.
Automated check	Machine-verifiable test the agent can run itself (lint, types, tests).
Automated review	CI/CD pipeline that validates agent output.
Human review	A person inspecting agent output before it ships.
Vibe coding	Accepting agent output without deep review. High speed, higher risk.
Design concept	High-level intent shared with the agent before implementation.
Grilling	Interrogating the model's reasoning to surface hidden assumptions.

---

Adding or Editing Terms

Each term is a standalone Markdown file in dictionary/:

<!-- dictionary/my-new-term.md -->
### My New Term

Plain-English definition here. Reference related terms with [brackets](#term-anchor).

*Usage:*

"Question someone might ask?"

"Answer that uses the term naturally."

Then register it in internal/Curriculum.md under the right section:

## Section N — Section Name

- My New Term

Regenerate:

npm run generate

---

Common Patterns & Troubleshooting

Why is my bill so high?

Root cause checklist:

1. Output tokens — Agent rewriting whole files. Output is ~5× more expensive than input. Instruct it to emit diffs/patches instead.
2. No prefix cache hit — Something changes early in the context each turn (timestamps, random IDs). Move dynamic content to the end of the system prompt.
3. Tool call explosion — One user message triggered 20+ tool calls. Each call = a new model provider request re-sending the full history.
4. Long session without compaction — History grows unbounded. Use compaction or clear the session.

Why does the agent seem "dumb" today?

• Non-determinism — Same task, different dice rolls. Try again before diagnosing.
• Attention degradation — Context window too full; key instructions buried. Clear and start fresh with a tight spec.
• Smart zone problem — Critical instructions in the middle of a huge context. Move them to the start or end.

Agent keeps asking permission for everything

• Check permission mode setting in your harness config.
• For trusted local work, set to auto-approve specific tool categories.
• For production/AFK runs, keep human-in-the-loop enabled.

Agent hallucinating about a library/API

• Knowledge cutoff issue. The API changed after training.
• Fix: Load the actual docs as contextual knowledge — paste the relevant README section or API reference directly into context.
• Don't rely on parametric knowledge for anything that ships or updates frequently.

Session going off the rails mid-task

Standard handoff pattern:

1. Ask the agent to write a handoff artifact summarising:
   - What was accomplished
   - Current state of the codebase
   - What's left to do
   - Any decisions made and why

2. Clear the session

3. Start a new session, paste the handoff artifact as initial context

4. Continue

AGENTS.md not being respected

• Confirm your harness actually injects it (Claude Code: yes; other harnesses: verify).
• Keep AGENTS.md concise — attention degradation applies to standing instructions too.
• Use progressive disclosure: only load detailed sub-instructions when the relevant task starts.

---

TypeScript Usage Example

The project itself is a documentation generator. Here's how to work with the source programmatically if you need to parse or extend it:

import { readdir, readFile } from "fs/promises";
import { join } from "path";

// Read all dictionary terms
async function loadDictionary(
  dictionaryDir: string
): Promise<Record<string, string>> {
  const files = await readdir(dictionaryDir);
  const terms: Record<string, string> = {};

  for (const file of files) {
    if (!file.endsWith(".md")) continue;
    const content = await readFile(join(dictionaryDir, file), "utf-8");
    const termName = file.replace(".md", "");
    terms[termName] = content;
  }

  return terms;
}

// Extract the plain-English definition from a term file
function extractDefinition(termContent: string): string {
  // First paragraph after the heading
  const lines = termContent.split("\n");
  const headingIdx = lines.findIndex((l) => l.startsWith("###"));
  if (headingIdx === -1) return "";

  const bodyLines: string[] = [];
  for (let i = headingIdx + 1; i < lines.length; i++) {
    const line = lines[i].trim();
    if (line === "") break;
    bodyLines.push(line);
  }
  return bodyLines.join(" ");
}

// Usage
const terms = await loadDictionary("./dictionary");
for (const [name, content] of Object.entries(terms)) {
  console.log(`${name}: ${extractDefinition(content)}`);
}

---

Quick Answers for Common Developer Questions

"What's the difference between a model and an agent?"

A model is just the weights — stateless, does next-token prediction. An agent is a model plus a harness: tools, system prompt, session management, permissions. Same model, radically different behaviour.

"Why does Claude Code edit files but Claude.ai just chat?"

Different harnesses. Same underlying model. Claude Code's harness includes filesystem tools and a different system prompt.

"How do I make the model 'remember' our internal API?"

Load the API docs as contextual knowledge (paste into context or attach as a file). Training is not an option — that's months of work by the model provider. Context is the lever you have.

"Why does the model agree with everything I say?"

Sycophancy — the model is optimised to be helpful, which sometimes means it confirms your assumptions instead of correcting them. Counter it by grilling: explicitly ask it to steelman the opposite position or find flaws.

"What's an AGENTS.md file?"

A markdown file your harness automatically injects into every session as standing instructions — like a persistent system prompt you check into version control.