What is Claude Code and how do you use it?

Claude Code in one paragraph

Claude Code is Anthropic's agentic coding tool for working directly with software projects. It can inspect a repository, trace dependencies, edit multiple files, run commands and tests, analyze failures, and handle parts of a Git workflow. The terminal is its original home, but Claude Code also works in VS Code, JetBrains IDEs, the desktop app, and a browser-based environment.

The important difference from a normal chatbot is that Claude Code does not have to stop after suggesting a code snippet. It can gather context, act on the project and verify the result. It still needs human oversight, but with a well-scoped task it behaves more like a collaborator inside the repository than an answer box beside it.

This is an evergreen guide. We will keep it updated as Claude Code's installation, features and recommended workflows change.

What is Claude Code?

Claude Code combines a language model with the tools used in software development. The model interprets instructions written in natural language. The agent layer lets it take concrete actions in the project environment.

It can:

• locate the files responsible for a feature;
• explain how data moves between modules;
• prepare a plan for a larger change;
• modify application code, tests and documentation;
• run linting, tests, type checks and builds;
• inspect errors and revise an implementation;
• read Git history, create commits and assist with pull requests;
• connect to external services through MCP;
• delegate focused work to subagents.

It is still a large language model, so it can make mistakes. The useful distinction is that it can test its own proposal with tools. A well-configured coding agent should not stop at saying “done.” It should show what changed and how the result was verified.

The agentic loop

A useful mental model for Claude Code is a three-stage loop:

1. Gather context. The agent reads instructions, explores the project structure and opens files related to the task.
2. Take action. It proposes or applies edits, runs commands and uses available tools.
3. Verify. It checks tests, diagnostics, the diff and the requested outcome.

After verification, it can return to exploration, collect missing context and improve the solution. That iteration is what separates a coding agent from conventional autocomplete.

Claude Code does not need to dump an entire repository into the context window. It searches for relevant locations and builds its understanding incrementally. This is why prompt quality is not mainly about length. A clear goal, constraints and a definition of success matter more.

A good agent task describes the desired end state and the evidence that will prove it works. A weak task merely says, “fix it.”

Where Claude Code runs

The name reflects its terminal-first design, but Anthropic now supports several working surfaces:

• Terminal provides the most direct local agent workflow.
• VS Code and JetBrains IDEs combine the conversation with file, diff and diagnostics views.
• The desktop app offers graphical sessions without giving up repository-level work.
• Claude Code on the web runs tasks in a hosted environment and suits asynchronous work.
• GitHub Actions can trigger selected workflows from issues or pull requests.

These modes are complementary. The terminal is useful for local work, an IDE integration for hands-on editing, and a hosted session when the task should continue away from the developer's machine.

How to install Claude Code

Anthropic maintains the current commands in its official quickstart. The documentation now recommends the native installer, which can keep Claude Code updated in the background.

macOS, Linux and WSL

curl -fsSL https://claude.ai/install.sh | bash

Windows PowerShell

irm https://claude.ai/install.ps1 | iex

Homebrew and WinGet installation options are also available. After installation, move into a project directory and run:

claude

Claude Code will ask you to authenticate on first launch. Access may come from an eligible Claude plan or usage billed through an API account. Organizations can also deploy it through supported cloud platforms.

Your first session: explore before editing

Do not begin with “rewrite the entire application.” First, check how the agent understands the repository:

Analyze this project's structure. Explain where authentication is handled,
which tests cover it, and which files would need to change to add API-key
login. Do not edit any files yet.

This prompt identifies the area, requests a useful deliverable and prevents premature edits. You can then ask for a plan:

Create a plan made of small, verifiable steps. Include tests and preserve
the current error-handling conventions. Show the plan before implementing it.

Finally, require evidence:

Run the authentication tests, type checking and linting. Summarize the diff,
the command results and any risks you could not verify.

The pattern is simple: explore → plan → implement → verify. It is usually more reliable than one enormous prompt, especially in an unfamiliar or older codebase.

CLAUDE.md: the repository's operating manual

One of Claude Code's most important features is the CLAUDE.md file. It provides durable project context: a concise set of instructions that tells the agent how the repository should be handled.

Useful contents include:

• the canonical test, lint and build commands;
• architecture notes that are not obvious from the file tree;
• naming and formatting conventions;
• security constraints;
• files or generated artifacts that should not be edited;
• the team's definition of done;
• recurring traps that cannot be inferred from the code alone.

