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

 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

 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

 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

 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

 1{
 2  "hooks": {
 3    "PreToolUse": [
 4      {
 5        "matcher": "Edit|Write",
 6        "hooks": [{ "type": "command", "command": "node scripts/save-context.js" }]
 7      }
 8    ],
 9    "PostToolUse": [
10      {
11        "matcher": "Edit|Write",
12        "hooks": [{ "type": "command", "command": "node scripts/run-tests.js" }]
13      }
14    ],
15    "Stop": [
16      {
17        "hooks": [{ "type": "command", "command": "node scripts/session-summary.js" }]
18      }
19    ]
20  }
21}

1# In Claude Code: register the repository as a plugin marketplace
2/plugin marketplace add affaan-m/everything-claude-code
3
4# Install the plugin from that marketplace (check the repo README for the exact name)
5/plugin install <plugin-name>@<marketplace-name>
6
7# Review what is installed
8/plugin

 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

 1# 1. Keep only what you use: subagents are active if their file is in
 2#    ~/.claude/agents/ (or .claude/agents/), and hooks are the ones listed
 3#    under "hooks" in ~/.claude/settings.json
 4ls ~/.claude/agents/
 5
 6# 2. Set up MCP servers
 7# Edit ~/.claude/mcp-configs/github.json
 8{
 9  "github": {
10    "token": "${GITHUB_TOKEN}",
11    "repo": "your-org/your-repo"
12  }
13}
14
15# 3. Customize rules for your stack
16# Edit ~/.claude/rules/coding-style.md to match your team's standards

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

 1// ~/projects/ecommerce/.mcp.json (JSON itself does not allow comments)
 2{
 3  "mcpServers": {
 4    "github":   { "command": "npx", "args": ["-y", "@modelcontextprotocol/server-github"] },
 5    "supabase": { "command": "npx", "args": ["-y", "@supabase/mcp-server-supabase@latest"] },
 6    "vercel":   { "command": "npx", "args": ["-y", "<vercel-mcp-package>"] }
 7  }
 8}
 9// Payment processing (Stripe) is left out; add it only for the sessions that need it:
10//   claude mcp add stripe -- <command>

 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>"

 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

 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

 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

 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

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

 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

 1{
 2  "hooks": {
 3    "PreToolUse": [
 4      {
 5        "matcher": "Write|Edit",
 6        "hooks": [{ "type": "command", "command": "node scripts/backup-files.js" }]
 7      }
 8    ],
 9    "PostToolUse": [
10      {
11        "matcher": "Write|Edit",
12        "hooks": [
13          { "type": "command", "command": "node scripts/format-code.js" },
14          { "type": "command", "command": "node scripts/run-tests.js" }
15        ]
16      }
17    ]
18  }
19}

 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
39```

1# Subagents are enabled by their presence in ~/.claude/agents/ (or .claude/agents/).
2# Park the ones you only need occasionally:
3mkdir -p ~/.claude/agents-parked
4mv ~/.claude/agents/architect.md ~/.claude/agents/security-auditor.md ~/.claude/agents-parked/
5# Keep tdd-engineer, code-reviewer, build-fixer for daily work

 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.

 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}

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

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

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

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

 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

 1# Create template
 2~/.claude/templates/fullstack-nextjs/
 3├── .claude/
 4│   ├── agents/         # Relevant agents
 5│   ├── skills/         # Stack-specific skills
 6│   ├── rules/          # Project conventions
 7│   └── settings.json   # Permissions and hooks
 8├── .mcp.json           # Required MCPs
 9├── .gitignore
10├── package.json
11└── README.md
12
13# Use template: copy it into the new project
14cp -r ~/.claude/templates/fullstack-nextjs/.claude ~/.claude/templates/fullstack-nextjs/.mcp.json ./

 1# 1. Create your agent
 2~/.claude/agents/my-custom-agent/
 3
 4# 2. Test thoroughly: place it in a test project's .claude/agents/
 5#    and ask Claude to delegate a task to it
 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

 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    "PostToolUse": [
14      {
15        "matcher": "Edit|Write",
16        "hooks": [{ "type": "command", "command": "node run-tests.js" }]
17      }
18    ]
19  }
20}
21```
22
23**Steps to Reproduce**:
241. Edit TypeScript file
252. Hook triggers tsc --watch
263. Watcher detects changes
274. Hook triggers again
285. Infinite loop
29
30**Expected**: Hook should detect watcher and skip
31**Actual**: Infinite loop until manual intervention

 1# .github/workflows/claude-code-review.yml
 2name: Claude Code Review
 3
 4on:
 5  pull_request:
 6    types: [opened, synchronize]
 7
 8jobs:
 9  review:
10    runs-on: ubuntu-latest
11    steps:
12      - uses: actions/checkout@v4
13
14      - name: Setup Claude Code
15        run: |
16          npm install -g @anthropic/claude-code
17          # Copy repository agents/skills
18          cp -r .claude-config/* ~/.claude/          
19
20      - name: Run Code Review
21        run: |
22          claude code /code-review --pr ${{ github.event.pull_request.number }}          
23
24      - name: Post Review Comments
25        uses: actions/github-script@v7
26        with:
27          script: |
28            // Post Claude's findings as PR comments
29            const review = require('./claude-review.json');
30            github.rest.pulls.createReview({
31              owner: context.repo.owner,
32              repo: context.repo.repo,
33              pull_number: context.issue.number,
34              body: review.summary,
35              event: 'COMMENT',
36              comments: review.findings
37            });            

1# Subagents are Markdown files with YAML front matter
2ls ~/.claude/agents/ .claude/agents/
3
4# Check the front matter has a name and description
5head -n 10 .claude/agents/tdd-engineer.md
6
7# Inside Claude Code: list and manage subagents
8/agents

1# Start Claude Code with debug output to see hook execution
2claude --debug
3
4# Inside Claude Code: review the registered hooks
5/hooks
6
7# Verify hook script exists and runs on its own
8ls -la ~/.claude/scripts/run-tests.js
9node ~/.claude/scripts/run-tests.js

 1# Inside Claude Code: see what is using the context
 2/context
 3
 4# Summarise the session, or start fresh for a new task
 5/compact
 6/clear
 7
 8# Remove MCP servers you are not using
 9claude mcp list
10claude mcp remove docker
11
12# Prefer a project-scoped .mcp.json with only the servers this repo needs

1Common causes:
21. Too many active MCP tools: check `claude mcp list` and remove unused servers
32. Large context history: check `/context`, then `/compact` or `/clear`
43. Expensive hooks: review them with `/hooks` and temporarily remove slow ones
54. Slow MCP servers: `/mcp` shows each server's connection status