What is agentic coding? - Glossary

This glossary gathers the essential definitions of agentic coding, Claude Code, and associated concepts. You will find each term explained in a self-contained sentence, with a concrete usage example to master the vocabulary of AI agent-assisted programming.

The vocabulary of agentic coding refers to the set of technical terms describing how an autonomous AI agent writes, modifies, and orchestrates code on your behalf. This field is experiencing rapid adoption with tools like Claude Code (Anthropic, 2025) that transform the terminal into an AI-driven development environment. Claude Code surpassed 500,000 active users six months after its launch.

What are the fundamental terms of agentic coding?

The definitions below cover the basic concepts you will encounter from your very first sessions with a code agent. See the guide on agentic coding for an overview before diving into the glossary.

Code agent is an AI program capable of executing development tasks autonomously in a real environment. Example: You ask "add a /health route to my Express API" and the agent creates the file, writes the code, and runs the test.

Agentic coding is the paradigm where a developer delegates complete tasks to an AI agent that plans, executes, and verifies its own actions. Example: Instead of typing each git command, you say "prepare a commit with the modified files" and the agent takes care of it.

Graduated autonomy is the principle by which an agent operates with different permission levels, from supervised mode to fully autonomous mode. Example: In plan mode, Claude Code submits each modification for your approval before applying it. In bypassPermissions mode, it acts without asking.

Agentic loop is the iterative cycle of planning, execution, observation, and correction that an agent repeats until completing a task. Example: Claude Code writes a test, runs it, observes the failure, fixes the source code, then reruns the test - all without intervention.

Key takeaway: these four terms form the conceptual foundation of agentic coding that you will find in every tool and every workflow.

How does Claude Code work in your terminal?

Claude Code is installed via npm and runs directly in your shell. To understand the installation step by step, refer to the installation and first launch FAQ.

Claude Code is a CLI tool developed by Anthropic that integrates an AI agent directly into the terminal for coding, debugging, and refactoring. Example: You type claude in your terminal, describe your need in natural language, and the agent modifies your files.

# Installing Claude Code via npm
npm install -g @anthropic-ai/claude-code
claude --version
# Claude Code v1.0.34

CLI (Command Line Interface) is a text-based interface where the user interacts with a program via typed commands. Example: You run claude "explain this file" directly from your terminal without opening an IDE.

Context (Context Window) is the maximum amount of text that an AI model can process in a single request, measured in tokens. Example: Claude Sonnet 4.6 handles a window of 200,000 tokens, or approximately 150,000 words. In practice, this allows analyzing an entire medium-sized project. The context management FAQ details optimization strategies.

CLAUDE.md is a persistent memory file that Claude Code reads automatically to load your preferences and project conventions. Example: You write "always use bun instead of npm" and the agent applies this rule in every session. See the CLAUDE.md memory system FAQ to configure this file.

Slash command is an instruction prefixed with / that triggers a specific action in Claude Code. Example: /commit automatically generates a commit message based on your changes. The slash commands FAQ lists all available options.

Key takeaway: Claude Code transforms your terminal into an augmented development environment - in practice, you keep your usual tools while adding a layer of intelligence.

What are the differences between Claude Code, Copilot, and Cursor?

The choice of a code assistant depends on your workflow. Each tool takes a distinct approach. The in-depth analysis of agentic coding compares these paradigms in detail.

GitHub Copilot is a code completion assistant integrated into IDEs that suggests lines or blocks of code in real time. Example: You start writing a function and Copilot automatically completes the body in VS Code.

Cursor is a VS Code-based IDE that integrates an AI agent capable of modifying multiple files simultaneously via a graphical interface. Example: You select a code block, describe the desired modification, and Cursor applies the changes with a visual diff.

Orchestrated code is the paradigm where the developer describes an objective and the agent manages the entire workflow: writing, testing, and deployment. Example: You say "migrate this API from REST to GraphQL" and the agent plans the steps, modifies the files, and verifies compilation.

78% of developers use at least one AI assistant in their daily workflow. In practice, Claude Code stands out for its ability to execute system commands, placing it in the agent category rather than simple autocompleters.

