Everything Claude Code: The Ultimate Production-Ready Plugin Collection Guide

January 24, 2026 • 22 min read • Yen

Claude Code AI Development Tools MCP Agents Automation Best Practices Productivity Testing DevOps

The everything-claude-code repository represents one of the most comprehensive and battle-tested collections of Claude Code configurations available today. Created by an Anthropic hackathon winner and evolved over 10+ months of intensive daily use building real products, this repository has earned its 22.3k stars by providing production-ready solutions to common development challenges.

This post provides a complete guide to setting up, customizing, and mastering this powerful plugin collection, along with best practices learned from real-world usage.

What is Everything Claude Code?

Think of it as a professional development team in a box. The repository provides a complete ecosystem of specialized components that transform Claude Code from a general-purpose AI assistant into a sophisticated development partner with deep knowledge of your workflows, standards, and infrastructure.

The Core Problem It Solves

Working with Claude Code out of the box, developers face several challenges:

Repetitive Instructions: Constantly re-explaining coding standards, testing requirements, and architectural patterns
Context Loss: Starting fresh each session without memory of previous decisions
Manual Workflow: Repeatedly performing the same multi-step processes (testing, code review, deployment)
Tool Overload: Managing dozens of MCP servers and tools without clear organization
Inconsistent Quality: Varying output quality depending on how well you prompt

The everything-claude-code repository systematically addresses each of these issues through five key component types.

Repository Architecture: Five Pillars of Productivity

~/.claude/
├── agents/              # Specialized subagents for delegation
│   ├── planner/
│   ├── architect/
│   ├── tdd-engineer/
│   ├── code-reviewer/
│   ├── security-auditor/
│   ├── build-fixer/
│   ├── e2e-tester/
│   ├── refactorer/
│   └── documentor/
├── skills/              # Workflow definitions and patterns
│   ├── coding-standards/
│   ├── backend-patterns/
│   ├── frontend-patterns/
│   ├── tdd-methodology/
│   ├── security-review/
│   └── verification-loops/
├── commands/            # Slash commands for quick actions
│   ├── tdd.md
│   ├── plan.md
│   ├── e2e.md
│   ├── code-review.md
│   ├── build-fix.md
│   └── refactor-clean.md
├── rules/               # Always-enforced guidelines
│   ├── security.md
│   ├── coding-style.md
│   ├── testing.md
│   ├── git-workflow.md
│   └── performance.md
├── hooks/               # Event-triggered automations
│   ├── pre-tool-use/
│   ├── post-tool-use/
│   └── on-stop/
├── scripts/             # Cross-platform utilities
│   └── package-manager-detector.js
└── mcp-configs/         # Pre-configured MCP servers
    ├── github.json
    ├── supabase.json
    ├── vercel.json
    └── railway.json

1. Agents: Your Specialized Development Team

Agents are specialized subagents designed for specific tasks. Each agent has deep expertise in its domain and follows proven patterns:

 1# TDD Engineer Agent (agents/tdd-engineer/)
 2
 3**Role**: Test-Driven Development specialist
 4**Expertise**: Writing tests first, implementing minimal code to pass
 5
 6**Process**:
 71. Understand requirements thoroughly
 82. Write failing test cases
 93. Implement minimal code to pass tests
104. Refactor while keeping tests green
115. Document test coverage
12
13**Best Practices**:
14- Start with edge cases
15- One test at a time
16- Clear test descriptions
17- Comprehensive assertions
18- Fast execution time

Key Agents Available:

Planner: Breaks down complex features into actionable tasks
Architect: Designs system architecture and makes technology decisions
TDD Engineer: Implements features using test-driven development
Code Reviewer: Performs comprehensive code reviews with security focus
Security Auditor: Identifies vulnerabilities and suggests fixes
Build Fixer: Diagnoses and resolves build failures
E2E Tester: Creates and maintains end-to-end test suites
Refactorer: Improves code quality while preserving functionality
Documentor: Generates comprehensive technical documentation

2. Skills: Reusable Workflow Definitions

