I've been using Claude Code nearly every day for the past six months.

It started as curiosity — another AI coding tool to evaluate. But somewhere around the second week, it stopped being something I was testing and became something I relied on. Not for everything, but for a specific set of tasks where it genuinely changes how I work.

This isn't a review or a promotional piece. It's what daily use actually looks like: what works well, where the rough edges are, and the patterns I've settled into after months of real projects. If you're considering adding an AI coding tool to your workflow, or already using one and wondering whether the grass is greener, this is the honest version.

What Is Claude Code?

Claude Code is a terminal-native, agentic AI coding tool built by Anthropic. It's not an IDE extension. It's not a chat sidebar. It runs directly in your terminal — or inside VS Code, JetBrains, or as a standalone desktop app.

What makes it different from most AI coding tools is scope. It reads your entire codebase. It can edit multiple files in a single operation. It runs shell commands, manages git workflows, and interacts with external services through a protocol called MCP.

The "agentic" part matters. You give it a task, and it figures out the steps: which files to read, what to change, what commands to run. You're not copy-pasting snippets back and forth. You describe what you want, and it operates across your project to get there.

It's powered by the same Claude models you'd use through the API, but with full filesystem access and the ability to act on your codebase directly.

What Changed in My Daily Workflow?

The honest answer is: more than I expected.

Codebase Exploration

When I pick up an unfamiliar project, I used to spend the first hour or two reading through directory structures, tracing imports, and building a mental model. Now I drop into Plan Mode, ask Claude to explain the architecture, and I have a working understanding in minutes. It reads the files, maps the relationships, and presents a structured summary. I still read the code myself — but I start with context instead of starting from zero.

Multi-File Refactoring

This is where the tool genuinely shines. Renaming a type across fifteen files. Updating an API response shape and propagating the change through components, tests, and utilities. These are tasks that are tedious and error-prone by hand. With Claude Code, it's a single prompt. It finds every reference, makes the changes, and I review the diff.

Debugging

My debugging workflow has changed significantly. I paste an error message, Claude reads the relevant files, identifies the likely cause, and proposes a fix. If the fix is wrong, I rewind using checkpoints and try a different approach. The feedback loop is much tighter than manually stepping through stack traces.

Commit Workflow

Small but meaningful: I use slash commands for generating commit messages and creating pull requests. It reads the staged changes, drafts a message that actually describes what happened, and I edit if needed. It saves a few minutes per commit, which compounds across a day of work.

The Hooks System

Hooks are lifecycle events that let you run custom logic at specific points during Claude Code's execution. They're defined in your project's .claude/settings.json and they run entirely locally — nothing is sent to Anthropic.

The available events are:

PreToolUse — runs before a tool executes (file edit, command run, etc.)
PostToolUse — runs after a tool completes
Stop — runs when Claude finishes its turn
PostCompact — runs after context compression

The most practical use I've found is guarding protected files. Here's a hook configuration that prevents Claude from modifying critical configuration:

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Edit|Write",
        "command": "node .claude/hooks/guard-protected-files.js \"$CLAUDE_FILE_PATH\"",
        "blocking": true
      }
    ]
  }
}

The guard script checks whether the target file is in a protected list (environment files, CI configuration, production secrets) and exits with a non-zero code to block the operation.

This is genuinely useful. It means I can give Claude broad autonomy over the codebase while maintaining hard boundaries around files that should only be changed manually. Hooks act as guardrails, not just automation triggers.

MCP Servers

MCP — Model Context Protocol — is how you connect external tools and services to Claude Code as native capabilities. Instead of describing an API to Claude and hoping it generates the right curl command, you expose a structured tool that it can call directly.

Here's a simplified version of what my MCP configuration looks like:

{
  "mcpServers": {
    "supabase": {
      "command": "npx",
      "args": ["-y", "@supabase/mcp-server-supabase@latest", "--project-ref", "your-project-ref"],
      "env": {
        "SUPABASE_ACCESS_TOKEN": "your-token"
      }
    },
    "content-hosting": {
      "type": "url",
      "url": "https://content.example.com/.well-known/mcp/sse",
      "headers": {
        "Authorization": "Bearer your-api-key"
      }
    }
  }
}

With this configuration, Claude can query my database, run migrations, publish content to my hosting service, and manage infrastructure — all through natural language prompts that resolve to structured tool calls.

This is the feature that transformed my perception of the tool. It turns Claude from a text generator that knows about code into a system operator that can interact with your actual infrastructure. The MCP ecosystem is growing quickly, and the ability to write your own MCP servers means you can connect essentially anything.

