Glossary

Your lens

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

Agent: A program you hand a task to, which works through it a step at a time: it uses an LLM to work out the next move, acts, and goes again. It holds the tools it may use and a working memory limited to the task in hand.
Agentic coding: An agent doing the coding work itself: it takes a task, changes the code, runs the tests, sees what failed and goes again. What a person spends time on shifts to stating the task well and judging what comes back.
Agentic Engineering: Building with agents across the whole software lifecycle, not only the coding, under the standards professional software already had to meet. Both have to be explicit: which standards still bind the work, and who is answerable for what ships. Neither can be handed to the agent.
AX (Agent Experience): What User Experience is for the people using a product, this is for the agents working in the codebase: what they must know written down, boundaries enforced rather than assumed, failures caught by a check instead of in review. Like any infrastructure, it needs an owner and goes stale.
Human in the loop (HITL): The team names the steps an agent may not take alone, then makes the tooling enforce them. Written into a policy it is a hope; encoded in the gates it is a control — and only the second one survives a busy week.
Non-determinism: The same brief does not produce the same work, and two runs can both be right. The model picks among plausible answers. And the same brief is not the same input: the standing instructions and the whole conversation so far are re-sent with it.
PRD (Product Requirements Document): The document that states what the software must do for the business (scope, rules, visible behaviour, acceptance criteria) in the language of the business rather than the build, so a sponsor can review it. Scope is agreed here, before the team builds against it.
SDLC (Software Development Lifecycle): The phases software passes through, from planning and requirements to deployment and maintenance, each ending in its own output and a hand-off to the next. Agents can support every phase; the hand-offs decide how much of that gain reaches delivery.
Skill: A written procedure an agent loads when a task calls for it — the team's way of working, in a file instead of in someone's head. Some apply themselves; others run only when asked for by name. Like code, they need maintaining: a skill nobody keeps current drifts away from how the team actually works.
Vibe Coding: A way of working where AI produces the code and the result is judged only from the business side: does it do what it should? The technical side — architecture, tests, maintainability, security — is not judged, and the code is barely reviewed and only partly understood.