Skills define standardized workflows that Claude Code follows automatically. They encode institutional knowledge and best practices:

 1# Backend API Development Skill
 2
 3## Workflow
 4
 5### 1. Planning Phase
 6- Define API endpoints and methods
 7- Specify request/response schemas
 8- Identify authentication requirements
 9- Plan database schema changes
10
11### 2. Implementation Phase
12- Write integration tests first
13- Implement route handlers
14- Add input validation
15- Implement business logic
16- Add error handling
17
18### 3. Testing Phase
19- Unit tests for business logic
20- Integration tests for endpoints
21- Load testing for performance
22- Security testing for vulnerabilities
23
24### 4. Documentation Phase
25- OpenAPI/Swagger specs
26- Example requests/responses
27- Error code documentation
28- Authentication flow diagrams
29
30## Quality Gates
31- ✅ All tests passing
32- ✅ 80%+ code coverage
33- ✅ No security vulnerabilities
34- ✅ API docs generated
35- ✅ Performance benchmarks met

3. Commands: Quick Workflow Triggers

Commands provide slash-command interfaces to common workflows:

 1# Available Commands
 2/tdd           # Start test-driven development workflow
 3/plan          # Create implementation plan
 4/e2e           # Generate end-to-end tests
 5/code-review   # Perform comprehensive code review
 6/build-fix     # Diagnose and fix build errors
 7/refactor-clean # Improve code quality
 8/setup-pm      # Configure package manager
 9/security      # Run security audit
10/docs          # Generate documentation

Each command delegates to the appropriate agent with predefined parameters and workflows.

4. Rules: Always-Enforced Guidelines

Rules are automatically applied to every Claude Code interaction, ensuring consistency:

 1# Security Rules (Always Applied)
 2
 3## Input Validation
 4- ALWAYS validate and sanitize all user input
 5- Use parameterized queries for database operations
 6- Never trust client-side validation alone
 7
 8## Authentication & Authorization
 9- Verify authentication on every protected endpoint
10- Implement least-privilege access control
11- Use secure session management
12
13## Data Protection
14- Encrypt sensitive data at rest and in transit
15- Never log passwords or tokens
16- Use environment variables for secrets
17
18## Dependencies
19- Keep all dependencies up to date
20- Review security advisories regularly
21- Use lock files for deterministic builds
22
23## Code Review Checklist
24- [ ] No hardcoded secrets
25- [ ] Input validation present
26- [ ] Error messages don't leak info
27- [ ] Authentication verified
28- [ ] Authorization checked

5. Hooks: Event-Triggered Automation

Hooks execute automatically in response to events, enabling powerful automations:

 1// pre-tool-use hook: Save context before tool execution
 2{
 3  "eventType": "PreToolUse",
 4  "script": "scripts/save-context.js",
 5  "enabled": true
 6}
 7
 8// post-tool-use hook: Run tests after file edits
 9{
10  "eventType": "PostToolUse",
11  "toolNames": ["Edit", "Write"],
12  "script": "scripts/run-tests.js",
13  "enabled": true
14}
15
16// on-stop hook: Generate session summary
17{
18  "eventType": "Stop",
19  "script": "scripts/session-summary.js",
20  "enabled": true
21}

Installation: Two Approaches

Option 1: Plugin Marketplace (Recommended)

The fastest and easiest method:

1# In Claude Code CLI
2/plugins search everything-claude-code
3
4# Install the plugin
5/plugins install everything-claude-code
6
7# Verify installation
8/plugins list

This method handles all file copying and configuration automatically, with built-in update support.

Option 2: Manual Installation

For customization or offline environments:

 1# 1. Clone the repository
 2git clone https://github.com/affaan-m/everything-claude-code.git
 3cd everything-claude-code
 4
 5# 2. Copy components to Claude Code directory
 6# On macOS/Linux:
 7cp -r agents ~/.claude/agents
 8cp -r skills ~/.claude/skills
 9cp -r commands ~/.claude/commands
