title: "What Is Agentic Development? — Claude Code" tested_with: claude-code: "1.0.x" last_updated: 2026-03-21 status: proven difficulty: beginner prerequisites: []

What Is Agentic Development? — Claude Code

What Claude Code Is

Claude Code is Anthropic's terminal-based agentic coding tool. You run it in your terminal, inside your project directory, and it operates directly in your development environment. It reads your files, edits your code, runs your commands, and works with your actual tools — not a copy, not a sandbox, not a browser-based approximation.

This is the key distinction from web-based chat interfaces. Claude Code does not ask you to paste code into a text box. It reads your codebase itself. It does not give you a snippet to copy back — it edits the file directly. It does not tell you to run a command — it runs the command and reads the output. You stay in your terminal, in your repo, with your git history and your tools.

The Architecture

Understanding the architecture helps you predict what Claude Code can and cannot do.

Your Terminal
    |
    v
Claude Code (local CLI process)
    |
    v
Claude model (Anthropic API)
    |
    v
Tools: File Read | File Write/Edit | Bash | Search | Sub-agents

When you type a message, Claude Code sends it — along with relevant context about your project — to the Claude model via Anthropic's API. The model decides what to do: read a file, search the codebase, run a command, or make an edit. Claude Code executes that action locally on your machine, sends the result back to the model, and the loop continues until the task is complete or the model needs your input.

Everything runs locally on your machine except the model inference. Your code is sent to the API for processing, but the file operations, command execution, and edits all happen in your local environment. Your project files live on your disk, not in a cloud workspace.

Key Capabilities

File reading. Claude Code can read any file in your project. It uses this to understand your codebase — reading source files, configuration, tests, documentation, and package manifests. When you ask a question about your code, it reads the relevant files rather than guessing.

File editing. Claude Code makes targeted edits to files. It performs search-and-replace operations on specific sections of code, which means it can modify a function without rewriting the entire file. You see a diff of every change before it is applied (depending on your permission settings).

Search. Claude Code can search across your codebase using pattern matching — finding function definitions, usages, configuration values, or any text pattern. This is how it navigates unfamiliar codebases and traces through code.

Bash execution. Claude Code can run shell commands in your terminal environment. This includes running tests, installing dependencies, checking git status, running linters, building projects, and anything else you would type at a command line. This is what closes the feedback loop — the agent can verify its own work.

Sub-agents. For complex tasks, Claude Code can spawn sub-agents — lightweight, focused instances that handle a specific part of a larger task. For example, the main agent might use a sub-agent to research a question before proceeding with an implementation. This happens automatically; you do not need to configure it.

MCP (Model Context Protocol). Claude Code supports MCP servers, which are plugins that extend its capabilities. MCP servers can provide access to databases, APIs, documentation, and other external tools. If your team has custom tooling, MCP is how you connect it.

Hooks. Claude Code supports hooks — scripts that run automatically at specific points in the workflow. For example, you can configure a hook that runs your linter after every file edit, or a hook that formats code before it is written. Hooks let you enforce project standards automatically.

A Typical Session

Here is what a real session looks like, step by step.

  1. You open your terminal in a project directory and run claude.
  2. You describe what you want. For example: "Add input validation to the createUser endpoint. Reject requests where the email field is missing or not a valid email format."
  3. The agent plans. Claude Code reads the relevant files — the route handler, the existing validation logic, the tests. It may search for how validation is done elsewhere in the project to match existing patterns.
  4. The agent acts. It edits the route handler to add validation. It may update or create tests. It runs the test suite to verify nothing broke.
  5. You review. You see the diffs, the command output, and the agent's reasoning. You approve, request changes, or ask follow-up questions.
  6. The loop continues until the task is done. If tests fail, the agent reads the error output and fixes the issue. If you ask for a change, it adjusts.

The critical point: this is an iterative loop, not a one-shot generation. The agent's ability to observe the results of its actions and adjust is what makes it agentic rather than a fancy code generator.

How Claude Code Differs from Web Chat Interfaces

If you have used ChatGPT, Gemini, or Claude on the web, you are used to a copy-paste workflow: you paste code in, get a response, copy code out, paste it into your editor, try it, and go back to the chat if it does not work.

Claude Code eliminates that round-trip. The differences:

  • It reads your files directly. No need to paste your code in or describe your project structure. It explores your codebase itself.
  • It edits files in place. No copying from a chat window. Changes go directly into your files.
  • It runs commands in your environment. When it runs your tests, it is running your actual test suite with your actual dependencies, not simulating or guessing.
  • It has persistent context within a session. It remembers what it read, what it tried, and what you discussed. You do not need to re-explain context after every exchange.
  • It operates at the project level, not the snippet level. It can make coordinated changes across multiple files in a single task.

The tradeoff is that it requires terminal comfort. If you are not used to working in a terminal, there is a small learning curve. But if you already live in your terminal, Claude Code fits naturally into your existing workflow.

Quick Install and First Run

Prerequisites: Node.js 18 or later.

Install:

npm install -g @anthropic-ai/claude-code

Set your API key (if you have not already):

export ANTHROPIC_API_KEY=your-key-here

You can add this to your shell profile (~/.bashrc, ~/.zshrc, etc.) so it persists across sessions.

First run:

cd /path/to/your/project
claude

Claude Code starts an interactive session. You see a prompt where you can type your first message. Try something simple to verify it works:

> Describe the structure of this project. What are the main components?

Watch what happens. The agent will read files — your package.json, your directory structure, your main source files — and synthesize a description. Pay attention to the tool calls it makes. This is the agentic loop in action.

Non-interactive mode (for scripting or one-shot tasks):

claude -p "Explain what the main function in src/index.ts does"

The -p flag runs a single prompt and exits, which is useful for quick questions or automation.

The Permission Model

Claude Code gives you control over what the agent can do without asking.

By default, Claude Code asks for your approval before:

  • Writing or editing files
  • Running shell commands (with some exceptions for safe, read-only commands)

This means you see every action before it happens and can approve or reject it. For your first sessions, this is exactly what you want — you get to observe the agent's decision-making and build trust incrementally.

As you get comfortable, you can grant broader permissions:

  • Allow specific tools to run without approval (e.g., allow all file reads, or allow specific commands like npm test).
  • Accept all edits during a session when you trust the direction and want to move faster.

The permission model exists because Claude Code runs in your real environment. It can do anything you can do in your terminal. The guardrails are there so you stay in control, especially early on when you are still learning how the agent behaves.

A sensible starting posture: leave defaults in place for your first few sessions. Once you understand the agent's behavior on your specific codebase, selectively loosen permissions for actions you trust. You can always tighten them again.

CLAUDE.md files. Claude Code reads CLAUDE.md files in your project root and subdirectories. These files contain project-specific instructions — coding conventions, preferred patterns, things to avoid. If your project has one, Claude Code follows those instructions automatically. If it does not, creating one is a high-leverage early investment. You will learn more about this in later modules.