34 Claude Code Usage Tips

# Claude Code can execute all standard CLI operations
claude --help
claude --version
claude --list-sessions

# Directly pass prompts to execute tasks
claude -P "Analyze package.json and list all dependencies"

# Non-interactive mode, output results directly
claude -P "Generate a React component" --no-interactive

# Use with other tools
git diff | claude -P "Explain these code changes"
npm test 2>&1 | claude -P "Analyze test failure reasons"

# Pass data via pipe
cat error.log | claude -P "Analyze error log and provide solutions"
curl https://api.example.com | claude -P "Parse this API response"

# Terminal 1
claude --session frontend-work

# Terminal 2
claude --session backend-api

# Terminal 3
claude --session testing

Please run tests in a new Claude instance and report the results to me.

[Paste design image]
Please generate corresponding React components based on this design, including:
- Responsive layout
- Mobile adaptation
- Using Tailwind CSS

// Automated screenshot script example
const puppeteer = require('puppeteer')

async function captureScreenshots() {
  const browser = await puppeteer.launch()
  const page = await browser.newPage()

  // Capture screenshots of different states
  await page.goto('https://localhost:3000')
  await page.screenshot({ path: 'homepage.png' })

  await page.click('.login-button')
  await page.screenshot({ path: 'login-page.png' })

  await browser.close()
}

Please analyze all screenshots in the screenshots/ directory and identify UI inconsistencies.

// MCP configuration example
{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["@modelcontextprotocol/server-postgres"]
    }
  }
}

After connecting to the database, please:
1. Analyze existing table structure
2. Generate TypeScript type definitions
3. Create CRUD API interfaces

Please get the latest Workers API documentation from Cloudflare MCP and create a sample project.

https://docs.example.com/api/v2

Please create a corresponding TypeScript SDK based on the above documentation.

https://en.wikipedia.org/wiki/Chess_rules

Based on the above rules, implement the core logic of a chess game.

# CLAUDE.md Example Structure

## Project Overview

Brief description of project purpose and tech stack

## Development Standards

- Code style guide
- Naming conventions
- File organization structure

## Common Commands

List frequently used project commands

## Important Notes

Project-specific notes and limitations

# Run in project root directory
> /init

# Claude Code will analyze project and generate configuration file

## Project Rules

- All API responses must include status and data fields
- Use camelCase for variables, PascalCase for components
- Forbidden to use any type, must define explicit TypeScript types

## Code Templates

### React Component Template

\```tsx
import React from 'react';

interface Props {
// props definition
}

export const ComponentName: React.FC<Props> = ({ }) => {
return <div></div>;
};
\```

## Architecture Decision Records

### ADR-001: Using Redux Toolkit

- **Date**: 2024-01-15
- **Decision**: Adopt Redux Toolkit for state management
- **Reason**: Simplify Redux usage, reduce boilerplate code

## Key Dependencies

| Package | Version | Purpose              | Notes                     |
| ------- | ------- | -------------------- | ------------------------- |
| react   | ^18.0.0 | UI framework         | Using concurrent features |
| next    | ^14.0.0 | Full-stack framework | App Router                |

## Testing Strategy

- Unit test coverage > 80%
- All API endpoints must have integration tests
- Using Jest + React Testing Library
- E2E testing with Playwright

// .claude/commands/test-all.js
module.exports = {
  name: 'test-all',
  description: 'Run all tests and generate coverage report',
  execute: async () => {
    await runCommand('npm test -- --coverage')
    await runCommand('npm run e2e')
  }
}

// .claude/commands/aliases.js
module.exports = {
  c: 'commit',
  p: 'push',
  ta: 'test-all',
  dev: 'npm run dev'
}

// .claude/commands/deploy.js
module.exports = {
  name: 'deploy',
  description: 'Complete deployment process',
  execute: async () => {
    await runCommand('npm test')
    await runCommand('npm run build')
    await runCommand('npm run deploy:prod')
  }
}

// .claude/commands/create-component.js
module.exports = {
  name: 'create-component',
  description: 'Create new component',
  parameters: ['name', 'type'],
  execute: async (name, type = 'functional') => {
    // Generate component based on parameters
  }
}

// .claude/commands/smart-test.js
module.exports = {
  name: 'smart-test',
  execute: async () => {
    const files = await getChangedFiles()
    if (files.some((f) => f.endsWith('.tsx'))) {
      await runCommand('npm run test:components')
    }
    if (files.some((f) => f.includes('api/'))) {
      await runCommand('npm run test:api')
    }
  }
}

// .claude/commands/scaffold.js
module.exports = {
  name: 'scaffold',
  interactive: true,
  execute: async () => {
    const type = await prompt('Choose type: component/page/api')
    const name = await prompt('Enter name:')
    // Generate code based on input
  }
}

# Create frontend development workspace
claude --workspace frontend --dir ./src/components

# Create backend development workspace
claude --workspace backend --dir ./src/api

# Create testing workspace
claude --workspace testing --dir ./tests

# View session history
claude --history

# Resume specific session
claude --resume <session-id>

# Export session record
claude --export-session > session-backup.json