Intelligence
Offerings
Writings
Get the briefing
Intelligence
Weekly BriefingThe Brain Problem
Offerings
Skill MakerCompressorOptimizer
Writings
BlogManifesto

Get the Briefing

One email. Every week. Free.

AI Tools

Claude Code: The AI Coding Tool That Lives in Your Terminal

Mon, Feb 23, 2026 · 10 min read
Claude Code: The AI Coding Tool That Lives in Your Terminal

Claude Code is Anthropic's command-line coding tool that turns your terminal into an ai-powered development environment. Instead of switching between a chat window and your IDE, you type a prompt and Claude reads your codebase, edits files, runs bash commands, and creates pull requests — all from the command line.

It launched in early 2025 and has quietly become the default coding assistant for a growing slice of professional developers. Steve Sewell, CEO of Builder.io, wrote in July 2025 that he abandoned Cursor entirely for Claude Code after weeks of testing: "There's no going back." When someone who wrote the definitive Cursor tips guide says that, it's worth paying attention.

How to install and use Claude Code

You need Node.js 18+ and either a Claude Pro/Max subscription or an Anthropic API key. Installation is one command:

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

For api access, set your key:

export ANTHROPIC_API_KEY="your-key-here"

Then start a session by running claude in any repo. That's it. Claude indexes your codebase and you're ready to go. If you use claude.ai with a Pro or Max plan, you can authenticate through your browser instead — no api key needed.

Here's what the basic workflow looks like when you use Claude Code daily:

# Start interactive mode in your repo
claude

# One-shot query (great for scripting)
claude -p "explain the auth flow in this project"

# Continue your last conversation
claude -c

# Pipe content for analysis
cat error.log | claude -p "what's causing these failures"

The -p flag is print mode — it answers and exits, which makes Claude Code scriptable. You can pipe it into other commands, automate it in CI, or use it as a code review step in your git hooks.

Slash commands and the CLI interface

Claude Code's functionality goes deeper than chatting. Slash commands give you control over the session without leaving the terminal:

  • /model — switch between Sonnet 4.5, Haiku 4.5, and Opus 4.5
  • /clear — wipe the conversation (do this often to save tokens)
  • /permissions — manage what Claude can read, write, and execute
  • /install-github-app — set up automatic PR reviews on github
  • /terminal-setup — fix Shift+Enter for multiline input
  • /agents — manage subagents for parallel tasks

You can also create custom slash commands by dropping markdown files in .claude/commands/. Need a quick code review template? Create .claude/commands/review.md with your prompt, and /review becomes available in every session. Arguments work too — $ARGUMENTS in the markdown gets replaced with whatever you type after the command.

The @ syntax lets you reference files directly: @./src/api/auth.ts tells Claude exactly where to look. You can use glob patterns like @./src/**/*.test.ts to reference entire test suites. And the ! prefix drops you into shell mode for quick bash commands without Claude's conversational overhead.

The permission system

This is the part that drives people crazy — and the part that keeps your codebase safe. Claude Code uses a tiered permission system:

Action Approval needed?
Reading files No
Running bash commands Yes (first time per command)
Editing files Yes (per session)

Rules evaluate in order: deny → ask → allow. You can configure them in settings.json:

{
  "permissions": {
    "allowedTools": ["Read", "Write", "Bash(git *)"],
    "deny": [
      "Read(./.env)",
      "Write(./production.config.*)"
    ]
  }
}

There are also permission modes: default (asks each time), acceptEdits (auto-approves file changes), plan (read-only analysis), and bypassPermissions for when you're working in containers or VMs.

Many developers run claude --dangerously-skip-permissions for their daily workflow. Sewell calls it "not as dangerous as it sounds — think of it as Cursor's old yolo mode." That's a personal risk call. For team environments, the fine-grained permission rules and deny lists make more sense.

CLAUDE.md — the system prompt for your project

This is where Claude Code gets genuinely powerful. CLAUDE.md files work like a system prompt for your codebase. Claude loads them hierarchically:

  • ~/.claude/CLAUDE.md — global rules across all projects
  • ./CLAUDE.md — project-level context (check this into git)
  • ./src/api/CLAUDE.md — subdirectory-specific instructions
# Project context

## Stack
- Frontend: Next.js with TypeScript
- Backend: Node.js with Express
- Database: PostgreSQL with Prisma

## Rules
- Use functional components with hooks
- Write tests for all new functions using Jest
- Never modify files in /src/legacy/ directly

This saves enormous amounts of tokens because you don't have to repeat context in every prompt. It also makes Claude Code consistent across your team — every coder working on the repo gets the same instructions. For large workflows that touch multiple parts of a codebase, this is how you keep Claude from making decisions that conflict with your architecture.

GitHub integration and code review

The /install-github-app slash command sets up automatic code review on every pull request. Claude analyzes diffs, flags potential vulnerabilities, and comments directly on the PR.

