Claude Code Expert Skill

Claude Code Expert Skill

This skill provides comprehensive guidance on using Claude Code, Anthropic's agentic coding tool.

When to Use This Skill

Use this skill when users need help with:

• Understanding Claude Code features and capabilities
• Setting up and configuring Claude Code
• Working with slash commands, hooks, and plugins
• Using MCP servers and Agent Skills
• Troubleshooting Claude Code issues
• Understanding best practices for Claude Code usage
• Deploying Claude Code in enterprise environments
• Using Claude Code with IDEs (VS Code, JetBrains)

Core Concepts

What is Claude Code?

Claude Code is Anthropic's agentic coding tool that lives in your terminal and helps you turn ideas into code faster. Key features include:

• Agentic Capabilities: Claude autonomously plans, executes, and validates tasks
• Terminal Integration: Works directly in your command line
• IDE Support: Extensions for VS Code and JetBrains IDEs
• Extensibility: Plugins, skills, slash commands, and MCP servers
• Enterprise Ready: SSO, sandboxing, monitoring, and compliance features

Architecture Components

1. Subagents: Specialized AI agents for specific tasks

   • planner: Research and create implementation plans
   • code-reviewer: Review code quality and security
   • tester: Run tests and validate implementations
   • debugger: Investigate and diagnose issues
   • docs-manager: Manage technical documentation
   • ui-ux-designer: Design and implement UI/UX
   • database-admin: Database optimization and management
   • And many more specialized agents

2. Agent Skills: Modular capabilities that extend functionality

   • Package instructions, metadata, and resources
   • Automatically discovered and used by Claude
   • Shareable across projects and teams

3. Slash Commands: User-defined operations that expand to prompts

   • Located in .claude/commands/
   • Execute with /command-name
   • Can accept arguments

4. Hooks: Shell commands that execute in response to events

   • Pre/post tool execution hooks
   • User prompt submit hooks
   • Customizable validation and automation

5. MCP Servers: Model Context Protocol integrations

   • Connect external tools and services
   • Provide resources, tools, and prompts
   • Remote and local server support

Installation & Setup

Prerequisites

• macOS, Linux, or Windows (WSL2)
• Node.js 18+ or Python 3.10+
• API key from Anthropic Console

Installation

# Install via npm (recommended)
npm install -g @anthropic-ai/claude-code

# Or via pip
pip install claude-code

Authentication

# Login with API key
claude login

# Or set environment variable
export ANTHROPIC_API_KEY=your_api_key

First Run

# Start interactive session
claude

# Run with specific task
claude "implement user authentication"

# Use in specific directory
cd /path/to/project
claude

Common Workflows

1. Feature Implementation

# Use the cook command for feature work
/cook implement user authentication with JWT

# Or start with planning
/plan implement payment integration with Stripe

2. Bug Fixing

# Quick fixes
/fix:fast the login button is not working

# Complex debugging
/debug the API returns 500 errors intermittently

# Fix type errors
/fix:types

3. Code Review & Testing

# Review recent changes
claude "review my latest commit"

# Run tests
/test

# Fix test failures
/fix:test the user service tests are failing

4. Documentation

# Create initial documentation
/docs:init

# Update existing docs
/docs:update

# Summarize changes
/docs:summarize

5. Git Operations

# Commit changes
/git:cm

# Commit and push
/git:cp

# Create pull request
/git:pr feature-branch main

Slash Commands Reference

Development Commands

• /cook [task]: Implement features
• /plan [task]: Research and create implementation plans
• /debug [issue]: Debug technical issues
• /test: Run test suite
• /refactor: Improve code quality

Fix Commands

• /fix:fast [issue]: Quick fixes
• /fix:hard [issue]: Complex issues with planning
• /fix:types: Fix TypeScript errors
• /fix:test [issue]: Fix test failures
• /fix:ui [issue]: Fix UI issues
• /fix:ci [url]: Fix CI/CD issues
• /fix:logs [issue]: Analyze logs and fix

Documentation Commands

• /docs:init: Create initial documentation
• /docs:update: Update existing documentation
• /docs:summarize: Summarize codebase

Git Commands

• /git:cm: Stage and commit
• /git:cp: Stage, commit, and push
• /git:pr [branch] [base]: Create pull request

