Glossary

Your lens

My own understanding of these terms, not official definitions, so that we read the Insights with the same vocabulary.

Agent: A process that pursues a goal by calling a large language model (LLM) in a loop: send the context, act on what comes back, append the result, send again. It holds what the model cannot — the goal, the history, the tools. The model itself knows only what the context window holds. Which tools it may use is fixed before it runs; the order it uses them in is not.
Agentic coding: An agent doing the coding: it reads files, edits them, and runs the build and the tests. That tells it whether its last change works, and it sets the next step from there. The more it can check for itself, the further it gets without you. Your work sits at both ends: preparing the task so the goal is clear, and verifying what comes back.
Agentic Engineering: Agentic coding covers the code; agentic engineering covers the whole software lifecycle. Agents take part in planning, requirements, design, implementation, testing, review and operation, and every stage stays under the professional standards the system has to meet. The engineering at each stage is the same: prepare what the agent needs — specification, context, constraints — and verify what comes back.
AX (Agent Experience): How easily an agent can do good work in a given environment — what Developer Experience is for you, this is for the agent. In a repository it comes down to whether the agent quickly sees how the project is built, which parts it may change, and which checks it can run to find out it was wrong. Once the agent does most of the writing, it carries the same weight DX does.
Human in the loop (HITL): The human sits at named points in an otherwise automated pipeline, not over its shoulder. What makes it real is a mechanism — a gate that holds the step, a hook that refuses the command, a deploy that waits to be started. If the only thing between an agent and a destructive action is that someone is reading the output, there is no human in the loop; there is a person watching.
Non-determinism: The same instruction does not come back the same, for two independent reasons. The model samples among plausible continuations, so even a fixed input lands differently. And your instruction is never sent alone: the model remembers nothing between requests, so each one re-sends the standing instructions and the whole conversation so far. Type the same prompt again and what arrives is still different.
PRD (Product Requirements Document): The document that states what the software must do for the business, and why: scope, business rules, visible behaviour and acceptance criteria. Architecture, libraries and the build order stay out of it. Design and implementation then build on a concrete definition of what the business needs, in the business's own terms.
SDLC (Software Development Lifecycle): The phases software passes through from idea to operation, such as requirements, design, implementation, testing and maintenance. Each phase ends in an artefact the next one works from, and an agent working in any phase is only as good as the input that artefact gives it.
Skill: A directory with a SKILL.md at its root: a name and a description in frontmatter, Markdown instructions below, plus any scripts and reference files. Only the descriptions load at startup. A model-invocable skill is chosen off its description alone, so a weak description means the skill silently never runs. Set it not to be model-invocable and it runs only when you call it by name.
Vibe Coding: Building software by prompting until it does what you want, without the judgement an engineer brings: the code goes unread, and structure, tests and maintainability play no part. Because that judgement is not needed, people without engineering training can do it too.