Setup and Configuration: Tips 1-15

Getting started with Claude Code requires thoughtful setup to maximize its capabilities. These 15 tips will help you configure Claude Code for optimal performance, whether you’re working solo or as part of a team.

Installation and IDE Integration

Tip 1: Install the VS Code Extension

The Claude Code extension works with VS Code, Cursor, and Windsurf. While it’s essentially just a launcher, it provides critical benefits:

• Quick launch from your IDE with keyboard shortcuts
• Multiple instances in parallel panes for different parts of your codebase
• Seamless file references between your editor and Claude Code
• Integrated diff viewing for reviewing changes

VS Code

# Install from VS Code marketplace
code --install-extension anthropic.claude-code

Cursor

# Works automatically with Cursor
# Extension available in Cursor marketplace

JetBrains

# Search for "Claude Code" in:
# Settings → Plugins → Marketplace

Tip

Power users report evolving from using Claude Code as a sidebar tool to making it their primary interface, only checking the actual code when reviewing changes.

Tip 2: Use the Optimal Installation Method

Install Claude Code globally using npm for the best experience across all your projects:

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

Alternative installation methods:

Homebrew (macOS)

brew install claude-code

Direct Download

# Download from GitHub releases
curl -L https://github.com/anthropics/claude-code/releases/latest/download/claude-code-linux-x64 -o claude-code
chmod +x claude-code
sudo mv claude-code /usr/local/bin/

Docker

docker run -it anthropic/claude-code

Tip 3: Skip Permission Prompts for Efficiency

One of the most impactful configuration changes is bypassing constant permission requests:

claude --dangerously-skip-permissions

This eliminates interruptions for:

• File editing permissions
• Basic command execution
• Git operations
• Package manager commands

Security Consideration

This is similar to Cursor’s “yolo mode”. While it could theoretically allow destructive commands, experienced users report no issues in production use. Use your judgment based on your security requirements.

Tip 4: Install GitHub CLI for Enhanced Integration

The GitHub CLI (gh) enables powerful Claude Code integrations:

# macOS
brew install gh

# Linux/WSL
curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo gpg --dearmor -o /usr/share/keyrings/githubcli-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null
sudo apt update && sudo apt install gh

# Windows
winget install GitHub.cli

After installation, authenticate:

gh auth login

This enables:

• Automated PR creation and review
• Issue management from Claude Code
• Repository operations
• GitHub Actions integration

Tip 5: Configure IDE Integration Properly

Set up proper IDE integration for seamless workflow:

1. Configure keyboard shortcuts

   // VS Code settings.json
   {
     "keybindings": [
       {
         "key": "cmd+shift+c",
         "command": "claude-code.open",
         "when": "editorTextFocus"
       }
     ]
   }

2. Set up file associations

   {
     "files.associations": {
       "CLAUDE.md": "markdown",
       "*.claude": "markdown"
     }
   }

3. Configure terminal integration

   # Add to ~/.zshrc or ~/.bashrc
   alias cc="claude"
   alias ccc="claude --dangerously-skip-permissions"

Terminal and Environment Setup

Tip 6: Set Up Terminal for Optimal Experience

Run the terminal setup command to configure proper key bindings:

claude
# Then run:
/terminal-setup

This enables:

• Shift+Enter for new lines in prompts
• Tab completion for commands
• History navigation with arrow keys
• Proper escape sequences for stopping operations

Note

If you’re experiencing issues with special keys, manually configure your terminal:

# For iTerm2/Terminal.app
stty sane
export TERM=xterm-256color

Tip 7: Enable Architect Mode for Large Projects

For large-scale refactoring and complex architectural work, Claude Code automatically optimizes its approach based on the complexity of your request. Simply describe your architectural needs and Claude will adapt its strategy accordingly.

• Advanced pattern recognition
• Improved performance on files with 10,000+ lines

When to Use Architect Mode

• Refactoring entire modules or subsystems
• Analyzing complex dependency graphs
• Working with legacy codebases
• Implementing architectural patterns across multiple files

Tip 8: Configure Model Preferences

Understand the model selection strategy for optimal results:

.claude/settings.json

{
  "model": "auto", // Default: uses Opus until 50% quota
  "modelPreferences": {
    "complex": "claude-opus-4",
    "routine": "claude-sonnet-4",
    "simple": "claude-haiku"
  }
}

Model selection guidelines:

• Opus 4: Complex architecture, system design, difficult debugging
• Sonnet 4: Routine development, standard features, refactoring
• Haiku: Simple tasks, formatting, basic code generation

Tip 9: Set Up Multiple Working Directories

For projects spanning multiple repositories:

# Start Claude Code with multiple directories
claude --add-dir ../backend --add-dir ../frontend --add-dir ../shared

# Or add during session
/add-dir ../backend
/add-dir ../frontend

Permanent configuration:

claude config add addDirs "../backend"
claude config add addDirs "../frontend"
claude config add addDirs "../shared"

Project Configuration

Tip 10: Optimize Your Shell Environment

Ensure Claude Code inherits your development environment:

~/.claude/shell-init.sh

export PATH="$HOME/.local/bin:$PATH"
export NODE_OPTIONS="--max-old-space-size=8192"
source ~/.nvm/nvm.sh

# Custom aliases Claude should know about
alias build="npm run build:all"
alias test="npm run test:coverage"
alias deploy="./scripts/deploy.sh"

Document custom tools in CLAUDE.md:

# Custom Tools and Commands

- `build`: Runs full build pipeline with type checking
- `test`: Runs tests with coverage reporting
- `deploy`: Deploys to staging (requires VPN connection)

Tip 11: Configure Proper File Permissions

Set up your project with appropriate permissions:

# Fix common permission issues
find . -type f -name "*.sh" -exec chmod +x {} \;
chmod -R u+rw .claude/

# Create .claude directory with proper permissions
mkdir -p .claude/{commands,hooks,settings}
chmod 755 .claude

Tip 12: Install MCP Servers for Extended Functionality

Model Context Protocol (MCP) servers extend Claude Code’s capabilities:

// .mcp.json (project-level)
{
  "servers": {
    "git": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-git"]
    },
    "github": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "postgres": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DATABASE_URL}"
      }
    }
  }
}

Essential MCP servers for development:

• git-mcp-server: Enhanced git operations
• github-mcp-server: PR and issue management
• postgres-mcp-server: Direct database access
• filesystem-mcp-server: Advanced file operations
• puppeteer-mcp-server: Browser automation

Tip 13: Use Debug Mode for MCP Troubleshooting

When MCP servers aren’t working correctly:

claude --mcp-debug

This provides:

• Detailed connection logs
• Error messages from MCP servers
• Configuration validation
• Performance metrics

Common troubleshooting steps:

1. Verify MCP server installation

   npm list -g @modelcontextprotocol/server-*

2. Check environment variables

   echo $GITHUB_TOKEN
   echo $DATABASE_URL

3. Test MCP server directly

   npx @modelcontextprotocol/server-git --test

Tip 14: Set Up Project-Specific Configurations

Create a comprehensive project configuration:

.claude/settings.json

{
  "allowedTools": [
    "Edit",
    "View",
    "Bash(git:*)",
    "Bash(npm:*)",
    "Bash(yarn:*)",
    "Bash(pnpm:*)",
    "mcp__git__*",
    "mcp__github__*"
  ],
  "hooks": [
    {
      "matcher": "Edit",
      "hooks": [
        {
          "type": "command",
          "command": "prettier --write \"$CLAUDE_FILE_PATHS\""
        }
      ]
    }
  ],
  "security": {
    "allowNetworkAccess": true,
    "allowedHosts": ["api.github.com", "api.openai.com"],
    "sensitiveFiles": ["*.env", "*.key", "secrets/*"]
  }
}

Share with your team by committing to version control:

git add .claude/settings.json
git commit -m "Add Claude Code project configuration"

Tip 15: Configure Allowed Tools Strategically

Balance security with productivity by customizing tool permissions:

Development

{
  "allowedTools": [
    "Edit",
    "View",
    "Create",
    "Delete",
    "Bash(*)",
    "mcp__*"
  ]
}

Staging

{
  "allowedTools": [
    "Edit",
    "View",
    "Bash(git:*)",
    "Bash(npm:test)",
    "mcp__github__*"
  ]
}

Production

{
  "allowedTools": [
    "View",
    "Bash(git:log)",
    "Bash(git:status)"
  ]
}

Use the /permissions command to modify during a session:

/permissions
# Select tools to allow/deny interactively

Next Steps

With Claude Code properly configured, you’re ready to optimize your project context. Continue to CLAUDE.md Optimization to learn how to create effective persistent memory for your projects.