CLAUDE.md and Slash Commands

Every project I work on now has a CLAUDE.md file at the root. This file is read automatically at the start of every session, giving Claude persistent context about the project.

Here's a condensed version of what mine typically contains:

# CLAUDE.md

## Commands
- `npm run dev` — start development server
- `npm run build` — production build
- `npm test` — run Jest tests

## Architecture
- Next.js App Router with TypeScript
- Components in `src/app/components/`
- Path alias: `@/*` → `./src/*`

## Rules
- Do not modify environment files
- Use British English in all content
- Prefer editing existing files over creating new ones

This removes the need to repeat project context in every conversation. Claude knows the build commands, the directory structure, and the project conventions from the first prompt.

For repeatable workflows, you can create custom slash commands in .claude/commands/. Each command is a markdown file with a prompt template. I have commands for generating test files, creating blog post scaffolds, and running pre-deployment checks. It's a small investment that pays off quickly.

Plan Mode and the Checkpoint System

Plan Mode is activated with /plan or Shift+Tab. It puts Claude into a read-only exploration state where it can read files, search the codebase, and design an approach — but it cannot make any changes.

I use this before every significant refactor. The pattern is:

Enter Plan Mode
Describe the goal
Let Claude explore and propose a plan
Review the plan
Exit Plan Mode and let it execute

This prevents the "act first, think later" problem that agentic tools can fall into.

Checkpoints complement this nicely. Every file edit creates an automatic checkpoint. If something goes wrong, pressing Escape twice lets you rewind to any previous state. It's version control at the operation level, not just the commit level.

The combination creates a workflow I think of as "explore, act, rewind" — and it makes me significantly more willing to attempt ambitious changes, because the cost of failure is nearly zero.

Comparison with Other Tools

Having used all three major options extensively, here's how they compare in practice:

Feature	Claude Code	Cursor	GitHub Copilot
Environment	Terminal / IDE / Desktop	Custom IDE (VS Code fork)	IDE extension
Multi-file editing	Native, agentic	Composer mode	Limited
MCP support	Full ecosystem	Not available	Not available
Hooks system	PreToolUse, PostToolUse, Stop	Not available	Not available
Inline completion	Not the focus	Excellent	Excellent
Autonomy level	High (runs commands, manages git)	Medium	Low
Context window	Full codebase	File-level + references	File-level

The honest take: these tools serve different needs.

Cursor is a brilliant daily IDE driver. Its inline completions are fast, its Composer mode handles multi-file tasks well, and it feels native to the editing experience. If you want AI embedded seamlessly in your editor, Cursor is excellent.

GitHub Copilot excels at inline completion — the tab-to-accept flow for single lines and small blocks. It's the least intrusive option and works well as a passive assistant.

Claude Code shines when the task is complex, multi-step, and spans your entire project. Refactoring across dozens of files, debugging with full codebase context, interacting with external services through MCP — these are where it genuinely outperforms.

Claude Code doesn't replace your IDE. It works alongside it. I use it in VS Code's terminal panel while editing in the same window.

Practical Tips

After six months of daily use, these are the patterns that made the biggest difference:

Create your CLAUDE.md immediately. Even a minimal one with build commands and directory structure saves repetitive context-setting across every session.
Use Plan Mode before large refactors. Let Claude explore and propose before it starts changing files. The five minutes spent planning prevents thirty minutes of fixing unintended changes.
Use hooks as guardrails, not just automation. Protecting sensitive files and enforcing conventions through hooks is more reliable than hoping you'll catch mistakes during review.
Trust checkpoints — be aggressive with prompts. The ability to rewind means you can try ambitious approaches without risk. If it doesn't work, you're two keypresses away from the previous state.
Connect your own tools via MCP. The built-in capabilities are useful, but MCP is where the tool becomes genuinely powerful. Database access, deployment triggers, content management — anything with an API can become a native Claude capability.

Closing Thoughts

The real value of Claude Code isn't writing code faster. Faster output is a side effect, not the goal.

The actual shift is cognitive. When exploration, refactoring, and multi-file changes become low-cost operations, you spend less mental energy on mechanical tasks and more on design decisions, architecture, and the problems that actually require human judgement.

After six months, I don't think about Claude Code as an AI coding tool. I think about it as a workflow layer — something that sits between intention and execution, handling the translation so I can focus on the thinking.

The best developer tool isn't the one that writes more code — it's the one that gives you time to think better.