For example:

# Claude Code guidance
 
- Use pnpm, not npm.
- Before finishing, run: pnpm lint, pnpm typecheck and pnpm test.
- Do not edit migration files unless the task explicitly requires it.
- New endpoints must use the validators in src/lib/validation.
- Preserve both English and Polish user-facing copy.

A good CLAUDE.md is short and operational. It should not duplicate the entire documentation set. If it grows too large, move specialized guidance closer to the relevant code or link to a document that only needs to be read for a particular task.

Plan Mode and low-risk exploration

For changes that cross several modules, begin in Plan Mode. The agent can inspect and reason about the project without freely editing it. This makes incorrect assumptions visible before they become a large diff.

Planning is especially useful for:

• framework or dependency migrations;
• bugs with an unclear root cause;
• authentication and authorization changes;
• refactors of shared modules;
• work in a repository you do not yet understand.

A plan is not proof of correctness. It should name relevant files, dependencies, verification steps and areas of risk. If it remains generic, ask the agent to investigate further before implementation.

Permissions, sandboxing and secrets

Claude Code can execute real commands, so security cannot depend on a sentence in a prompt. Its permission system distinguishes lower-risk reading from actions that modify the environment and may require approval or a matching rule.

Before approving a command, check:

• exactly what will run;
• the working directory;
• whether it can modify or delete data;
• whether it uses network access;
• whether production credentials are present in the environment.

Anthropic also provides operating-system-level sandboxing. The sandbox can restrict filesystem and network access while reducing repetitive approval prompts. It works on macOS, Linux and WSL2, but not directly in native Windows. The core principle remains unchanged: grant the agent only the access required for the task.

Keep production secrets out of the repository and away from files the agent may inspect. Use a separate branch, container or test environment for risky work. Always review the diff before committing.

We explored the wider problem in our analysis of how Anthropic contains Claude agents.

Context management: longer is not always better

During a session, Claude Code accumulates conversation history, command output and file excerpts. Eventually the context can become crowded with stale hypotheses, logs and instructions that no longer matter.

Practical rules:

• use /clear when moving to an unrelated task;
• use /compact when you want to preserve the core of a long session while dropping noise;
• delegate research to a subagent when the final answer is small but the search requires many files;
• avoid pasting huge logs when the relevant error section is enough;
• split broad work into phases with separate success criteria.

More tokens do not automatically produce a better answer. A clean context often helps more than another page of conversation history.

MCP, hooks, skills, plugins and subagents

Claude Code can be extended beyond its default tools.

MCP, the Model Context Protocol, can connect the agent to services and data such as an issue tracker, documentation, a database or observability tools. Every connection also expands the agent's capabilities, so it should use narrow credentials and minimal permissions.

Hooks run deterministic scripts at selected points in the workflow. They can format changed files, reject disallowed commands or trigger quality checks.

Skills and plugins package instructions, commands and integrations into reusable components. They are valuable when a team performs the same kind of work across several repositories.

Subagents receive their own context and a focused role. One might inspect tests, another documentation and a third security concerns. Their conclusions can return to the main session without filling it with every intermediate step.

These are powerful building blocks, but they do not all need to be enabled on day one. Stabilize a simple local workflow first. Automate the process once the team knows how to evaluate it manually.

How much does Claude Code cost?

Claude Code does not have one universal cost independent of how it is used. Access can come through a Claude plan or metered model usage through an API account. Actual cost depends on the selected model, context length, number of agent steps, tool calls and frequency of use.

A repository-wide migration will consume more than an explanation of one function. Repeatedly reading large files or launching parallel subagents can also increase usage.

Instead of tracking token price alone, measure:

• cost per completed task;
• time saved in implementation and review;
• revisions needed after the first result;
• the share of changes that must be reverted manually;
• spend on sessions that did not produce useful work.

Check the Claude Code product page and cost documentation for current plans because limits and billing details can change. We have also covered Anthropic's recent Claude Code usage-limit increase.

Claude Code vs Cursor, GitHub Copilot and Claude chat

These products overlap, but each has a different natural center of gravity.

Claude Code is a task- and repository-oriented agent. It is well suited to multi-file analysis, commands, migrations, debugging and work that runs from exploration through verification.

Cursor and similar AI editors keep the IDE at the center. They are convenient for continuous hands-on coding where the developer wants files and suggestions visible at all times.