10cp -r rules ~/.claude/rules
11cp -r hooks ~/.claude/hooks
12cp -r scripts ~/.claude/scripts
13cp -r mcp-configs ~/.claude/mcp-configs
14
15# On Windows (PowerShell):
16Copy-Item -Recurse -Force agents $env:USERPROFILE\.claude\agents
17Copy-Item -Recurse -Force skills $env:USERPROFILE\.claude\skills
18Copy-Item -Recurse -Force commands $env:USERPROFILE\.claude\commands
19Copy-Item -Recurse -Force rules $env:USERPROFILE\.claude\rules
20Copy-Item -Recurse -Force hooks $env:USERPROFILE\.claude\hooks
21Copy-Item -Recurse -Force scripts $env:USERPROFILE\.claude\scripts
22Copy-Item -Recurse -Force mcp-configs $env:USERPROFILE\.claude\mcp-configs
23
24# 3. Install script dependencies
25cd ~/.claude/scripts
26npm install
27
28# 4. Restart Claude Code

Post-Installation Configuration

After installation, customize for your environment:

 1# 1. Configure your package manager preference
 2# Edit ~/.claude/config.json
 3{
 4  "packageManager": "pnpm",  # or npm, yarn, bun
 5  "enabledAgents": [
 6    "planner",
 7    "tdd-engineer",
 8    "code-reviewer"
 9  ],
10  "enabledHooks": [
11    "save-context",
12    "run-tests"
13  ]
14}
15
16# 2. Set up MCP servers
17# Edit ~/.claude/mcp-configs/github.json
18{
19  "github": {
20    "token": "${GITHUB_TOKEN}",
21    "repo": "your-org/your-repo"
22  }
23}
24
25# 3. Customize rules for your stack
26# Edit ~/.claude/rules/coding-style.md to match your team's standards

Critical Best Practice: Context Window Management

This is the most important lesson from the repository’s documentation.

Claude Code has a 200k token context window, but poor configuration can shrink effective capacity to 70k tokens. The culprit? Too many MCP servers and tools active simultaneously.

The Problem

# ❌ BAD: Too many active tools
~/.claude/mcp-configs/
├── github.json          # 15 tools
├── gitlab.json          # 12 tools
├── supabase.json        # 20 tools
├── firebase.json        # 18 tools
├── vercel.json          # 8 tools
├── railway.json         # 6 tools
├── aws.json             # 30 tools
├── docker.json          # 25 tools
└── kubernetes.json      # 35 tools

Total: 169 tools loaded into every conversation!
Context consumed: ~130k tokens just for tool definitions
Remaining for code: ~70k tokens

The Solution: Project-Specific MCP Configurations

 1# ✅ GOOD: Project-specific configuration
 2~/projects/web-app/.claude/mcp-config.json
 3{
 4  "mcpServers": {
 5    "github": {
 6      "command": "npx",
 7      "args": ["-y", "@modelcontextprotocol/server-github"]
 8    },
 9    "supabase": {
10      "command": "npx",
11      "args": ["-y", "@modelcontextprotocol/server-supabase"]
12    }
13  }
14}
15
16# Result: ~40 tools total
17# Context consumed: ~30k tokens
18# Remaining for code: ~170k tokens

Context Optimization Guidelines

From the repository’s best practices:

Fewer than 10 MCP servers per project - More than this significantly degrades performance
Under 80 total active tools - Each tool definition consumes ~200 tokens
Project-specific configurations - Different MCP servers for different projects
Disable unused tools - Even within enabled MCPs, disable tools you don’t need
Monitor token usage - Use /context-stats to see current consumption

Practical Example: E-commerce Project

 1// ~/projects/ecommerce/.claude/mcp-config.json
 2{
 3  "mcpServers": {
 4    // Frontend development
 5    "github": { "enabled": true },
 6
 7    // Backend API
 8    "supabase": { "enabled": true },
 9
10    // Deployment
11    "vercel": { "enabled": true },
12
13    // Payment processing (only when needed)
14    "stripe": { "enabled": false }  // Enable manually with /mcp enable stripe
15  },
16  "contextOptimization": {
17    "autoDisableUnusedTools": true,
18    "sessionBasedActivation": true
19  }
20}

Workflow Patterns: Real-World Usage