Code completion is the feature that predicts and suggests the continuation of code being typed, without autonomous execution. Example: Copilot suggests a grayed-out line of code that you accept with Tab - it modifies nothing without your validation.

Multi-file (editing) is an agent's ability to modify multiple code files in a single coordinated operation. Example: You ask to rename a function and Claude Code updates the declaration and all calls across 12 files in 8 seconds.

Key takeaway: Claude Code operates as an autonomous agent in the terminal, while Copilot remains a suggestion tool and Cursor combines both approaches in an IDE.

What AI models are available: Haiku, Sonnet, and Opus?

Anthropic offers three models in the Claude family, each optimized for a specific use case. The agentic coding FAQ explains when to use each model.

Claude Haiku 4.5 is Anthropic's fastest model, optimized for simple tasks requiring minimal latency. Example: You use Haiku to reformat a JSON file - the response arrives in under 500 ms.

Claude Sonnet 4.6 is Anthropic's mid-range model offering a balance between performance, cost, and reasoning quality. Example: You ask Sonnet to write a validation function with unit tests - the result is accurate and costs $3 per million input tokens.

Claude Opus 4.6 is Anthropic's most powerful model, designed for complex reasoning tasks and advanced agentic coding. Example: You entrust Opus with migrating a codebase from JavaScript to TypeScript - it handles complex types and edge cases.

Token is the basic unit used by language models to split text, corresponding to approximately 0.75 words in English. Example: The sentence "Hello world" contains approximately 2 tokens. A 1,000-line code file represents approximately 15,000 tokens.

Temperature is the parameter controlling the degree of creativity in an AI model's responses, from 0 (deterministic) to 1 (creative). Example: For production code, set the temperature to 0 to get reproducible results.

Key takeaway: choose Haiku for speed, Sonnet for daily use, and Opus for demanding tasks - in practice, 80% of your sessions will use Sonnet.

How do pricing plans and consumption work?

Claude Code billing is based on token consumption. Check your usage regularly via the Anthropic dashboard. To manage your permissions and limit costs, the permissions and security FAQ guides you.

Anthropic API is Anthropic's web service that allows sending requests to Claude models and receiving responses programmatically. Example: You configure your API key with export ANTHROPIC_API_KEY=sk-... before launching Claude Code.

# API key configuration
export ANTHROPIC_API_KEY="sk-ant-your-key"
claude "list the project files"

Token consumption is the measurement of the volume of text processed by the API, billed per million tokens. Example: In practice, a 30-minute refactoring session with Sonnet 4.6 consumes approximately 50,000 input tokens and 20,000 output tokens, or about $0.45.

Max plan (Claude Max) is the high-usage monthly subscription offered by Anthropic at $100 or $200/month for unlimited access to models. Example: With the Max plan at $200/month, you use Claude Code without worrying about the token counter for the entire month.

Rate limiting is the mechanism that limits the number of API requests per minute to prevent server overload. Example: If you reach the limit of 60 requests per minute, Claude Code displays a waiting message and automatically resumes after 30 seconds.

the Max 20x plan covers the needs of 95% of professional developers using Claude Code daily.

Key takeaway: estimate your consumption over a work week before choosing a plan - the Pro plan is sufficient for moderate use, the Max plan is for intensive users.

What technical concepts do you need to master?

These terms describe the internal mechanisms you will encounter when using Claude Code daily. To start your first sessions, follow the first conversations FAQ.

Diff (patch) is the format for displaying code modifications showing lines added and removed between two versions of a file. Example: Claude Code displays a colored diff after each modification - green lines are added, red ones are removed.

- const port = 3000;
+ const port = process.env.PORT || 3000;

Hallucination is a response generated by an AI model that contains factually incorrect information presented with confidence. Example: The agent invents a non-existent npm package name - always verify suggested dependencies with npm search.

MCP (Model Context Protocol) is an open protocol allowing Claude Code to connect to external data sources such as databases or APIs. Example: You configure an MCP server so that Claude Code can directly access your PostgreSQL database. See the MCP FAQ for complete configuration.

