Getting Started with Claude Code

Claude Code is an agentic coding tool that reads your codebase, edits files, and runs commands. Unlike simple code completion, Claude Code operates in an agentic loop — it gathers context, plans, acts, and verifies its own work.

Why Our CloseFuture Team Uses Claude Code?

What You Can Do

• Ask questions about your codebase — "How does our auth middleware work?"
• Edit code across multiple files — "Add input validation to the signup form"
• Run and fix tests — "Write tests for the cart service and fix any failures"
• Search and navigate — "Find all API endpoints that don't have auth checks"
• Git operations — "Commit these changes, create a PR with a clear description"
• Automate CI workflows — Use in GitHub Actions for automated code reviews
• Connect external tools — Jira, Slack, Supabase databases via MCP protocol

Platforms at a Glance

System Requirements

• OS: macOS 13+, Windows 10 1809+, Ubuntu 20.04+, Debian 10+
• Hardware: 4 GB+ RAM
• Network: Internet connection required
• Shell: bash, zsh, or PowerShell recommended

Step-by-Step Setup

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

# PowerShell
irm https://claude.ai/install.ps1 | iex

# Or WinGet
winget install Anthropic.ClaudeCode

brew install --cask claude-code

# Requires Node.js 18+
npm install -g @anthropic-ai/claude-code

cd your-project
claude

# Ask about your project
> summarize this codebase and explain the architecture

# Make changes
> add input validation to the signup form in src/components/Signup.tsx

# Run tests
> run the test suite and fix any failures

Claude Code operates through an intelligent three-phase agentic loop. Unlike traditional code assistants, Claude gathers context, acts, and verifies its own work — iterating until complete.

Available Tools

Permission System

Explore → Plan → Code → Commit

> read src/auth/ and explain how session handling works

> create a plan to add OAuth2 support using the existing auth patterns

> implement the plan. write tests and run them after each change

> commit the changes with a descriptive message and create a PR

Fix Bugs

> the login form throws a TypeError when email is empty - find and fix it
> users report a blank screen after failed login. check token refresh in src/auth/
> fix the race condition in the checkout flow

Write and Fix Tests

> write comprehensive tests for the CartService class, aim for >90% coverage
> find untested functions in the notification module and add edge case tests
> run the test suite and fix all failures

Refactor Code

> refactor fetchUserData to use async/await instead of .then() chains
> migrate our Express routes from JavaScript to TypeScript with proper type definitions
> find deprecated API usage across the project and suggest modern alternatives

Git & PRs

> commit my changes with a descriptive message
> create a new branch called feature/oauth2
> create a PR with a summary of what changed and why
> help me resolve the merge conflicts in src/api/users.ts

Pipe & Script (Headless)

# One-shot query
claude -p "summarize this project"

# Process piped content
git diff main...feature | claude -p "review these changes for bugs and security issues"

# Structured output
claude -p "list all API endpoints" --output-format json > endpoints.json

Write Effective Prompts

Context Management

Pitfalls to Avoid

CLAUDE.md is a markdown file Claude reads at the start of every session. Run /init to create one.

Where to Put It

What to Include

# CLAUDE.md

## Tech Stack
- TypeScript strict mode, React 18, Next.js 14
- Tailwind CSS for styling
- Vitest for testing (not Jest)
- pnpm (not npm or yarn)

## Commands
- Build: `pnpm build`
- Test: `pnpm test`
- Lint: `pnpm lint`

## Architecture
- API routes in src/api/
- Components in src/components/
- All DB access through Supabase Client