Pattern 1: Feature Development with TDD

 1# 1. Start with planning
 2/plan implement user authentication with JWT
 3
 4# Claude delegates to Planner agent, creates task breakdown
 5
 6# 2. Begin TDD workflow
 7/tdd
 8
 9# TDD Engineer agent activated:
10# - Writes failing tests
11# - Implements minimal code
12# - Refactors
13# - Documents
14
15# 3. Code review before committing
16/code-review
17
18# Code Reviewer agent checks:
19# - Code quality
20# - Security issues
21# - Test coverage
22# - Documentation
23
24# 4. Fix any issues found
25# Claude automatically fixes issues based on review
26
27# 5. Commit with generated message
28git add .
29git commit -m "feat: implement JWT authentication
30
31- Add JWT token generation and validation
32- Implement secure password hashing
33- Add authentication middleware
34- Test coverage: 95%
35
36Co-authored-by: Claude Code <noreply@anthropic.com>"

Pattern 2: Build Error Resolution

 1# You see build errors
 2npm run build
 3# Error: Module not found: 'react-router-dom'
 4
 5# Quick fix with specialized agent
 6/build-fix
 7
 8# Build Fixer agent:
 9# 1. Analyzes error output
10# 2. Identifies root cause (missing dependency)
11# 3. Proposes solution
12# 4. Executes fix (npm install react-router-dom)
13# 5. Verifies build succeeds
14# 6. Commits fix if needed

Pattern 3: Security Audit

 1# Before production deployment
 2/security
 3
 4# Security Auditor agent:
 5# 1. Scans for common vulnerabilities
 6# 2. Checks dependency security
 7# 3. Reviews authentication/authorization
 8# 4. Validates input sanitization
 9# 5. Checks for secret leaks
10# 6. Generates security report
11
12# Output:
13# ✅ No hardcoded secrets found
14# ❌ SQL injection risk in user search endpoint
15# ❌ Missing rate limiting on login endpoint
16# ⚠️  3 dependencies with known vulnerabilities
17
18# Claude automatically creates issues for each finding
19# and can fix them immediately with your approval

Pattern 4: Comprehensive Refactoring

 1# Legacy code needs improvement
 2/refactor-clean src/components/UserProfile.jsx
 3
 4# Refactorer agent:
 5# 1. Analyzes code structure
 6# 2. Identifies improvement opportunities:
 7#    - Extract reusable hooks
 8#    - Reduce component complexity
 9#    - Improve naming
10#    - Add TypeScript types
11#    - Optimize renders
12# 3. Refactors incrementally
13# 4. Runs tests after each change
14# 5. Ensures no functionality breaks

Advanced Techniques

1. Custom Agent Creation

Create specialized agents for your domain:

 1# ~/.claude/agents/api-integration-specialist/
 2
 3**Role**: Third-party API integration expert
 4**Expertise**: REST APIs, GraphQL, webhooks, rate limiting, retries
 5
 6**Process**:
 71. Review API documentation
 82. Design client wrapper with error handling
 93. Implement rate limiting and retries
104. Write integration tests with mocks
115. Create usage examples
12
13**Tech Stack Familiarity**:
14- axios/fetch for HTTP requests
15- graphql-request for GraphQL
16- node-cache for response caching
17- p-retry for retry logic
18
19**Quality Standards**:
20- Comprehensive error handling
21- Request/response logging
22- API key management via env vars
23- Automatic token refresh
24- Circuit breaker pattern

Usage:

1/agent api-integration-specialist "integrate Stripe payment API"

2. Custom Skills for Your Stack

Define workflows specific to your technology:

 1# ~/.claude/skills/nextjs-fullstack/
 2
 3## Next.js Full-Stack Feature Development
 4
 5### 1. Component Development
 6- Create React Server Component
 7- Add client interactivity with 'use client' where needed
 8- Implement loading and error states
 9- Add Suspense boundaries