The default review prompt is too verbose — it comments on everything. Sewell's fix is to customize claude-code-review.yml:

direct_prompt: |
  Review this pull request for bugs and security issues.
  Only report actual bugs and potential vulnerabilities.
  Be concise.

This is a real use case that compounds. As ai coding tools increase your PR volume, automated code review catches the logic errors and vulnerabilities that human reviewers miss while they're bikeshedding variable names. Claude can also pull comments from an existing pull request and address them, which closes the review loop without you switching context.

Hooks — automate everything around Claude

Hooks let you trigger shell commands based on Claude's actions. The most common: auto-format files after Claude writes them.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write(*.py)",
        "hooks": [
          {
            "type": "command",
            "command": "python -m black \"$file\""
          }
        ]
      }
    ]
  }
}

Hook events include PreToolUse (runs before, can block), PostToolUse (runs after), and notification hooks for Slack or other tools. This is where you automate linting, formatting, test runs, and deployment checks around Claude's edits.

The VS Code extension and IDE integration

The claude code plugin for VS Code (also works in Cursor) gives you a launcher pane inside your ide. It's minimal — no fancy UI, just a terminal embedded in your editor. But the key feature is running multiple Claude instances in parallel, each working on different parts of your codebase.

Most developers end up defaulting to Claude first and their editor second. As Sewell put it: "I used to have Claude as a small sidebar while coding in the main editor. Now I default to Claude first and only peek at code when reviewing changes."

The extension works on macos and linux. There's also a VS code extension from community contributors that adds screenshot capture for visual bug reporting — you can paste images with Control+V (not Command+V — one of those terminal quirks).

Why Claude Code handles large codebases better

Builder.io has a React component that's 18,000 lines long. No other ai coding tool — not Cursor, not ChatGPT, not Gemini's coding mode — could successfully update it. Claude Code can.

This comes down to Anthropic building the model and the tool together. When Claude Code hits a limitation, Anthropic goes and improves the underlying llms. They're not a third-party wrapper calling someone else's api — they control the entire stack, from model training to the cli interface. That's why the context handling, file navigation, and codebase understanding feel a generation ahead of tools built on top of OpenAI's models.

Claude Code can also iterate on its own output. It will write code, run it, see the error, fix it, and write code again — looping through bash execution until the test passes. The ai agents pattern lets you spin up subagents that work in parallel on different tasks within the same repo.

Pricing and plans

Claude Code is included in Claude Pro ($20/month) and Max ($100 or $200/month) plans. You can also pay per-token through the api:

Model Input (per MTok) Output (per MTok)
Opus 4.5 $15 $75
Sonnet 4.5 $3 $15
Haiku 4.5 $1 $5

The pricing math is simple: Pro subscribers get access to all three models with usage limits. On Pro, Claude uses Opus until you hit 50% of your allocation, then falls back to Sonnet. Max plans give you significantly more headroom before the fallback kicks in.

For heavy usage, API access with Sonnet 4.5 is often more economical than a subscription. For occasional use, Pro at $20/month is hard to beat. We break down every plan, API cost, and optimization strategy in our Claude Code pricing guide. If you're deciding between model tiers, see our Claude Sonnet vs Opus comparison. And if you're considering the Max subscription for higher limits, our Claude Max deep-dive does the math.

The COBOL story

In February 2026, Anthropic announced that Claude Code can automate COBOL modernization — mapping dependencies, documenting automated workflows, and spotting vulnerabilities in legacy systems that run banking and government infrastructure. IBM stock dropped over 10% the same day. That's not a podcast talking point — it's a market signal about where ai coding is headed.

COBOL modernization is a $2 trillion problem that has resisted automation for decades. The fact that Claude Code can handle it — navigating massive codebases with tangled dependencies, generating documentation, and producing modernized code — tells you something about the ceiling for this coding tool.

When to use Claude Code vs. alternatives

Use Claude Code if you spend most of your time in the terminal, work with large codebases, or want deep git and github integration. The command-line interface feels faster than any IDE sidebar once you internalize the slash commands. If you're new, start with our Claude Code tutorial — it gets you from install to your first pull request in under 30 minutes. If you're already using it, our power user's deep dive covers context management, subagents, and CI/CD automation.

Use Cursor or the vs code extension approach if you prefer a visual IDE and aren't ready to go terminal-first. Use OpenAI's ChatGPT or Gemini for one-off questions where you don't need codebase awareness.

The LinkedIn developer communities have been debating this for months, and the consensus is converging: for professional developers who write code daily, Claude Code is the most capable ai coding assistant available right now. It's not the friendliest for beginners — the terminal interface and permission system have a learning curve. But for anyone who's comfortable in a cli, it's the tool to beat.

Sources

Subscribe to the Spark blog

Recent Posts