Skip to content

Claude Code: Anthropic's Terminal Coding Agent

by Tim Hopper · Markdown
AI Assistants

Claude Code is an AI coding agent from Anthropic that reads a project’s files, edits them, runs shell commands, and iterates on the results. A request is described in plain language, and Claude Code decides which files to read, which commands to run, and what code to write; when a command fails, it reads the error and adjusts. It also runs as a VS Code and JetBrains extension, a desktop app, and in the browser at claude.ai/code, with access to the files and tools available in each environment.

Authentication is available through an eligible Claude subscription, an Anthropic Console account, or a supported cloud provider. Available features and usage limits depend on the account and environment; see the authentication documentation.

Claude Code has no language of its own. It operates whatever tooling a project already uses, which makes its Python behavior a product of configuration rather than built-in support. Pointed at a Python repository, it can install and run uv, create virtual environments, run and repair pytest suites, apply Ruff lint and format fixes, run mypy or ty, and read a traceback to locate the failing line.

When to use Claude Code

Claude Code suits tasks that span multiple files and require running commands to verify the result: writing and fixing a test suite, migrating a project from requirements.txt to a pyproject.toml-based uv workflow, resolving lint and type errors across a package, or tracing a bug from a stack trace to its cause. Its standing-instructions file and hooks make it a fit for teams that want an agent to follow the same tooling conventions on every run. For editor-native inline completion, an autocomplete tool such as GitHub Copilot fits closer to the keystroke; Claude Code operates at the level of a whole task.

Key Features

  • Project-level file editing: reads and edits files across a repository, not one buffer at a time
  • Shell execution: runs build, test, and lint commands and reacts to their output
  • Project instructions: CLAUDE.md, supported AGENTS.md files, and scoped .claude/rules/ guide sessions
  • Hooks: shell commands that fire before or after agent actions, such as formatting after every edit
  • Skills and plugins: reusable workflows invoked by name or selected from a matching request
  • Subagents: delegated tasks with their own context windows and tool access
  • Permission modes and sandboxing: control tool approval and restrict command access
  • Model Context Protocol (MCP) support: connects external data sources and tools through an open standard
  • Git integration: stages changes, writes commit messages, creates branches, and opens pull requests
  • Scriptable CLI: the claude -p flag runs a prompt headlessly for pipelines and CI

Configuration and Instructions

CLAUDE.md is a Markdown file placed in the project root that Claude Code reads at the start of every session. It records standing instructions: which package manager to use (for example, “use uv, never pip”), how to run the test suite, which type checker the project runs, and code conventions to follow. Committing it shares the instructions with collaborators. Instructions guide the model; they do not enforce tool access. Claude Code can also read AGENTS.md under the conditions in the memory documentation, and .claude/rules/ can scope instructions to particular files. Auto memory stores notes across sessions; /memory lets users inspect and edit them.

Settings files control permissions, model selection, and environment for a project or user. Permission modes determine which actions prompt for approval; sandboxing restricts filesystem and network access for shell commands. Hooks extend this configuration with shell commands bound to lifecycle events: a PostToolUse hook can run ruff format after each edit, and a hook before a commit can block it if pytest fails.

Extending Claude Code

Skills package a repeatable workflow (a prompt, its instructions, and any scripts) so it can be invoked by name or matched from a natural-language request. Plugins bundle skills, slash commands, hooks, and MCP servers for distribution through a marketplace; Astral, now part of OpenAI, publishes skills for uv, Ruff, and ty. These provide guidance when loaded; they do not install the tools or enforce project settings.

Model Context Protocol (MCP) servers connect Claude Code to external systems such as issue trackers and databases through a single open protocol, so the agent can read and write data beyond the local filesystem.

Installation 

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

Open a new terminal and run claude --version; a working installation prints the installed version. See setup for package manager alternatives and platform requirements.

After installation, run claude inside a project directory to start a session; the first run prompts for login.

Pros

  • Whole-project action: edits files and runs commands rather than suggesting single lines
  • Tool-agnostic operation: drives uv, Ruff, pytest, and type checkers through the project’s existing configuration
  • Shared conventions: version-controlled instructions and hooks make project workflows available across a team
  • Headless automation: claude -p runs prompts in CI, pipelines, and scripts
  • Extensibility through skills, plugins, and MCP servers

Cons

  • Account usage limits or metered API costs apply; large codebases and long sessions consume more context
  • Instructions and skills guide the model but do not guarantee correctness; command output and diffs still need review
  • Terminal-first workflow is less familiar than inline editor completion for some developers
  • Autonomy over shell commands and git requires review discipline (see enough git to supervise an AI coding agent)
Last updated on