10
11### 2. API Route Development
12- Create route handler in app/api/
13- Implement request validation with Zod
14- Add authentication middleware
15- Return proper status codes
16
17### 3. Database Integration
18- Define Prisma schema
19- Generate migrations
20- Implement CRUD operations
21- Add database indexes
22
23### 4. Testing Strategy
24- Component tests with React Testing Library
25- API tests with supertest
26- E2E tests with Playwright
27- Visual regression tests
28
29### 5. Performance Optimization
30- Implement React Server Components
31- Add proper caching headers
32- Optimize images with next/image
33- Use dynamic imports for code splitting

3. Hook Chains for Advanced Automation

Chain multiple hooks for complex workflows:

 1// ~/.claude/hooks/complete-feature-workflow.json
 2{
 3  "hooks": [
 4    {
 5      "eventType": "PreToolUse",
 6      "toolNames": ["Write", "Edit"],
 7      "script": "scripts/backup-files.js"
 8    },
 9    {
10      "eventType": "PostToolUse",
11      "toolNames": ["Write", "Edit"],
12      "script": "scripts/format-code.js"
13    },
14    {
15      "eventType": "PostToolUse",
16      "toolNames": ["Write", "Edit"],
17      "script": "scripts/run-tests.js",
18      "continueOnError": true
19    },
20    {
21      "eventType": "PostToolUse",
22      "toolNames": ["Write", "Edit"],
23      "conditions": {
24        "allTestsPassed": true
25      },
26      "script": "scripts/update-docs.js"
27    }
28  ]
29}

4. Verification Loops for Quality Assurance

Implement continuous validation:

 1# ~/.claude/skills/verification-loop/
 2
 3## Continuous Verification Pattern
 4
 5### Checkpoint Model
 6After each significant change:
 71. Run affected tests
 82. Check type errors
 93. Verify build succeeds
104. Update documentation
11
12### Continuous Evaluation Model
13Before marking task complete:
141. Full test suite passes
152. No TypeScript errors
163. No linting errors
174. Code coverage > 80%
185. Security scan passes
196. Performance benchmarks met
20
21### Grader Configuration
22```yaml
23graders:
24  - type: test
25    command: npm test
26    threshold: 100%
27
28  - type: coverage
29    command: npm run coverage
30    threshold: 80%
31
32  - type: security
33    command: npm audit
34    severity: high
35
36  - type: performance
37    command: npm run benchmark
38    threshold: 95  # 95th percentile < 100ms


## Common Pitfalls and Solutions

### **Pitfall 1: Agent Overload**

**Problem**: Enabling all agents makes Claude Code slow and confused.

**Solution**: Enable only agents you actively use:

```json
// ~/.claude/config.json
{
  "enabledAgents": [
    "tdd-engineer",   // For daily development
    "code-reviewer",  // For PR reviews
    "build-fixer"     // For CI/CD issues
  ],
  "disabledAgents": [
    "architect",      // Use only for major features
    "security-auditor", // Use before releases
    "documentor"      // Use during sprint end
  ]
}

Pro tip: Enable agents on-demand with /agent enable <name>.

Pitfall 2: Conflicting Rules

Problem: Multiple rule files with contradicting guidelines confuse Claude.

Solution: Consolidate and prioritize rules:

 1# ~/.claude/rules/consolidated.md
 2
 3## Rule Priority System
 4
 5### P0: Security (Never Compromise)
 6- Input validation
 7- Authentication/authorization
 8- Secret management
 9
10### P1: Correctness (Rarely Compromise)
11- Type safety
12- Error handling
13- Test coverage
14
15### P2: Style (Compromise for readability)
16- Naming conventions
17- Code formatting
18- Comment style
19
20### P3: Performance (Compromise for clarity)
21- Optimization techniques
22- Caching strategies
23- Algorithm choices
24
25When rules conflict, higher priority wins.

Pitfall 3: Hook Cascades

Problem: Hooks triggering other hooks creates infinite loops.

Solution: Implement circuit breakers:

 1// scripts/run-tests-with-circuit-breaker.js
 2let executionCount = 0;
 3const MAX_EXECUTIONS = 3;
 4
 5export async function hook({ event, context }) {
 6  executionCount++;
 7
 8  if (executionCount > MAX_EXECUTIONS) {
 9    console.log('Circuit breaker activated - too many hook executions');
10    return { skip: true };
11  }
12
13  // Run tests
14  const result = await runTests();
15
16  // Reset counter on success
17  if (result.success) {
18    executionCount = 0;
19  }
20
21  return result;
22}

