Claude Code: 24 Power Tips to Master the AI Terminal

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

# Option 1: Start an interactive session
claude

# Option 2: Launch with a prompt
claude "Show me the directory structure of this project"

# Option 3: Non-interactive mode (great for scripts)
claude -p "Generate a .gitignore file"

# ❌ Too vague
> Optimize this function

# ✅ Specific and actionable
> Optimize the parseJSON function in src/utils/parser.js.
> It currently takes 5 seconds to process a 10MB file.
> Target: under 1 second. Consider streaming or chunked parsing.

# ❌ All at once (error-prone)
> Build a complete blog system with users, posts, and comments

# ✅ Step by step (controllable and verifiable)
> Step 1: Design the database schema for users, posts, and comments
# Review the design...
> Step 2: Implement user registration and login APIs based on that schema
# Test it...
> Step 3: Implement CRUD endpoints for posts

# Get an overview
> Analyze this project's directory structure and tech stack

# Understand a specific module
> Read through src/services/payment and explain the payment flow

# Learn the code style
> Look at the code in src/controllers and summarize the coding conventions

> Refactor the authentication module
# Claude starts executing but touches files it shouldn't...

# Press Esc to interrupt (NOT Ctrl+C — that exits the program)

> Stop. Only refactor files in src/auth. Don't touch src/user.

# Mac: Cmd + Ctrl + Shift + 4 to capture to clipboard
# Then press Ctrl+V in Claude Code (not Cmd+V)

> [paste screenshot]
> The login form styling is broken. Inputs should have rounded corners
> and the button color should be #1890ff.

# Reference a single file
> Optimize the performance of @src/utils/helper.ts

# Reference multiple files
> Compare @package.json and @package-lock.json for version mismatches

# Reference a directory
> Analyze the component structure in @src/components/

# Direct execution, bypassing Claude
> ! npm test
> ! git status
> ! docker ps

# Supports Tab auto-completion
> ! npm run b<Tab>  # Auto-completes to npm run build

claude --dangerously-skip-permissions

{
  "permissions": {
    "allow": [
      "Bash(npm:*)",
      "Bash(git:*)",
      "Bash(docker:*)",
      "Read",
      "Edit"
    ]
  }
}

# Continue the most recent conversation
claude -c
# or
claude --continue

# Browse session history
claude -r
# or
claude --resume

# Resume a specific session (supports fuzzy matching)
claude -r "auth refactor"

# Rename the current session
> /rename payment-module-refactor

# Resume it later
$ claude -r "payment"

# Press Ctrl+B to background the current task
> Refactor the entire services directory
# While executing... press Ctrl+B

# The task continues in the background while you work on other things
> Different question: how do I fix this bug?

# Check background task status
> /tasks

# Check status
> What files did I change today?
> Show me the commits from the last week

# Commit changes
> Commit my changes with message "Fix avatar upload failure"

# Branch operations
> Create a new branch feature/payment from main
> Merge feature/payment into develop

# Rollback
> Undo the last commit but keep the code changes
> Revert config.js to the previous version

# Find files
> Find all TypeScript files over 500 lines in src/
> List .vue files modified in the last 24 hours

# Process management
> What's using port 3000?
> Kill all node processes

# Log analysis
> Count HTTP 500 errors in nginx access.log
> Find the 10 most frequent errors in error.log

# Batch operations
> Rename all .jsx files to .tsx in the src directory
> Delete all .DS_Store files in the project

# Analyze test results
$ npm test 2>&1 | claude -p "Analyze why these tests are failing"

# Analyze logs
$ tail -100 error.log | claude -p "What do these errors have in common?"

# Analyze Git history
$ git log --oneline -20 | claude -p "Summarize recent development work"

# Analyze dependencies
$ npm outdated | claude -p "Which dependencies should I upgrade first?"

# Simple problems
> think Why doesn't this regex match?

# Architecture decisions
> think harder Design a push notification system for 1M users,
> considering real-time delivery, reliability, and cost