Planning Commands

• /plan:two [task]: Create plan with 2 approaches
• /plan:ci [url]: Plan CI/CD fixes
• /plan:cro [issue]: Create CRO optimization plan

Content Commands

• /content:fast [request]: Quick copy writing
• /content:good [request]: High-quality copy
• /content:enhance [issue]: Enhance existing content
• /content:cro [issue]: Conversion rate optimization

Design Commands

• /design:fast [task]: Quick design
• /design:good [task]: High-quality design
• /design:3d [task]: 3D designs with Three.js
• /design:screenshot [path]: Design from screenshot
• /design:video [path]: Design from video

Deployment Commands

• /deploy: Deploy using dx up
• /deploy-check: Check deployment readiness

Other Commands

• /brainstorm [question]: Brainstorm features
• /ask [question]: Answer technical questions
• /scout [prompt]: Scout directories
• /watzup: Review recent changes
• /bootstrap [requirements]: Bootstrap new project
• /journal: Write journal entries

Agent Skills

Creating Skills

Skills are located in .claude/skills/ and consist of:

1. skill.md: Main skill instructions
2. skill.json: Metadata and configuration

Example skill.json:

{
  "name": "my-skill",
  "description": "Brief description of when to use this skill",
  "version": "1.0.0",
  "author": "Your Name"
}

Example skill.md structure:

# Skill Name

Description of what this skill does.

## When to Use This Skill

Specific scenarios when Claude should activate this skill.

## Instructions

Step-by-step instructions for Claude to follow.

## Examples

Concrete examples of skill usage.

Best Practices for Skills

1. Clear Activation Criteria: Define exactly when the skill should be used
2. Concise Instructions: Focus on essential information
3. Actionable Guidance: Provide clear steps Claude can follow
4. Examples: Include concrete examples of expected inputs/outputs
5. Scope Limitation: Keep skills focused on specific domains

Using Skills via API

Skills can be used with the Claude API:

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

const response = await client.messages.create({
  model: 'claude-sonnet-4-5-20250929',
  max_tokens: 4096,
  skills: [
    {
      type: 'custom',
      custom: {
        name: 'document-creator',
        description: 'Creates professional documents',
        instructions: 'Follow corporate style guide...'
      }
    }
  ],
  messages: [{ role: 'user', content: 'Create a project proposal' }]
});

MCP Server Integration

What is MCP?

Model Context Protocol (MCP) allows Claude Code to connect to external tools and services.

Configuration

MCP servers are configured in .claude/mcp.json:

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path/to/allowed/files"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your_github_token"
      }
    }
  }
}

Common MCP Servers

• @modelcontextprotocol/server-filesystem: File system access
• @modelcontextprotocol/server-github: GitHub integration
• @modelcontextprotocol/server-postgres: PostgreSQL database
• @modelcontextprotocol/server-brave-search: Web search
• @modelcontextprotocol/server-puppeteer: Browser automation

Remote MCP Servers

Connect to MCP servers over HTTP/SSE:

{
  "mcpServers": {
    "remote-service": {
      "url": "https://api.example.com/mcp",
      "headers": {
        "Authorization": "Bearer token"
      }
    }
  }
}

Hooks System

Hook Types

1. Pre-tool hooks: Execute before tool calls
2. Post-tool hooks: Execute after tool calls
3. User prompt submit hooks: Execute when user submits prompts

Configuration

Hooks are configured in .claude/hooks.json:

{
  "hooks": {
    "pre-tool": {
      "bash": "echo 'Running bash command: $TOOL_ARGS'"
    },
    "post-tool": {
      "write": "./scripts/format-code.sh"
    },
    "user-prompt-submit": "./scripts/validate-request.sh"
  }
}

Hook Environment Variables

Available in hook scripts:

• $TOOL_NAME: Name of the tool being called
• $TOOL_ARGS: JSON string of tool arguments
• $TOOL_RESULT: Tool execution result (post-tool only)
• $USER_PROMPT: User's prompt text (user-prompt-submit only)

Use Cases

• Code formatting after file writes
• Security validation before bash execution
• Cost tracking and budgeting
• Custom logging and monitoring
• Integration with external systems

Plugins System

Plugin Structure

Plugins are packaged collections of extensions:

my-plugin/
├── plugin.json          # Plugin metadata
├── commands/            # Slash commands
├── skills/             # Agent skills
├── hooks/              # Hook scripts
├── mcp/                # MCP server configurations
└── README.md           # Documentation

plugin.json Example

{
  "name": "my-plugin",
  "version": "1.0.0",
  "description": "Plugin description",
  "author": "Your Name",
  "homepage": "https://github.com/user/plugin",
  "commands": ["commands/*.md"],
  "skills": ["skills/*/"],
  "hooks": "hooks/hooks.json",
  "mcpServers": "mcp/mcp.json"
}

Installing Plugins

# Install from GitHub
claude plugin install gh:username/repo

# Install from local path
claude plugin install ./path/to/plugin

# Install from npm
claude plugin install npm:package-name

# List installed plugins
claude plugin list

# Uninstall plugin
claude plugin uninstall plugin-name

Creating Plugin Marketplaces

Organizations can create private plugin marketplaces:

{
  "marketplaces": [
    {
      "name": "company-internal",
      "url": "https://plugins.company.com/catalog.json",
      "auth": {
        "type": "bearer",
        "token": "${COMPANY_PLUGIN_TOKEN}"
      }
    }
  ]
}

Configuration & Settings

Settings Hierarchy

1. Global settings: ~/.claude/settings.json
2. Project settings: .claude/settings.json
3. Environment variables
4. Command-line flags

Key Settings

{
  "model": "claude-sonnet-4-5-20250929",
  "maxTokens": 8192,
  "temperature": 1.0,
  "thinking": {
    "enabled": true,
    "budget": 10000
  },
  "sandboxing": {
    "enabled": true,
    "allowedPaths": ["/workspace"],
    "networkAccess": "restricted"
  },
  "outputStyle": "default",
  "memory": {
    "enabled": true,
    "location": "project"
  }
}

Model Configuration

Model aliases available:

• opusplan: Claude Opus with extended thinking for planning
• sonnet: Latest Claude Sonnet
• haiku: Claude Haiku for fast responses

Output Styles

Customize Claude's behavior for different use cases:

# List available output styles
ls ~/.claude/output-styles/

# Use specific output style
claude --output-style technical-writer

# Create custom output style
cat > ~/.claude/output-styles/my-style.md <<EOF
You are a [role]. Follow these guidelines:
- [Guideline 1]
- [Guideline 2]
EOF

Enterprise Features

Identity & Access Management

SSO Integration: SAML 2.0 and OAuth 2.0 support RBAC: Role-based access control User Management: Centralized user provisioning

Security & Compliance

Sandboxing: Filesystem and network isolation Audit Logging: Comprehensive activity logs Data Residency: Region-specific deployment options Compliance: SOC 2, HIPAA, GDPR compliant

Deployment Options

Amazon Bedrock: Deploy via AWS Bedrock Google Vertex AI: Deploy via GCP Vertex AI Self-hosted: On-premises deployment with Docker/Kubernetes LLM Gateway: Integration with LiteLLM and other gateways

Monitoring & Analytics

OpenTelemetry: Built-in telemetry support Usage Analytics: Track team productivity metrics Cost Management: Monitor and control API costs Custom Dashboards: Build org-specific dashboards

Network Configuration

Proxy Support: HTTP/HTTPS proxy configuration Custom CA: Trust custom certificate authorities mTLS: Mutual TLS authentication IP Allowlisting: Restrict access by IP

IDE Integration

Visual Studio Code

Install the official extension:

1. Open VS Code
2. Search for "Claude Code" in extensions
3. Install and authenticate

Features:

• Inline chat
• Code actions
• Diff view
• Terminal integration

JetBrains IDEs

Supported IDEs:

• IntelliJ IDEA
• PyCharm
• WebStorm
• PhpStorm
• GoLand
• RubyMine

Installation:

1. Open Settings → Plugins
2. Search for "Claude Code"
3. Install and authenticate

CI/CD Integration

GitHub Actions

Example workflow:

name: Claude Code CI
on: [push, pull_request]

jobs:
  claude-review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: anthropic/claude-code-action@v1
        with:
          command: '/fix:types && /test'
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

GitLab CI/CD

Example pipeline:

claude-review:
  image: node:18
  script:
    - npm install -g @anthropic-ai/claude-code
    - claude login --api-key $ANTHROPIC_API_KEY
    - claude '/fix:types && /test'
  only:
    - merge_requests

Advanced Features

Extended Thinking

Enable deep reasoning for complex problems:

# Enable extended thinking globally
claude config set thinking.enabled true

# Set thinking budget
claude config set thinking.budget 15000

# Use in API
const response = await client.messages.create({
  model: 'claude-sonnet-4-5-20250929',
  thinking: {
    type: 'enabled',
    budget_tokens: 10000
  },
  messages: [...]
});

Prompt Caching

Reduce costs by caching repeated context:

const response = await client.messages.create({
  model: 'claude-sonnet-4-5-20250929',
  system: [
    {
      type: 'text',
      text: 'You are a coding assistant...',
      cache_control: { type: 'ephemeral' }
    }
  ],
  messages: [...]
});

Checkpointing

Automatically track and rewind changes:

# Enable checkpointing
claude config set checkpointing.enabled true

# View checkpoints
claude checkpoint list

# Rewind to checkpoint
claude checkpoint restore <checkpoint-id>

# Create manual checkpoint
claude checkpoint create "before refactoring"

Memory Management

Control how Claude remembers context:

# Enable memory
claude config set memory.enabled true

# Set memory location (global/project/none)
claude config set memory.location project

# View stored memories
claude memory list

# Clear memories
claude memory clear

Troubleshooting

Common Issues

Authentication Failures

# Re-login
claude logout
claude login

# Verify API key
echo $ANTHROPIC_API_KEY

MCP Server Connection Issues

# Test MCP server
npx @modelcontextprotocol/inspector

# Check MCP configuration
cat .claude/mcp.json

Performance Issues

• Reduce context window size
• Enable prompt caching
• Use appropriate model (Haiku for speed)
• Clear memory cache

Permission Errors

• Check file permissions
• Verify sandboxing settings
• Review hook configurations

Debug Mode

Enable verbose logging:

# Enable debug logging
export CLAUDE_DEBUG=1
claude

# Or use debug flag
claude --debug "implement feature"

Getting Help

• Documentation: https://docs.claude.com/claude-code
• GitHub Issues: https://github.com/anthropics/claude-code/issues
• Support: support.claude.com
• Community: discord.gg/anthropic

Best Practices

1. Project Organization

• Keep .claude/ directory in version control
• Document custom commands and skills
• Share plugin configurations with team
• Use project-specific settings

2. Security

• Never commit API keys
• Use environment variables for secrets
• Enable sandboxing in production
• Review hook scripts before execution
• Audit plugin sources

3. Performance Optimization

• Use prompt caching for repeated context
• Choose appropriate model for task
• Implement rate limiting in hooks
• Monitor token usage
• Use batch processing for bulk operations

4. Team Collaboration

• Standardize slash commands across projects
• Share useful skills via plugin marketplace
• Document custom configurations
• Set up CI/CD integration
• Use consistent memory settings

5. Cost Management

• Set budget limits in hooks
• Monitor usage via analytics API
• Use Haiku for simple tasks
• Implement caching strategies
• Track per-project costs

API Reference

Admin API

Get Usage Report

GET /v1/admin/claude-code/usage

Get Cost Report

GET /v1/admin/usage/cost

List Users

GET /v1/admin/users

Messages API

Create Message

POST /v1/messages

Stream Message

POST /v1/messages (with stream=true)

Count Tokens

POST /v1/messages/count_tokens

Files API

Upload File

POST /v1/files

List Files

GET /v1/files

Delete File

DELETE /v1/files/:file_id

Models API

List Models

GET /v1/models

Get Model

GET /v1/models/:model_id

Skills API

Create Skill

POST /v1/skills

List Skills

GET /v1/skills

Update Skill

PATCH /v1/skills/:skill_id

Conclusion

Claude Code is a powerful agentic coding tool that can significantly accelerate development workflows. By leveraging its extensibility through skills, plugins, MCP servers, and hooks, you can create a highly customized development environment tailored to your team's needs.

Start simple with basic commands, then gradually adopt advanced features like custom skills, MCP integrations, and enterprise deployment options as your needs grow.