@calmhive/calmhive-cli

# Claude Code Best Practices & Tips *Comprehensive guide compiled from official Anthropic documentation and community insights* ## Table of Contents - [Getting Started](#getting-started) - [Core Commands & CLI Usage](#core-commands--cli-usage) - [CLAUDE.md Files & Project Memory](#claudemd-files--project-memory) - [Advanced Features](#advanced-features) - [Custom Slash Commands](#custom-slash-commands) - [Thinking Modes](#thinking-modes) - [Workflow Strategies](#workflow-strategies) - [Safety & Permissions](#safety--permissions) - [Collaboration Tips](#collaboration-tips) - [Troubleshooting](#troubleshooting) ## Getting Started ### Installation ```bash npm install -g @anthropic-ai/claude-code ``` ### Basic Usage ```bash # Start interactive REPL claude # Start with initial prompt claude "explain this codebase" # One-shot query via SDK claude -p "fix the bug in auth.js" # Continue most recent conversation claude -c # Update to latest version claude update ``` ### Key CLI Flags - `--add-dir`: Add working directories - `--print/-p`: Print response without interactive mode - `--output-format`: Specify format (text, json, stream-json) - `--verbose`: Enable detailed logging - `--model`: Set model for session - `--continue`: Load most recent conversation - `--resume`: Resume specific session ## Core Commands & CLI Usage ### Essential Commands ```bash # Basic commands claude # Start REPL claude "query" # Start with prompt claude -p "query" # Query and exit claude -c # Continue conversation # Data input methods cat file.txt | claude # Pipe data claude -p "analyze" < data.csv # Redirect input # Session management claude --resume session_id # Resume specific session claude --model claude-3-opus # Use specific model ``` ### Piping and Data Input Claude Code supports multiple data input methods: - Copy and paste directly into prompts - Pipe data: `cat foo.txt | claude` - Tell Claude to pull data via bash commands - Ask Claude to read files or fetch URLs - Use for logs, CSVs, and large datasets ## CLAUDE.md Files & Project Memory ### Purpose CLAUDE.md files serve as project memory and context for Claude Code. They help maintain consistency across sessions and team members. ### What to Include ```markdown # Project: MyApp ## Development Commands - `npm run dev` - Start development server - `npm test` - Run test suite - `npm run build` - Build for production ## Code Style - Use TypeScript for all new files - Follow ESLint configuration - Use Prettier for formatting - 2-space indentation ## Testing Guidelines - Write unit tests for all utilities - Integration tests for API endpoints - Use Jest and React Testing Library ## Repository Structure - `/src` - Source code - `/tests` - Test files - `/docs` - Documentation - `/scripts` - Build and deployment scripts ## Common Patterns - Use custom hooks for state management - Prefer composition over inheritance - Always handle error states in components ``` ### Team Benefits - Include CLAUDE.md changes in commits - Share knowledge across team members - Maintain consistency in coding standards - Document project-specific commands and patterns ## Advanced Features ### MCP Integration ```bash # Configure MCP servers claude mcp add my-server -s project /path/to/server claude mcp get my-server claude mcp list ``` ### Git Integration - Search git history - Resolve merge conflicts - Create commits and pull requests - Browse repository context ### Multi-Language Support - Works with any programming language - Understands project context automatically - Adapts to existing code patterns ## Custom Slash Commands ### Creating Custom Commands Place markdown files in `.claude/commands/` to create custom slash commands: ```markdown  # Fix GitHub Issue 1. Use `gh issue view {issue_number}` to get issue details 2. Analyze the problem and identify root cause 3. Implement the fix following project patterns 4. Write or update tests 5. Create descriptive commit message 6. Verify the fix resolves the issue ``` Access with: `/project:fix-github-issue` ### Useful Custom Commands - `/create-docs` - Generate comprehensive documentation - `/run-tests` - Execute test suite with reporting - `/deploy-staging` - Deploy to staging environment - `/code-review` - Perform code review checklist - `/refactor-component` - Modernize legacy components ### Command Categories - **Project-specific**: Commands for your specific codebase - **Personal**: Commands for your workflow preferences - **Dynamic**: Commands with arguments and parameters ## Thinking Modes ### Understanding Thinking Modes Claude Code includes "thinking" modes that allocate additional computation time for complex problems. ### Thinking Levels ``` think < think hard < think harder < ultrathink ``` ### Token Allocations - `think`: ~4,000 tokens - `think hard`: ~6,000 tokens - `megathink`: ~10,000 tokens - `ultrathink`: ~32,000 tokens ### When to Use - **think**: Standard problem-solving - **think hard**: Complex debugging or architecture decisions - **ultrathink**: Extremely complex problems requiring deep analysis ### Usage Examples ```bash claude "think hard about optimizing this algorithm" claude "ultrathink the best architecture for this microservice" ``` ## Workflow Strategies ### Recommended Workflows #### 1. Explore, Plan, Code, Commit ```bash # Explore codebase claude "give me an overview of this project structure" # Plan changes claude "think about the best approach to add user authentication" # Implement claude "implement JWT authentication with Express middleware" # Commit claude "create a commit with proper message for auth implementation" ``` #### 2. Test-Driven Development ```bash # Write tests first claude "write unit tests for user authentication module" # Implement to pass tests claude "implement the authentication module to pass these tests" # Refactor claude "refactor the auth code for better readability" ``` #### 3. Visual Iteration - Provide screenshots for UI work - Use mockups as targets - Iterate based on visual feedback #### 4. Bug Fixing Workflow ```bash # Reproduce issue claude "help me reproduce this authentication bug" # Analyze claude "think hard about what could cause this auth failure" # Fix claude "implement a fix for the authentication issue" # Verify claude "write tests to ensure this bug doesn't happen again" ``` ### Large Task Management For complex tasks: - Use Markdown files as checklists - Break down into smaller subtasks - Use GitHub issues as working scratchpads - Create multiple Claude sessions for parallel work ## Safety & Permissions ### Permission Management ```bash # View current permissions /permissions # Modify tool permissions claude config set toolPermissions.Bash allow claude config set toolPermissions.Edit prompt claude config set toolPermissions.Bash deny ``` ### Permission Levels - `allow`: Always allow without prompting - `prompt`: Ask for permission each time (default) - `deny`: Never allow tool use ### Best Practices - Start with prompt permissions for new projects - Use `allow` for trusted, repetitive tasks - Be cautious with `--dangerously-skip-permissions` - Prefer containerized environments for experimentation ### Tool Safety ```bash # Disable specific tools claude --disable-tool Bash,Edit # Safer alternatives claude config set toolPermissions.FileWrite prompt ``` ## Collaboration Tips ### Course Correction - Correct Claude early and often - Be specific about what went wrong - Provide clear examples of desired behavior ### Context Management ```bash # Clear context when switching tasks /clear # Reset conversation /reset ``` ### Team Collaboration - Share CLAUDE.md files in git repositories - Document team coding standards - Include common commands and patterns - Version control your `.claude/commands/` directory ### Multiple Sessions ```bash # Use git worktrees for parallel development git worktree add ../feature-branch feature-branch cd ../feature-branch claude "work on the new feature" ``` ## Troubleshooting ### Common Issues #### Context Overload - Use `/clear` to reset context - Break large tasks into smaller sessions - Focus on specific files or components #### Permission Errors ```bash # Check permissions /permissions # Reset to defaults claude config reset toolPermissions ``` #### Performance Issues - Use thinking modes for complex problems - Provide clear, specific instructions - Break complex tasks into steps ### Debugging Commands ```bash # Verbose logging claude --verbose # Check configuration claude config show # Verify installation claude --version ``` ### Memory Management - Claude Code automatically manages conversation history - Use `/clear` to reset context when needed - Long conversations may need periodic clearing ## Pro Tips ### Optimization Strategies 1. **Be Specific**: Provide clear, detailed instructions 2. **Use Context**: Reference files, functions, and patterns 3. **Iterate**: Make small changes and verify results 4. **Document**: Update CLAUDE.md with successful patterns 5. **Test**: Verify changes work as expected ### Advanced Techniques - Use subagents for complex multi-step problems - Combine with other tools (GitHub CLI, Docker, etc.) - Create project-specific command templates - Use visual targeting for UI development ### Performance Tips - Provide target outputs (tests, mockups, specifications) - Use incremental development approaches - Leverage Claude's codebase understanding - Course correct early to avoid wrong directions ### Integration Examples ```bash # With GitHub CLI claude "use gh to create a PR for this feature" # With Docker claude "containerize this application" # With testing frameworks claude "run the test suite and fix any failures" ``` --- ## Additional Resources - [Official Claude Code Documentation](https://docs.anthropic.com/en/docs/claude-code) - [Claude Code Best Practices (Anthropic)](https://www.anthropic.com/engineering/claude-code-best-practices) - [Community Examples](https://github.com/hesreallyhim/awesome-claude-code) *This guide is based on official Anthropic documentation and community best practices as of 2025.*