Agentic Engineering Vocabulary & Patterns

"Everyone obsesses over the model, but the harness — your prompts, skills, codebase quality, workflows, and environment — gives you equal leverage and is fully under your control." — Matt Pocock (Source: Agentic Engineering Workflow, YouTube, 2026-06-18)

Agentic engineering is not about better prompts. It's about designing the whole system around the model — the harness, the codebase, the workflows, the handoffs — so that the model reliably produces good work. This page synthesizes Matt Pocock's agentic engineering philosophy (from his 1-hour interview with David Ondrej) and his AI Coding Dictionary (67 terms, 2.4K GitHub stars) into an operational vocabulary.

The Central Insight: Model vs Harness

The model and the harness are two different things, and you control only one:

Component	What It Is	You Control It?
Model	The parameters — does next-token prediction, nothing else. Stateless.	No — the provider owns it
Harness	Everything around the model: tools, system prompt, context management, permissions, skills, hooks	Yes — entirely

"Claude.ai and Claude Code run on the same model but behave differently because their harnesses differ. When behaviour differs between two products, the model is often not the variable — the harness is." — AI Coding Dictionary, "Harness"

This distinction is the foundation of agentic engineering. Most people obsess over which model to use. The 10x difference comes from optimizing what the model runs in — the codebase structure, the skill system, the task scoping, the verification layer.

Tactical vs Strategic Programming

Drawing from John Ousterhout's Philosophy of Software Design:

Level	What It Is	Status
Tactical programming	Day-to-day writing of code — implementing a function, fixing a bug	AI has eaten this
Strategic programming	Long-term thinking — codebase architecture, interfaces, task scoping, verification systems	Still fully human — and the multiplier

"AI makes senior developers 10x better, but juniors only get a small boost. Getting good with AI means getting good at your domain — the skills you bring are the multiplier." — Matt Pocock

Strategic programming hasn't changed: design the hard parts upfront, scope tasks well, think about module interfaces, write good tests, build a codebase that's easy to work in. AI just makes the tactical execution faster — which makes strategic thinking more valuable, not less.

The Session Lifecycle

Understanding how sessions degrade is core operational knowledge for agentic work:

The Smart Zone → Dumb Zone

Every session has a smart zone — the early portion where the agent is sharp, recall is good, and instructions hold. As context accumulates past ~125K-150K tokens (on frontier models), the session drifts into the dumb zone: sloppier, forgetful, more mistakes. Same model, same harness — just more context.

The mechanism: each token has a fixed attention budget. As the context grows, your early instructions compete with thousands of newer tokens for that fixed attention. The signal doesn't disappear — it gets buried in noise.

"The decline is gradual, which makes it easy to miss. There's no error message and no visible boundary; the agent just starts performing slightly worse, then noticeably worse." — AI Coding Dictionary, "Smart zone"

Operational rule: Do one task per session. Each task gets the sharpest part of the session. When a single task exceeds one smart zone, split it with a handoff.

Handoffs

A handoff transfers agent context from one session to another with no return path. The carry mechanism varies:

Mechanism	Form	Properties
Handoff artifact	File in the environment (plan doc, decisions log, spec)	You can read and correct it before anything depends on it; reusable
Compaction	In-memory summary seeded into a fresh session	Automatic and cheap; harder to inspect; feeds one successor

The visible failure of a bad handoff is relitigation: the new session re-opens decisions the old one had settled, because the carry recorded what was decided but not why.

Autocompact is particularly dangerous — it's compaction triggered automatically when the context window hits ~80% full, firing mid-task at whatever moment the threshold is hit. It can quietly lose constraints. Prefer manual compaction at phase boundaries.

Skills: Procedures vs Abilities

Matt Pocock distinguishes two types of agent skills:

Type	Who Invokes	Example	Philosophy
Procedure	You invoke it explicitly	"Grill me" adversarial interviewer, "teach" course generator	You stay in control; the model follows instructions
Ability	The model invokes itself	Coding standards checker, formatting enforcer	The model decides when to use it

Matt strongly prefers procedures: "I know my skills, I know my abilities. I don't want to delegate my thinking to the model."

Skills implement progressive disclosure — only the name and description sit in context by default. The full instructions (potentially thousands of tokens) load only when the skill is triggered. This keeps the always-loaded layer small and the context window free.

