A Complete Guide to Claude Code - Here are ALL the Best Strategies

Key Concepts

• Claude Code: An AI coding assistant.
• Context Engineering: Providing AI coding assistants with the necessary information to build production-ready software.
• Global Rules (claw.md): System prompts to steer Claude Code's behavior, defining best practices and patterns.
• Permission Management (settings.local.json): Defining commands Claude Code can run without explicit approval.
• Custom Slash Commands: Reusable prompts for Claude Code, enabling agentic workflows.
• MCP Servers: External tools connected to Claude Code to enhance its capabilities.
• PRP Framework: A three-step process for defining features, generating context documents, and executing them with AI coding assistants.
• Sub Agents: Specialized AI agents called upon by a primary Claude Code agent for specific tasks.
• Claude Hooks: Automations triggered at different points in the development lifecycle.
• GitHub CLI Integration: Managing GitHub issues and pull requests directly from Claude Code.
• YOLO Mode with Dev Containers: Running Claude Code in an isolated environment with dangerous permissions for full autonomy.
• Parallel Agent Development: Using multiple instances of Claude Code to work on different parts of a codebase or implement the same feature simultaneously.

Global Rules (claw.md)

• Purpose: To provide high-level instructions and best practices to Claude Code.
• Creation:
  • Using the built-in /init command.
  • Manually creating a claw.md file.
• Example: A claw.md file for Python-based applications, including instructions like "Keep It Simple, Stupid" (KISS) and "You Ain't Gonna Need It" (YAGNI).
• Multiple claw.md Files: Can be placed at different levels of the repository (e.g., frontend and backend folders). Claude Code intelligently uses the relevant claw.md based on the current context.
• Best Practices:
  • Referencing external files (patterns, best practices, business documents) in claw.md for easier sharing and switching between AI coding assistants.
• Prompting Strategies:
  • Using keywords like "important," "proactively," and "ultraink" to influence Claude Code's behavior.
  • Prompting against over-engineering and keeping old code for backward compatibility.

Permission Management (settings.local.json)

• Purpose: To control which commands Claude Code can run without explicit approval.
• Implementation:
  • Using the permissions command in Claude Code.
  • Defining an allow list and a deny list in the settings.local.json file within the .claw directory.
• Example: Allowing commands like grep, ls, mkdir, and running Python commands.
• Security Recommendations:
  • Never add the rm (remove) command to the allow list.
  • Avoid using bash * to prevent Claude Code from running any command without approval.

Custom Slash Commands

• Purpose: To build agentic workflows that can be triggered with simple prompts.
• Creation:
  • Creating a commands folder within the .claw directory.
  • Defining slash commands as markdown files (e.g., primer.md).
• Example: A primer command that instructs Claude Code to get up to speed with a codebase by using the tree command, reading the claw.md file, and reading the README.md file.
• Parameters: Slash commands can accept arguments using the $arguments keyword.
• Sharing: Slash commands can be easily shared with teammates.

MCP Servers

• Purpose: To enhance Claude Code's capabilities with external tools.
• Examples:
  • Serena MCP server for semantic retrieval and code editing.
  • Archon MCP server for knowledge and task management.
• Adding MCP Servers:
  • Using the cloud mcp add command.
• Permission Management:
  • Adding mcp_serena or mcp_archon to the settings.local.json file to allow Claude Code to use the MCP server's tools without asking for permission.
• Serena MCP Server:
  • Enhances Claude Code's understanding of the codebase.
  • Particularly useful for working with existing codebases.
• Archon MCP Server (Overhaul):
  • A knowledge and task management backbone for AI coding assistants.
  • Features a user interface for managing tasks and knowledge in real-time.
  • Includes documentation crawling capabilities.

Context Engineering with the PRP Framework

• Purpose: To provide AI coding assistants with a comprehensive context for building features or projects.
• Three-Step Process:
  1. Define: Outline the feature or project in an initial markdown file (initial MD) within the PRPS folder.
  2. Generate: Generate a comprehensive document (PRP - Product Requirement Prompt) using a slash command (e.g., /generate pyantic AI PRP).
  3. Execute: Execute the PRP using a slash command (e.g., /execute PRP).
• Initial MD:
  • Describes the feature, tools, dependencies, and system prompts.
  • Provides examples and documentation references.
  • Includes considerations and potential pitfalls.
• PRP:
  • A longer-form prompt that contains all the context for the coding assistant.
  • Based on a base PRP template that covers core principles, tasks, validation loops, and anti-patterns.
• Validation: Always validate the generated PRP before execution.

Sub Agents

• Purpose: To add specialized intelligence to coding workflows.
• Functionality:
  • A primary Claude Code agent can call upon sub agents for specific tasks.
  • Sub agents have their own context windows and specialized system prompts.
  • The primary agent prompts the sub agent based on its understanding of the sub agent's capabilities.
  • Sub agents can work autonomously on delegated tasks.
  • The primary agent can kick off multiple sub agents in parallel.
• Implementation:
  • Sub agents are defined as markdown files within the agents folder in the .claw directory.
• Example: A validation gates sub agent that is responsible for writing and validating tests.
• Sub Agent Definition:
  • Includes the name of the agent, a description (which tells the primary agent how to invoke it), and the tools it has access to.

Claude Hooks

• Purpose: To add deterministic control to Claude Code's behavior.
• Functionality:
  • Custom commands can be invoked after specific actions, such as using a tool or a sub agent.
• Implementation:
  • Hooks are defined in JSON and added to the settings.local.json file.
• Example: A hook that logs tool usage to a file every time a tool is used.
• Parameters: Hooks can receive parameters, such as the specific tools that were used.

GitHub CLI Integration

• Purpose: To manage GitHub issues and pull requests directly from Claude Code.
• Setup:
  • Install the GitHub CLI.
  • Authenticate with GitHub using gh auth login.
• Functionality:
  • Creating issues and pull requests.
  • Fixing GitHub issues automatically.
• Example: A fixGitub issue slash command that takes an issue number as an argument, uses the GitHub CLI to understand the issue, implements a fix, writes tests, and creates a pull request.

YOLO Mode with Dev Containers

• Purpose: To run Claude Code in an isolated environment with dangerous permissions for full autonomy.
• Implementation:
  • Using dev containers to run Claude Code in its own isolated environment.
  • Setting up firewalls for the dev container.
  • Running Claude Code with the --dangerously-skip-permissions flag.
• Benefits:
  • Protects the entire machine from potentially harmful actions.
  • Allows Claude Code to operate entirely autonomously without asking for approval.

Parallel Agent Development

• Purpose: To use multiple instances of Claude Code to work on different parts of a codebase or implement the same feature simultaneously.
• Implementation:
  • Using git work trees to have different branches of the GitHub repository open at the same time.
  • Running an instance of Claude Code on each work tree.
• Manual Setup:
  • Creating feature branches.
  • Adding work trees using git worktree add.
  • Changing into the work tree directory and launching Claude Code.
• Automated Setup (Slash Commands):
  • prep parallel: Creates new branches and git work trees.
  • execute parallel: Executes a plan in each work tree and reports the results.
• Benefits:
  • Faster development.
  • Ability to pick the best implementation from multiple parallel agents.

Conclusion

Claude Code is a powerful AI coding assistant that can be significantly enhanced by leveraging its features and integrating it with external tools. By implementing global rules, managing permissions, using custom slash commands, connecting to MCP servers, utilizing the PRP framework, employing sub agents, adding Claude Hooks, integrating with the GitHub CLI, running in YOLO mode with dev containers, and using parallel agent development, developers can maximize their productivity and build production-ready software more efficiently.