GitHub Copilot combines autocomplete, chat and a growing set of agent features, especially close to GitHub workflows.

A normal Claude conversation is useful for explanation, design and reasoning over supplied material, but it does not automatically have the same access to a local repository and development tools.

This is not necessarily an either-or decision. Claude Code can work inside an IDE, while a team uses autocomplete for small edits and the agent for larger, verifiable tasks.

Where Claude Code works best

The strongest tasks are those where the agent can verify its work:

• fixing a bug with a reproducible case;
• adding a feature with clear acceptance criteria;
• refactoring code covered by tests;
• migrating an API or dependency;
• understanding an unfamiliar repository;
• adding tests around existing behavior;
• drafting documentation from the code;
• reviewing a diff for a specific class of risk;
• automating repetitive Git work.

It is less reliable when success is mostly a matter of taste and the requirements keep changing during the task. If you cannot explain what a good result looks like, the agent will struggle too.

Common mistakes

Giving an open-ended instruction

“Improve the architecture” does not say which problem should disappear. Name the symptom, constraints and final test instead.

Accepting the summary without reading the diff

An agent can write a convincing explanation despite a flawed change. The source of truth is the code, tests and application behavior.

Omitting verification criteria

If the project lacks tests, ask for a reproduction, type check, build or a small regression test.

Overloading CLAUDE.md

Hundreds of instructions compete for attention. Keep the rules that genuinely affect decisions.

Granting broad permanent permissions

Fewer confirmation prompts save time but increase the consequences of a mistake. Permission rules should be narrow and predictable.

Using one endless session

Unrelated problems deserve separate context. Conversation history is not project memory; instructions, documentation and code are.

A practical pre-flight checklist

• Is the goal stated in one concrete sentence?
• Does the agent know the constraints and files it should not touch?
• Is there a test or another measurable definition of success?
• Is the work happening on a separate branch?
• Are production secrets and data out of reach?
• Should the agent produce a plan first?
• Will you review the diff and command output?
• Does CLAUDE.md contain the current project commands?

If most answers are yes, the agent has a good environment for useful work.

What changed in Claude Code in 2026?

Claude Code has moved well beyond a terminal experiment. Anthropic now develops a desktop app, browser-based work, IDE integrations, plugins and skills, subagents, checkpoints and more mature team workflows.

With Claude Opus 4.8, Anthropic also introduced dynamic workflows in research preview: the ability to plan larger jobs and coordinate many subagents. That is a direction of travel, not a reason to give an agent unrestricted production access. Our Claude Opus 4.8 analysis explains the change in more detail.

The most important evolution is less theatrical. Claude Code is increasingly connected to the actual software delivery process. Permissions, sandboxing, hooks, organization policies and usage analytics matter as much as the model itself.

Will Claude Code replace developers?

Not in a responsible software process. An agent can take over mechanical work, accelerate codebase exploration and produce a strong first implementation. It does not automatically know the business intent, the history behind tradeoffs or consequences that are not represented in the repository.

The developer's role partly shifts from typing every change toward defining the problem, designing constraints and evaluating evidence. That remains technical work. In some ways it becomes more demanding because a large change can be generated quickly and still needs accountable review.

Claude Code is most valuable not when it pretends to be an autonomous expert, but when it shortens the path from a well-defined problem to a verified solution.

FAQ

Is Claude Code free?

Access depends on current Claude plans or API billing. Limits and features vary, so check the official product page for the latest terms.

Does Claude Code work on Windows?

Yes. Anthropic provides a native PowerShell installer. WSL2 is also an option when the project relies on a Linux-based toolchain or you want to use the built-in sandbox.

Does Claude Code send source code to the cloud?

The model needs relevant context to respond, so selected code and session data are processed by the service according to your deployment and plan. Before organizational use, review Anthropic's data usage documentation, retention settings and rules for sensitive code.

Can Claude Code commit and push code?

It can use Git commands when permissions allow. A commit should follow diff review and tests. A push, package publication or production deployment deserves a separate, deliberate approval.

Do you need to know programming?

Claude Code can explain code and help beginners, but without technical knowledge it is harder to spot a subtle defect, unsafe command or unnecessarily complex design. The larger the impact of a change, the more important competent review becomes.

Is Claude Code safe?

It includes permissions and optional sandboxing, but safety also depends on the environment, access scope and user behavior. A separate branch, minimal permissions, no production secrets and careful diff review remain essential.