Pitfall 4: Stale Context Accumulation

Problem: Session context grows unbounded, degrading performance.

Solution: Implement context pruning:

 1// ~/.claude/hooks/on-stop/prune-context.js
 2export async function hook({ sessionData }) {
 3  // Keep only recent context
 4  const maxContextAge = 24 * 60 * 60 * 1000; // 24 hours
 5  const now = Date.now();
 6
 7  sessionData.messages = sessionData.messages.filter(msg =>
 8    (now - msg.timestamp) < maxContextAge
 9  );
10
11  // Compress old decisions into summaries
12  sessionData.decisions = compressDecisions(sessionData.decisions);
13
14  return { updatedSession: sessionData };
15}

Customization Strategies

Strategy 1: Start Minimal, Add Incrementally

Don’t enable everything at once. Follow this adoption path:

Week 1: Core Workflow

1# Enable only:
2- commands/tdd.md
3- rules/security.md
4- rules/testing.md

Week 2: Add Code Quality

1# Add:
2- commands/code-review.md
3- agents/code-reviewer/
4- rules/coding-style.md

Week 3: Add Automation

1# Add:
2- hooks/post-tool-use/run-tests
3- hooks/on-stop/session-summary

Month 2: Advanced Features

1# Add:
2- agents/architect/
3- skills/backend-patterns/
4- verification-loops

Strategy 2: Team-Specific Customization

Create team variations:

 1# Backend team configuration
 2~/.claude/profiles/backend/
 3├── agents/
 4│   ├── api-designer/
 5│   └── database-optimizer/
 6├── skills/
 7│   ├── microservices-patterns/
 8│   └── database-design/
 9└── mcp-configs/
10    ├── supabase.json
11    └── railway.json
12
13# Frontend team configuration
14~/.claude/profiles/frontend/
15├── agents/
16│   ├── component-builder/
17│   └── accessibility-auditor/
18├── skills/
19│   ├── react-patterns/
20│   └── design-system/
21└── mcp-configs/
22    ├── vercel.json
23    └── figma.json

Switch profiles:

1claude code --profile backend

Strategy 3: Project Templates

Create starter templates for different project types:

 1# Create template
 2~/.claude/templates/fullstack-nextjs/
 3├── .claude/
 4│   ├── agents/         # Relevant agents
 5│   ├── skills/         # Stack-specific skills
 6│   ├── rules/          # Project conventions
 7│   └── mcp-config.json # Required MCPs
 8├── .gitignore
 9├── package.json
10└── README.md
11
12# Use template
13claude init --template fullstack-nextjs

Performance Monitoring

Track your productivity gains:

 1# Built-in metrics
 2/stats show
 3
 4# Sample output:
 5Claude Code Statistics (Last 30 Days)
 6======================================
 7Commands Used: 156
 8  /tdd:          45 (29%)
 9  /code-review:  32 (21%)
10  /build-fix:    28 (18%)
11  /plan:         25 (16%)
12  /refactor:     26 (16%)
13
14Agent Delegations: 89
15  tdd-engineer:      38
16  code-reviewer:     28
17  build-fixer:       23
18
19Time Saved (estimated): 42.5 hours
20  Test writing:     15.2h
21  Code review:      12.8h
22  Bug fixing:       14.5h
23
24Context Efficiency:
25  Avg tokens used:  45k / 200k (22.5%)
26  Avg response time: 3.2s
27  Cache hit rate:   67%

Contributing Back to the Repository

The repository welcomes contributions. Here’s how to add value:

 1# 1. Create your agent
 2~/.claude/agents/my-custom-agent/
 3
 4# 2. Test thoroughly
 5claude test-agent my-custom-agent
 6
 7# 3. Document clearly
 8# Add comprehensive README with examples
 9
10# 4. Submit PR
11git clone https://github.com/affaan-m/everything-claude-code.git
12cd everything-claude-code
13git checkout -b agent/my-custom-agent
14# Add your agent to agents/
15git push origin agent/my-custom-agent
16# Create PR with detailed description

