Most AI coding tools meet you in the editor. Claude Code meets you in the terminal.

Anthropic’s Claude Code is a command-line agent that understands your codebase, reads and writes files, runs shell commands, and works through complex engineering tasks with genuine autonomy. It’s less of a chatbot with code syntax highlighting and more of a junior engineer that actually has access to your machine.

I’ve been using it daily for several months — including to build this entire site — and it’s changed how I think about AI assistance in my workflow.

What Claude Code Actually Is

Claude Code is an agentic CLI tool. You install it, navigate to a project directory, and start a session. From there, it can:

  • Read any file in your project — it explores the codebase before suggesting changes
  • Edit files directly — using precise diff-based edits, not full rewrites
  • Run shell commands — npm run build, terraform plan, git diff, whatever you need
  • Search your codebase — with grep, glob, and ripgrep integration
  • Browse the web — fetch documentation, API references, or research context
  • Use MCP servers — connect to external tools, databases, and services

The key difference from an in-editor AI is that Claude Code has a persistent loop. It doesn’t just respond to a single prompt — it works through a task over multiple steps, using the results of each action to inform the next.

Installation

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

That’s it. Run claude in any directory to start a session. On first run it walks you through authentication — you can use your Claude.ai subscription or an Anthropic API key.

The Basics: A Real Workflow

Here’s what a typical session looks like. You navigate to your project and start Claude Code:

cd my-project
claude

From the prompt, you can describe what you want in plain language:

> Add input validation to the user registration endpoint.
  Validate that email is a valid format and password is at
  least 8 characters with at least one number.

Claude Code will:

  1. Read the relevant files to understand the existing code structure
  2. Identify the registration endpoint and its current validation logic
  3. Make targeted edits — only the lines that need to change
  4. Optionally run tests to confirm nothing broke

You review the diff before anything is written to disk. You stay in control.

CLAUDE.md: Teaching Claude Your Project

The most underrated Claude Code feature is CLAUDE.md. Drop a file with this name in your project root (or any subdirectory) and Claude Code reads it at the start of every session. Use it to capture:

  • How to run the project, build it, and test it
  • Architecture overview and key file paths
  • Conventions and patterns you want enforced
  • Things Claude should never do in this codebase
# CLAUDE.md

## Commands
npm run dev      # Dev server at localhost:3000
npm run build    # Production build
npm run test     # Run test suite

## Architecture
- Express API in src/api/
- React frontend in src/client/
- Shared types in src/types/

## Conventions
- Use zod for all input validation
- Never use any — use unknown and narrow
- All API responses use the ApiResponse<T> wrapper type

This context means you don’t re-explain your project every session. It also means Claude Code behaves consistently — it knows your patterns and respects them.

Plan Mode

For complex tasks where you want sign-off before any changes happen, use plan mode:

> /plan Refactor the authentication module to use JWT instead of sessions

Claude Code explores the codebase and returns a structured implementation plan — what files will change, what approach it will take, and what edge cases it’s accounting for. You review and approve before a single file is touched.

This is the right workflow for anything non-trivial: refactors, new features, dependency upgrades. It prevents the “AI went off in the wrong direction and now I have a mess” problem.

Permissions and Safety

Claude Code is conservative by default. In the default permission mode, it asks before:

  • Running shell commands
  • Writing or deleting files
  • Making network requests

You can configure these permissions to be more or less restrictive depending on how much trust you want to extend. In practice, I run with fairly permissive settings in personal projects and tighter settings when working in codebases shared with a team.

The --dangerously-skip-permissions flag exists but should stay in your pocket. The confirmation prompts are a useful circuit breaker, not just bureaucracy.

MCP: Extending What Claude Can See

Claude Code supports the Model Context Protocol, which lets you connect it to external tools. This is where it gets genuinely powerful for cloud and DevOps work.

With the right MCP server configured, Claude Code can:

  • Query your AWS resources directly while writing infrastructure code
  • Pull context from your issue tracker or documentation
  • Interact with databases to understand your actual data shapes
  • Run custom tools specific to your organization

MCP servers are defined in your Claude Code settings:

{
  "mcpServers": {
    "aws": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-aws"]
    }
  }
}

Once configured, Claude Code has access to those tools in every session.

Hooks: Automating the Workflow

Claude Code has a hooks system that fires shell commands in response to agent events:

  • PreToolUse — runs before Claude executes a tool
  • PostToolUse — runs after a tool completes
  • Stop — runs when the agent finishes a task

This lets you build lightweight automation into your Claude Code workflow. Run a linter after every file edit, send a notification when a task completes, or log agent activity for audit purposes.

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run lint --silent"
          }
        ]
      }
    ]
  }
}

How I Actually Use It

For this site specifically, I used Claude Code to:

  • Build every component from scratch
  • Iterate on the design system and global CSS
  • Add features incrementally without breaking existing styles
  • Debug build errors and Astro configuration issues

The workflow was: describe what I want, review the plan, approve the changes, check the result in the browser. Claude Code handled the file structure, the scoped CSS patterns, and the Astro component conventions — I just directed and reviewed.

For my infrastructure work, I use it to:

  • Draft and review Terraform modules with full awareness of my existing state structure
  • Write CI/CD pipeline configuration with knowledge of my actual project layout
  • Generate documentation from code rather than maintaining it separately

The Bottom Line

Claude Code isn’t magic. It makes mistakes, it sometimes needs course correction, and it works best when you have a clear sense of what you want. But for engineers who know their domain, it’s an extraordinary force multiplier.

The terminal-native approach is deliberately different from editor-based tools. It fits the workflow of engineers who already live in the command line — infrastructure engineers, backend developers, DevOps practitioners. If that’s you, it’s worth giving a real try.

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

Start with something real. You’ll figure out the workflow quickly.