Introduction: The AI Engineering Stack This glossary defines the language of Instruction-Led Engineering (ILE). To use these terms effectively, it is helpful to understand that they fall into two distinct categories: General AI Paradigms, which represent the “cognitive ability” of the AI, and Agentic Coding Specializations, which describe how the AI actively works within a professional software workflow.
***
General AI Paradigms
These are the foundational concepts of Generative AI, focusing on how the AI thinks, remembers, and processes data.
- *Context Window Management: The strategy of picking only the most relevant snippets of code to show the AI so it doesn’t get overwhelmed or “hallucinate”.
- *Guardrails: The structured technical and linguistic constraints placed around a stochastic model. They act as the “track walls” that keep outputs safe and within scope, preventing unauthorized actions like deleting your root directory.
- *Stochastic System: Modern Large Language Models (LLMs) operate on probabilistic distributions, unlike traditional deterministic software. This means outputs are determined by the likelihood of the next piece of data, which allows for creativity and human-like conversation, but also requires management for temperature (randomness) and hallucinations.
- *Tool Use / Function Calling: The mechanism that enables the AI agent to “reach out” of the chat window to perform actions like reading a file, writing to a terminal, or listing a directory.
***
Agentic Coding Specializations
These terms move beyond the idea of a “chatbot” and describe how an AI becomes an “active participant” in a filesystem.
- Agentic IDE Orchestration: The advanced practice of using AI agents to autonomously manage the entire software development life cycle directly within an Integrated Development Environment (IDE).
- Agent-Oriented Programming: A paradigm where the AI agent is treated as the primary execution unit, shifting from a passive tool to an active participant that plans, searches, executes, and fixes.
- Agentic Loops: The iterative cycle where an agent follows a pattern to: Plan → Act → Observe → Re-plan.
- Agentic Workflow: Utilizing AI agents that can use tools (such as terminals or filesystems) to complete multi-step tasks autonomously.
- AI-Native Development: Building software where the AI agent is the primary driver and the human developer acts as the “Architect” or “Reviewer”.
- Chain-of-Thought (CoT) Prompting: Instructing the AI to “think out loud” or create a mapped plan before it executes any code.
- Context Poisoning (Context Bloat): When too many competing instructions or irrelevant files are introduced, causing the AI to become confused, slow, or prone to ignoring core rules.
- Context Steering: Using configuration files (like `agent.md`) to define the logic and “soul” of the AI agent within the IDE.
- Discovery Phase: A directive requiring the AI to explore the existing codebase and understand patterns before proposing changes.
- Grounding: Forcing the AI to anchor its responses in the actual reality of your codebase, such as instructing it to only suggest libraries currently in your `package.json`.
- Human-in-the-Loop (HITL): A workflow where the AI proposes a plan or code change but must wait for a human “Reviewer” to approve it before execution.
- Loop Closure: The autonomous process where an agent performs an action, observes a failure, and decides on a correction without needing human intervention.
- MultiStep Planning: The ability of an agent to break down a high-level prompt into a sequence of atomic, actionable tasks.
- Project Memory (RAG in IDEs): Retrieval-Augmented Generation that utilizes the IDE’s ability to index your local files, providing the “knowledge” half of the Project-Specific Brain.
- Prompt Engineering for Agents: Creating system instructions focused on telling the agent how to use its available tools, not just what code to write.
- State Drift: A disconnect that happens when the AI agent’s internal “plan” becomes decoupled from the actual state of the files (e.g., assuming a file was deleted when the command actually failed).
- Synthetic Seniority: Boosting a junior or mid-level developer’s output quality by using an `agent.md` file written by a Principal Architect, enforcing high-level standards the human operator may not even be aware of yet.
***
The Intersection: Instruction-Led Engineering
At the center of general capabilities and agentic coding are the instructions that bridge them.
- Instruction-Led Engineering (ILE): A paradigm where the primary driver of development is a set of persistent, high-level directives rather than manual code entry. The developer acts as a Systems Architect, defining declarative rules for the AI to follow.
- System Prompts & Agent.md: Configuration-as-Prompt files that act as a permanent “System Message” appended to every interaction. They create a “Project-Specific Brain” so the AI never forgets your architectural constraints, style preferences, and actionable directives during long sessions.