How to Use Claude Code, Anthropic's Agentic Coding Tool

Subagents

Subagents are helper agents with their own context window, system prompt and tool list. Claude delegates work to them, such as searching a large codebase, so the main conversation stays clean. The built-in ones are Explore (fast, read-only search), Plan (research for plan mode) and general-purpose. You can define your own:

.claude/agents/code-reviewer.md

---
name: code-reviewer
description: Reviews code for quality, security and best practices
tools: Read, Glob, Grep
model: sonnet
---

You are a code reviewer. Analyze the changed code and give specific,
actionable feedback on correctness, security and readability.

Hooks

Hooks are shell commands that run at fixed points: before a tool runs, after it runs, when Claude stops, when a session starts, and so on. A line in CLAUDE.md asking Claude to format code is a request. A hook makes it happen every time. This example from the official hooks guide formats every file Claude edits:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  }
}

A PreToolUse hook that exits with code 2 blocks the action, which is how you protect files such as .env.

MCP servers

The Model Context Protocol connects Claude Code to external tools such as GitHub, Jira, databases, browsers and documentation servers:

claude mcp add --transport http github https://api.githubcopilot.com/mcp/
claude mcp add playwright npx @playwright/mcp@latest
claude mcp list

Add --scope project to save a server to .mcp.json so the whole team gets it. If a server shows as failed, run claude mcp list, then start the server command manually to see its error. If you're building your own server, read what a .NET MCP server should never expose to AI first.

Controlling what it can do

Press Shift+Tab to cycle permission modes during a session:

If I had to pick one habit, it would be plan mode for anything non-trivial. Claude researches first and shows you a plan, and you correct a wrong approach before any code changes. Reviewing a plan is far cheaper than reviewing a wrong diff.

Permission rules in .claude/settings.json sit on top of the mode, and deny rules apply in every mode. Keep the allow list narrow: specific commands like Bash(dotnet test *) rather than broad wildcards, with secrets files denied outright. Narrow allow rules for your build and test commands are also the cure for constant permission prompts.

{
  "permissions": {
    "allow": ["Bash(dotnet test *)", "Bash(dotnet build *)", "Read"],
    "ask": ["Bash(git push *)"],
    "deny": ["Read(./.env)", "Bash(curl *)"]
  }
}

Workflows that work well

Getting oriented in an unfamiliar codebase is one of the best first uses, because nothing gets changed:

> Explain how authentication works in this solution. Which projects
  are involved, where are tokens validated, and what would break if
  I upgraded the JWT library?

Bug fixing works best when you hand over the evidence and say how to verify the fix:

> This test fails with "InvalidOperationException: Sequence contains
  no elements" in OrderService.GetLatest. Find the root cause, fix it,
  add a regression test, and run the test project.

That last sentence matters. Claude does its best work when it can run something and check the result, so always name the test command or the expected output. Be specific about scope, too: "fix the null check in InvoiceMapper.cs" beats "fix the bugs".

For a feature, use plan mode end to end:

1. Press Shift+Tab until the mode shows Plan, or type /plan add CSV export to the reports page.
2. Read the plan and correct the approach, file locations or libraries.
3. Approve it, and let Claude implement and run the tests.
4. Review the diff, then ask it to commit with a descriptive message.

Commit often, so each step is easy to review and revert (/rewind can also restore checkpoints), and run /clear when you switch tasks. Stale context costs tokens and confuses the model.

Finally, claude -p makes it scriptable. Combined with the Don't ask mode, so that only pre-approved tools run, it fits into CI, and there are GitHub Actions and GitLab CI/CD integrations for PR review and issue triage.

# Non-interactive mode
git diff main --name-only | claude -p "review these changed files for security issues"

# Pipe logs in
tail -200 app.log | claude -p "summarize the errors and likely causes"

For a .NET-specific walkthrough, see Claude Code for .NET developers: a practical introduction.

Which plan you need

Claude Code shares one usage pool with Claude chat. Limits reset on a rolling five-hour window, and paid plans also have weekly limits. These are the prices on Anthropic's pricing page as of October 2026:

Pro suits a few focused sessions a day. Developers who run Claude Code most of the day usually hit Pro limits and move to Max. Before upgrading, though, check /usage and /context: clearing between tasks, using a smaller model for simple work and trimming CLAUDE.md all stretch a plan further. Claude Code can also run through Amazon Bedrock, Google Cloud or Microsoft Foundry if your company already buys Claude there.

One question to settle before you point it at sensitive code is data usage. It depends on your account type and settings: commercial accounts (Team, Enterprise, API) are covered by Anthropic's commercial terms, and consumer plans have their own privacy settings. Check your plan's policy.

Claude Code, Cursor or GitHub Copilot?

All three now offer agents, so the real differences are workflow, model choice and billing. Prices are as listed on each vendor's site in October 2026.

Many developers combine them: Copilot or Cursor for inline completions while typing, Claude Code for multi-file tasks, refactors and automation. Claude Code's VS Code extension even runs inside Cursor. My advice is to pick by the work you do most. If your day is mostly writing code line by line, an editor with strong tab completion will serve you better. If it's mostly multi-step changes, refactors and scripted chores, Claude Code is the stronger fit, and the right first step is to run /init in a real repository and hand it a small, testable task.