Definition

Claude Code is an agentic development tool from Anthropic: it reads codebases, edits files, executes shell commands, and calls external tools. Available in the terminal, VS Code, JetBrains, the desktop application, and at claude.ai/code; all surfaces run on the same engine, read the same CLAUDE.md files, and follow a unified settings hierarchy.

The key word here is "agentic." Claude Code doesn't just answer questions — it acts. It plans a task, calls tools in sequence, and sees the work through to completion without requiring human input at every step. That shift is what this entire article is about.

A Brief Product History

Anthropic released Claude Code in early 2025 as a research preview — initially as a terminal tool, an experiment in agentic coding. The product evolved rapidly: plugins for VS Code and JetBrains arrived, followed by a desktop application, MCP server support, cloud agents (routines), and an Agent SDK for programmatically building custom agents.

Early versions were perceived as a "smart bash assistant": you typed a command, Claude suggested a code snippet. Today the picture is fundamentally different — Claude Code independently explores an unfamiliar codebase, draws up a plan, modifies dozens of files, runs tests, and commits the result. What used to take half a workday of routine effort becomes a single, well-formulated task.

The Agentic Loop

The heart of Claude Code is the agentic loop. It works like this:

1. You give it a task — interactively or via a headless call.

2. The model analyzes the context and chooses the next step.

3. If a tool is needed — Read, Edit, Bash, Grep, Glob, or any MCP tool — Claude calls it.

4. Claude observes the result: command output, file contents, an error message.

5. Based on that observation — back to step 2. The loop repeats until the task is complete.

flowchart TD
    A[User Task] --> B[Analysis and Planning]
    B --> C{Tool needed?}
    C -->|Yes| D[Tool Call\nRead / Edit / Bash / Grep…]
    D --> E[Observing Result\noutput · file · error]
    E --> B
    C -->|No| F[Task Complete]
    style A fill:#4a90d9,color:#fff
    style F fill:#5cb85c,color:#fff
    style C fill:#f5a623,color:#fff

This "plan → act → observe" loop is what makes Claude Code an agent rather than a chatbot. The model doesn't wait for you to copy output into the next message — it reads the result itself and continues working.

Unix Philosophy: Composability as a Principle

Claude Code is built on Unix principles: small tools that do their job well and know how to work together through streams. This isn't a metaphor — it's a literal capability:

# Pipe a log into Claude and get an error analysis
tail -f server.log | claude -p "Найди паттерны ошибок и объясни причины"

# Get structured JSON for further processing
claude -p "Выведи список всех API-эндпоинтов в этом репозитории" \
  --output-format json | jq '.[]]'

The -p flag (headless / print mode) turns Claude Code into a Unix filter: it accepts stdin, returns stdout, and requires no interactive session. The agent integrates naturally into CI/CD pipelines, shell scripts, and any other automation.

Anthropic has combined the "do one thing well" philosophy with the ability to compose Claude Code with other tools — grep, jq, gh, docker — just like any Unix component. Headless Mode and CLI Scripting covers this side of the tool in depth.

Agent vs. Chat Assistant: A Fundamental Difference

Two scenarios make the distinction clear:

Chat assistant:

You:  "How do I fix this TypeScript error?"
AI:   "Try adding a type to variable X…"
You:  <copy the code, paste it, see a new error, write again>
AI:   "Now you also need to do this…"

Claude Code (agent):

You:    "Fix all TypeScript errors in this project."
Claude: reads tsconfig.json
        → runs tsc --noEmit
        → sees 12 errors
        → fixes files one by one
        → runs tsc again
        → confirms: no errors
        → reports the result

The difference isn't the model's intelligence — it's the architecture of interaction. A chat assistant lives in the space of dialogue; an agent lives in the space of real tools and the filesystem. The agent sees actual command output rather than simulating it.

Several important implications follow:

• An agent can make a mistake and correct itself — it observes every step and adjusts course. A chat assistant only learns about an error from you.
• A task is an intention, not an instruction. You say what needs to be done, not how. The implementation details are up to the agent.
• One task, many steps. A typical agentic session involves dozens of tool calls. That's not a bug — it's a feature.

Why This Changes the Workflow

When a tool can act rather than merely advise, the very way you think about work changes:

Before: "How do I write X?" → get an answer → apply it yourself → come back with a new question.

Now: "Do X" → delegate → review the result → refine or accept.

This is closer to working with a junior developer than to using a search engine. Claude Code works best when a task is framed holistically rather than step by step. "Add tests for the auth/ module, use Jest, coverage no lower than 80%" is a good agent task. "Write a test for the login function" works too, but it puts you in charge of manually orchestrating the entire process.

The key practical takeaway: the more precisely you describe the desired outcome and acceptance criteria, the more effectively the agent works. Prompt engineering for an agent isn't about magic incantations — it's the skill of stating tasks clearly. What a complete working cycle looks like in practice is explored in Typical Workflows: Explore, Plan, Implement.

See Also

• Installation, Surfaces, and Environments — where and how to run Claude Code
• Interactive Mode and Session Navigation — how to work with the agent
• Permission Model, Security, and Trust — what the agent can do and how to control it
• Typical Workflows: Explore, Plan, Implement — the complete working cycle
• Headless Mode and CLI Scripting — Unix integration and automation in depth
• Claude Code Among the Alternatives — comparison with Cursor, Aider, Copilot, and others