Prompt is the natural language instruction you send to an AI agent to trigger an action or obtain a response. Example: "Refactor this function to use async/await" is a prompt. A precise 20-50 word prompt produces 40% more relevant results than a vague prompt.

Prompt engineering is the discipline of formulating optimal instructions to get the best results from an AI model. Example: Instead of "fix this bug", you write "identify why the POST /users request returns 500 and propose a fix with a test".

# Structured prompt for Claude Code
claude "Read the file src/api/users.ts,
  identify the cause of the crash on POST /users,
  write a non-regression test,
  then apply the fix."

Sandbox is an isolated execution environment where the agent runs commands without risk to the host system. Example: Claude Code runs rm in a sandbox by default - files outside the working directory are protected.

Streaming is the transmission mode where the model's response appears progressively, token by token, instead of waiting for the complete response. Example: You see the code appear line by line in your terminal, allowing you to detect an error before generation is complete.

Key takeaway: mastering these technical concepts lets you understand what the agent does under the hood and optimize your interactions.

Why train in agentic coding in 2026?

Agentic coding represents a paradigm shift in the way software is developed. SFEIR Institute offers training courses suited to each level to ramp up skills quickly.

Augmented developer is a development professional who uses AI agents as a productivity lever while maintaining technical mastery. Example: You write the architecture, the agent generates the boilerplate code, and you verify the result - your productivity increases by 30 to 50% depending on the tasks.

Orchestration is the coordination of multiple AI agents or tools working together to accomplish a complex development task. Example: You launch one agent to write the code, another for the tests, and a third for documentation - all three work in parallel.

AI pair programming is the collaborative practice where a developer works alongside an AI agent instead of a human colleague. Example: You think about the architecture while Claude Code implements your decisions in real time in the terminal.

To practice these concepts in a structured setting, the Claude Code one-day training at SFEIR lets you master the tool with hands-on labs on real cases. If you want to go further, the AI-Augmented Developer 2-day training covers the full range of agentic workflows with multiple tools. Experienced profiles will appreciate the AI-Augmented Developer - Advanced one-day training, focused on multi-agent orchestration and complex use cases.

Key takeaway: agentic coding is not a fad - it is a measurable technical skill that is acquired through guided practice.

What additional terms should you know?

Here are the remaining glossary terms, which complete your agentic coding vocabulary. You will encounter them in official documentation and advanced tutorials.

Decision tree (planning tree) is the internal structure that an agent builds to break down a complex task into ordered sub-tasks. Example: For "add JWT authentication", the agent creates a plan: install the package, create the middleware, add the routes, write the tests.

Automated code review is the analysis of code by an AI agent that identifies bugs, security flaws, and style issues. Example: You run claude /review and the agent flags 3 potential SQL injections and 7 unused variables in 12 seconds.

Few-shot prompting is the technique of providing a few examples in the prompt to guide the model's behavior. Example: You show 2 examples of functions with their documentation, then ask the agent to document the rest of the file.

Grounding is the process by which an AI agent anchors its responses in actual project data rather than its general knowledge. Example: Claude Code reads your package.json and file tree before suggesting code - it adapts to your actual dependencies.

Human-in-the-loop is the interaction model where a human validates each critical step of the agent before it proceeds. Example: In plan mode, Claude Code shows you the planned modifications and waits for your approval before applying them.

Retrieval-Augmented Generation (RAG) is the technique combining document retrieval and text generation to produce responses grounded in specific sources. Example: The agent searches your internal documentation before generating code, reducing the hallucination rate by 60%.

Tool use (function calling) is the ability of an AI model to call external tools such as a terminal, browser, or database during its reasoning. Example: Claude Code calls git diff to see your modifications, then npm test to verify everything passes - without you typing those commands.

{
  "tool": "bash",
  "command": "npm test -- --coverage",
  "description": "Run tests with coverage"
}

Key takeaway: these advanced terms prepare you to leverage the most powerful features of code agents - in practice, each concept corresponds to a concrete productivity lever.