## Conventions
- Branch naming: feature/*, bugfix/*, hotfix/*
- Commit messages: conventional commits (feat:, fix:, refactor:)

Starting a Session

claude                     # Interactive session
claude "task description"  # Start with a task
claude -p "query"          # One-shot (print mode)
claude -c                  # Continue most recent conversation
claude -r                  # Resume a specific session
claude -r auth-refactor    # Resume by session name

Interactive Commands

Keyboard Shortcuts

Search for "Claude Code" in the Extensions marketplace (Ctrl+Shift+X) and install. Requires VS Code 1.98.0+.

Key Shortcuts

Features

• Inline diffs — review every code change before accepting
• @-mentions — @filename for files, @folder/ for directories
• Checkpoints — hover over messages to rewind code and conversation
• Plan Mode — analyze safely before committing to changes
• Drag & drop — drag files into chat as context

Install the Claude Code plugin from the JetBrains Marketplace. Supports IntelliJ IDEA, PyCharm, WebStorm, GoLand, PHPStorm, and others.

• Interactive diffs for reviewing code changes
• Context sharing with the IDE
• Same command set as the CLI (/compact, /clear, etc.)
• Permission mode cycling with Shift+Tab

Download from claude.ai/download for macOS (Intel/Apple Silicon) or Windows (x64, ARM64).

• Side-by-side parallel sessions with separate git worktrees
• Visual diffs for reviewing changes
• All the same agentic capabilities as the terminal
• Use /desktop in CLI to hand off a session to the desktop app

Go to claude.ai/code and sign in. No local setup needed.

• Full agentic coding in a sandboxed cloud environment
• Connect to GitHub repos directly
• Long-running tasks continue even if you close the browser
• Works on mobile — check progress from anywhere
• Use /teleport in CLI to pull a cloud session to your terminal

MCP lets Claude Code communicate with external tools — databases, APIs, project management tools, and more.

Adding MCP Servers

# Add a server
claude mcp add --transport http github https://api.githubcopilot.com/mcp/

# Add a stdio server
claude mcp add my-server -- node /path/to/server.js

# List configured servers
claude mcp list

# Remove a server
claude mcp remove my-server

Popular Integrations

Hooks run deterministic commands at specific points in Claude's workflow — like linting after edits or blocking changes to certain directories.

{
  "hooks": {
    "afterEdit": [
      { "command": "eslint --fix $FILE", "description": "Auto-fix lint issues" }
    ],
    "beforeCommit": [
      { "command": "pnpm typecheck", "description": "Type-check before committing" }
    ]
  }
}

Available Hook Points

• afterEdit — runs after any file is modified
• beforeCommit — runs before git commits
• afterCommit — runs after git commits
• onSessionStart — runs when a session begins

Skills are custom slash commands you create for repeatable workflows. They live in .claude/skills/.

---
name: review-pr
description: Review a PR with our team's checklist
---

# PR Review Workflow
1. Read all changed files
2. Check for security issues (SQL injection, XSS, auth bypass)
3. Check for performance issues (N+1 queries, missing indexes)
4. Verify tests exist for new functionality
5. Check adherence to our code style (see CLAUDE.md)
6. Write a structured review comment

Then use it with /review-pr. Run /skills to see all available skills.

Subagents are specialized assistants that run in their own context window with specific tools and permissions.

• Preserve context — keep exploration out of your main conversation
• Enforce constraints — limit which tools a subagent can use
• Specialize — dedicated agents for testing, docs, security review
• Control costs — route tasks to faster, cheaper models like Haiku

Creating a Subagent

---
name: security-reviewer
description: Review code for security vulnerabilities
model: sonnet
tools:
  - Read
  - Grep
  - Glob
---

You are a security-focused code reviewer. Analyze code for:
- SQL injection, XSS, CSRF vulnerabilities
- Authentication and authorization issues
- Hardcoded secrets or credentials

While subagents work within a single session, agent teams coordinate across separate sessions. A lead agent distributes work and merges results.

• Parallel processing — multiple agents work on different parts simultaneously
• Separate git worktrees — each agent works in isolation
• Lead agent coordinates — distributes tasks, reviews output, merges
• Useful for large refactors, multi-service changes, comprehensive testing

Configure via /config in a session, or edit .claude/settings.json directly.

Configuration Scopes

{
  "permissions": {
    "allow": ["Bash(npm test)", "Bash(git status)", "Bash(pnpm lint)"]
  },
  "model": "sonnet",
  "theme": "dark"
}

{
  "permissions": {
    "allow": [
      "Bash(npm test)",
      "Bash(npm run lint)",
      "Bash(git status)",
      "Bash(git diff *)",
      "Read", "Glob", "Grep"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force *)"
    ]
  }
}

Permission Modes

• Normal: Ask for each edit and command
• Auto-Accept Edits: Edit files freely, ask for commands
• Plan Mode: Read-only. Creates a plan for approval before any changes

• Code context is sent to Anthropic's API for processing
• Anthropic does not train on your code by default
• Team and Enterprise plans have additional data privacy guarantees
• Claude respects .gitignore — ignored files are never sent
• Permission system prevents unauthorized destructive actions
• All API communication is encrypted over HTTPS

# Start with a specific model
claude --model opus

# Switch mid-session
/model sonnet

# Toggle extended thinking (Opus)
# Alt+T in VS Code

Extended Thinking

• Enabled by default for Opus
• Toggle with Alt+T (VS Code) or Option+T (macOS)
• Disable with export MAX_THINKING_TOKENS=0

Flags

Claude automatically creates checkpoints before making changes. You can rewind to any checkpoint to restore both code and conversation state.

• Terminal: Press Esc twice, or use /rewind
• VS Code: Hover over a message and click the rewind icon
• Rewind restores: code changes, conversation state, and file system
• You can fork from a checkpoint to try a different approach

Use Claude Code in your GitHub Actions workflows for automated code reviews, PR generation, and more.

name: Claude Code Review
on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Review this PR for:
            - Bugs and logic errors
            - Security vulnerabilities
            - Performance issues
            Provide specific, actionable feedback.

This integration installs 2 specialized agents, 8 database commands, and an MCP server that turn Claude Code into a full-featured Supabase development environment.

What's Included

Installation

npx claude-code-templates@latest \
  --command supabase-schema-sync,supabase-migration-assistant,supabase-performance-optimizer,supabase-security-audit,supabase-backup-manager,supabase-type-generator,supabase-data-explorer,supabase-realtime-monitor \
  --agent supabase-schema-architect,supabase-realtime-optimizer \
  --mcp supabase

# Install a specific agent
npx claude-code-templates@latest --agent supabase-schema-architect

# Install a specific command
npx claude-code-templates@latest --command supabase-schema-sync

# Install the MCP server only
npx claude-code-templates@latest --mcp supabase

MCP Server Configuration

{
  "mcpServers": {
    "supabase": {
      "url": "https://mcp.supabase.com/mcp"
    }
  }
}

# Add via CLI
claude mcp add --transport http supabase https://mcp.supabase.com/mcp

# Authenticate (opens browser login)
# Type /mcp in Claude Code and follow the login flow

Official Documentation

Community