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

Section 2 — Sessions, Context & Turns

Section 3 — Tools & Environment

Section 4 — Failure Modes

Section 5 — Handoffs

Section 6 — Memory & Steering

Section 7 — Patterns of Work

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.