2. Report Issues with Context

When reporting bugs:

 1**Issue**: Hook infinite loop with TypeScript watch mode
 2
 3**Environment**:
 4- OS: macOS 14.2
 5- Claude Code version: 1.5.0
 6- Node.js: 20.10.0
 7- Package manager: pnpm 8.15.0
 8
 9**Configuration**:
10```json
11{
12  "hooks": {
13    "post-tool-use": {
14      "enabled": true,
15      "script": "run-tests.js"
16    }
17  }
18}

Steps to Reproduce:

Edit TypeScript file
Hook triggers tsc –watch
Watcher detects changes
Hook triggers again
Infinite loop

Expected: Hook should detect watcher and skip Actual: Infinite loop until manual intervention


### **3. Improve Documentation**

The repository values clear documentation:
- Add more usage examples
- Create video tutorials
- Write troubleshooting guides
- Translate to other languages

## Integration with CI/CD

Extend the patterns to your CI pipeline:

```yaml
# .github/workflows/claude-code-review.yml
name: Claude Code Review

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Claude Code
        run: |
          npm install -g @anthropic/claude-code
          # Copy repository agents/skills
          cp -r .claude-config/* ~/.claude/

      - name: Run Code Review
        run: |
          claude code /code-review --pr ${{ github.event.pull_request.number }}

      - name: Post Review Comments
        uses: actions/github-script@v7
        with:
          script: |
            // Post Claude's findings as PR comments
            const review = require('./claude-review.json');
            github.rest.pulls.createReview({
              owner: context.repo.owner,
              repo: context.repo.repo,
              pull_number: context.issue.number,
              body: review.summary,
              event: 'COMMENT',
              comments: review.findings
            });

Troubleshooting Guide

Problem: “Agent not found” error

 1# Check agent installation
 2ls ~/.claude/agents/
 3
 4# Verify agent configuration
 5cat ~/.claude/agents/tdd-engineer/config.json
 6
 7# Reinstall specific agent
 8claude install-agent tdd-engineer
 9
10# Check Claude Code can find it
11claude list-agents

Problem: Hooks not triggering

 1# Enable hook debugging
 2export CLAUDE_DEBUG_HOOKS=true
 3
 4# Check hook configuration
 5cat ~/.claude/hooks/post-tool-use/run-tests.json
 6
 7# Verify hook script exists and is executable
 8ls -la ~/.claude/scripts/run-tests.js
 9chmod +x ~/.claude/scripts/run-tests.js
10
11# Test hook manually
12node ~/.claude/scripts/run-tests.js

Problem: Context window exceeded

 1# Check current context usage
 2claude /context-stats
 3
 4# Disable unused MCPs
 5claude mcp disable docker kubernetes aws
 6
 7# Clear old context
 8claude /clear-context --keep-session
 9
10# Use project-specific MCP config
11echo '{"mcpServers": {"github": {}}}' > .claude/mcp-config.json

Problem: Slow response times

 1# Profile performance
 2claude --profile
 3
 4# Common causes:
 5# 1. Too many active tools (>80)
 6claude mcp list --count
 7
 8# 2. Large context history
 9claude /context-stats
10
11# 3. Expensive hooks
12claude hooks disable --all
13# Re-enable one by one to find culprit
14
15# 4. Network latency to MCP servers
16claude mcp health-check

Real-World Success Stories

From the repository’s discussions and issues:

Case Study 1: 10x Test Writing Speed

“Before: Writing tests took 40% of development time. After: TDD agent writes comprehensive tests in minutes. Time saved: ~15 hours per week for our team of 5.”
– Frontend Team Lead, Series B Startup

Their Setup:

TDD Engineer agent for all feature work
Custom skill for React Testing Library patterns
Post-edit hook to run affected tests automatically

Case Study 2: Zero Security Incidents

“We had 3 security incidents in 6 months pre-adoption. Zero incidents in 8 months since using Security Auditor. Agent catches issues before code review.”
– CTO, FinTech Company

Their Setup:

Security Auditor agent runs on every PR
Custom rules for PCI DSS compliance
Pre-commit hook blocks commits with HIGH severity issues

Case Study 3: Reduced Code Review Time

“Code reviews took 2-3 hours and still missed issues. Now Claude does first-pass review in 2 minutes. Human reviewers focus on architecture and business logic.”
– Engineering Manager, Enterprise SaaS

Their Setup:

Code Reviewer agent integrated with GitHub Actions
Custom skill encoding company coding standards
Automated comment posting on PRs

Conclusion: From Good to Great

The everything-claude-code repository represents the evolution of Claude Code from a helpful assistant to an indispensable development partner. By encoding workflows, standards, and institutional knowledge into agents, skills, and rules, you create a system that improves with every interaction.

Key Takeaways

Start Minimal: Don’t enable everything at once. Add components as you identify needs.
Context is King: Manage your context window carefully. Fewer than 10 MCPs per project, under 80 total tools.
Customize Relentlessly: The provided agents and skills are starting points. Adapt them to your stack, team, and domain.
Automate Incrementally: Use hooks to automate repetitive tasks, but add circuit breakers to prevent cascades.
Measure Impact: Track time saved and quality improvements to justify continued investment.
Contribute Back: Share your improvements with the community. Your custom agents might solve others’ problems.

Next Steps

Install the repository using your preferred method
Enable TDD workflow for your next feature
Add code review automation to your PR process
Create your first custom agent for domain-specific work
Optimize your MCP configuration for better performance
Share your experience in the repository discussions

The repository is MIT licensed and actively maintained. Whether you’re a solo developer or part of a large engineering organization, these battle-tested patterns can transform your development workflow.

Start with what resonates. Modify for your stack. Remove what you don’t use. Add your own patterns. The goal isn’t to use every feature—it’s to use the right features for your context.

Repository: github.com/affaan-m/everything-claude-code Stars: 22.3k | Forks: 2.7k | License: MIT

Have you customized Claude Code with your own agents or skills? Share your patterns in the comments below or contribute to the repository!

What is Everything Claude Code?

The Core Problem It Solves

Repository Architecture: Five Pillars of Productivity

1. Agents: Your Specialized Development Team

2. Skills: Reusable Workflow Definitions

3. Commands: Quick Workflow Triggers

4. Rules: Always-Enforced Guidelines

5. Hooks: Event-Triggered Automation

Installation: Two Approaches

Option 1: Plugin Marketplace (Recommended)

Option 2: Manual Installation

Post-Installation Configuration

Critical Best Practice: Context Window Management

The Problem

The Solution: Project-Specific MCP Configurations

Context Optimization Guidelines

Practical Example: E-commerce Project

Workflow Patterns: Real-World Usage

Pattern 1: Feature Development with TDD

Pattern 2: Build Error Resolution

Pattern 3: Security Audit

Pattern 4: Comprehensive Refactoring

Advanced Techniques

1. Custom Agent Creation

2. Custom Skills for Your Stack

3. Hook Chains for Advanced Automation

4. Verification Loops for Quality Assurance

Pitfall 2: Conflicting Rules

Pitfall 3: Hook Cascades

Pitfall 4: Stale Context Accumulation

Customization Strategies

Strategy 1: Start Minimal, Add Incrementally

Strategy 2: Team-Specific Customization

Strategy 3: Project Templates

Performance Monitoring

Contributing Back to the Repository

1. Share Your Custom Agents

2. Report Issues with Context

Troubleshooting Guide

Problem: “Agent not found” error

Problem: Hooks not triggering

Problem: Context window exceeded

Problem: Slow response times

Real-World Success Stories

Case Study 1: 10x Test Writing Speed

Case Study 2: Zero Security Incidents

Case Study 3: Reduced Code Review Time

Conclusion: From Good to Great

Key Takeaways

Next Steps

Yen

Related Articles

Building a Centralized Monitoring System with AWS CloudWatch and Grafana using CDK

Express.js Best Practices: Building Production-Ready Node.js Backend Applications

TypeScript Best Practices: A Comprehensive Guide to Type-Safe Development