# Most complex problems (use sparingly — expensive)
> ultrathink Redesign this monolith's microservice decomposition

# Enter plan mode
> /plan

# Or start with plan mode
$ claude --permission-mode plan

# Example: refactoring a complex module
> /plan
> Refactor the order module into separate service, repository, and controller layers

# Claude outputs a detailed plan:
# 1. Create services/order.service.ts
# 2. Create repositories/order.repository.ts
# 3. Modify controllers/order.controller.ts
# 4. Update related test files
# ...

# Approve the plan to start execution

# Add related directories
> /add-dir ../backend-api
> /add-dir ../shared-types

# Now Claude can understand cross-project relationships
> The frontend calls /api/users — show me the backend implementation

> Is the UserDTO type in shared-types the same one used by both frontend and backend?

# Full-stack project
> /add-dir ../server    # Add backend
> /add-dir ../mobile    # Add mobile app

# Microservices
> /add-dir ../user-service
> /add-dir ../order-service
> /add-dir ../gateway

# Then ask cross-service questions
> How do the user service and order service communicate?

./CLAUDE.md              # Project-level, committed to repo, shared with team
./.claude/CLAUDE.md      # Project config
~/.claude/CLAUDE.md      # Global personal preferences

# Use the # prefix to add memories on the fly
> # This project uses pnpm, not npm
> # Commit messages should be in English
> # API responses use { code, data, message } format

> /memory

# Project Standards

## Tech Stack
- Frontend: Vue 3 + TypeScript + Vite
- Backend: Go + Gin + GORM
- Database: PostgreSQL + Redis

## Code Style
- Components use PascalCase, utility functions use camelCase
- Functions should not exceed 50 lines
- Unit tests are required

## Common Commands
- `make dev` — start dev environment
- `make test` — run tests
- `make lint` — lint code

# Create file .claude/commands/review.md
Review the currently staged code:

1. Check for obvious bugs or logic errors
2. Verify compliance with project coding standards
3. Identify security concerns
4. Provide specific improvement suggestions

> /project:review

# Create file ~/.claude/commands/standup.md
Prepare my daily standup update:

1. Check git log for yesterday's commits and summarize completed work
2. Check the status of issues assigned to me
3. Identify potential blockers or coordination needs

Output format:
## Yesterday
## Today
## Blockers

> /user:standup

# .claude/commands/fix-issue.md
Fix GitHub Issue #$ARGUMENTS

Steps:
1. Run gh issue view $ARGUMENTS to get issue details
2. Analyze the root cause
3. Write the fix
4. Write test cases
5. Run tests to verify

> /project:fix-issue 42

# Check current model
> /model

# Switch models
> /model opus     # For complex problems
> /model sonnet   # For everyday tasks
> /model haiku    # For quick tasks

# Keyboard shortcut
# Mac: Option+P
# Win/Linux: Alt+P

# Add GitHub MCP server
$ claude mcp add github -- npx -y @anthropic/github-mcp

# Add database MCP server
$ claude mcp add postgres -- npx -y @anthropic/postgres-mcp

# List installed MCP servers
$ claude mcp list

# Manage MCP in a session
> /mcp

# Token usage for current session
> /cost

# Context window utilization (visual)
> /context
# Example output: [████████████░░░░░░░░] 58%

# Overall statistics
> /stats

# Subscription quota
> /usage

# Smart compression, preserving key topics
> /compact Keep the database design discussion

# Full reset (when starting a new topic)
> /clear

# Set maximum spend (USD)
$ claude -p --max-budget-usd 5.00 "Refactor all project tests"

# Limit conversation turns
$ claude -p --max-turns 10 "Fix this bug"

# Combine both
$ claude -p --max-budget-usd 2.00 --max-turns 5 "Optimize performance"

# Export to file
> /export session-2024-01-15.md

# Export to clipboard
> /export

# Exported conversations can be:
# - Saved as documentation
# - Shared with team members
# - Used as context for future sessions