Context pointers are the mechanism: a one-line mention ("deploy process: see internal/deploy.md") that the agent follows only when the task matches. Compare that to inlining a 2,000-token runbook in AGENTS.md — which pays the token cost on every turn, every session.

AFK: The Throughput Multiplier

AFK (away from keyboard) is the working pattern where you kick off a session and leave the agent to run unattended. It's the throughput multiplier — many AFK sessions can run in parallel while you sleep.

Matt's setup: Sand Castle — agents inside Docker/Podman sandboxes, parallelized on GitHub Actions. Agents pick up labelled issues, implement them, and submit PRs. He reviews the PRs, not the process.

The AFK pattern requires three layers:

Before: Resolve ambiguity upfront — grilling, a written spec — so there are fewer gaps for the agent to fill alone
During: Automated checks and automated review stand in for the attention you're not giving
After: The run ends in something reviewable — a PR, not changes already merged

"AFK doesn't remove human review; it defers all of it to the end, which is why what arrives at the end has to be worth reviewing." — AI Coding Dictionary, "AFK"

Loops vs Queues

Matt pushes back on the "agentic loop" framing:

"Agentic 'loops' are overhyped. Think in terms of queues — a backlog of scoped tasks that AFK agents pick off. This mirrors how real dev teams work. A single infinite loop doesn't match team reality; queues with multiple nodes do."

The queue model: GitHub issues labelled by type → AFK agents pick up matching issues → sandboxed implementation → automated checks pass → PR submitted → human review.

This is fundamentally different from a single agent running in an infinite loop. It's parallelizable, reviewable, and recovers from individual failures without losing the whole run.

Codebase Quality as Cost Lever

"If your codebase architecture is better, then you can get a cheaper model to do the same work — your guard rails are better, it needs to spend fewer tokens banging its head against the wall." — Matt Pocock

This is the AX (agent experience) argument. Good AX has three dimensions:

Dimension	What Good AX Looks Like
Automated checks	Fast, deterministic tests, types, and lints the agent can self-correct from
Architecture	Predictable structure, behaviour behind small interfaces, names that say what things do
Free context	Lean AGENTS.md, skills behind context pointers — most of the context window available for the task

AX and DX overlap (good checks help both) but diverge. Humans tolerate tribal knowledge and slow CI; agents can't. A codebase can have good DX and poor AX. The fix when an agent performs well in one repo and badly in another is usually AX, not a model change.

Verification Layers

Agents produce more code, which means verification becomes the bottleneck. Three layers, from cheapest to most expensive:

Layer	What It Catches	Deterministic?	Cost
Automated checks	Type errors, test failures, lint — what can be asserted mechanically	Yes	Machine
Automated review	Misleading names, missed edge cases, judgement-shaped problems	No	Machine
Human review	Whether the change is right, whether it fits the codebase, whether it should exist	No	Human attention

Vibe coding removes human review entirely — behaviour is the only thing checked. Trade speed for inspection. Appropriate for prototypes and one-off scripts; dangerous for auth flows and production code.

"Don't just fix the bug, fix the system. When you find a security bug, the 10x AI builder asks: how did this bug exist so long without being caught? Then builds a system to prevent the class of problem." — Matt Pocock

The Design Concept

Brooks' term, revived by Pocock: the design concept is the shared understanding of what's being built, held in common between user and agent but separate from any asset.

The failure pattern: the agent writes exactly what you asked for and it's still wrong. The cause: you hadn't fully figured out what you wanted. The design concept wasn't finished in your head — your prompt captured the parts you'd worked out, and the agent filled the silences with its own assumptions.

Grilling is the deliberate fix: the agent interviews you Socratically, one decision at a time, proposing a recommended answer for each. No handoff artifact is written until the concept stabilizes. When conversation is too low-fidelity, switch to prototyping — build a quick rough version, look at it, and come back to the conversation.

Putting It Together: The Agentic Engineering Stack

Harness — Claude Code, Hermes Agent, or any agentic coding harness (you control this)
Skills — Procedures you invoke (grill, teach, deploy) with progressive disclosure behind context pointers
AGENTS.md — Short standing brief: build commands, conventions, constraints. Lean — not a style guide dump
Specs & Tickets — Scoped units of work that AFK agents pick off from a queue
Automated checks — Types, tests, lints that give the agent self-correction signal
Sandbox — Isolated environment for AFK runs; read-only filesystem, no network unless needed
Human review — Read the diff, not the summary. Reserve for what only you can judge