Everything Claude Code - A Practical Guide#

A guide to the everything-claude-code repository, a comprehensive toolkit for getting the most out of Claude Code. This collection comes from an Anthropic hackathon winner with 10+ months of intensive daily use.

Quick Overview#

The repo is organized into these main components:

Installation#

Option 1: Claude Code Plugin (Recommended)#

Option 2: Manual Installation#

Commands (31 Available)#

Commands are slash-shortcuts that trigger specific workflows. They live in ~/.claude/commands/.

Most Useful Commands#

/plan - Planning & Architecture#

Use before starting any significant feature. Analyzes requirements and creates step-by-step implementation plans.

/tdd - Test-Driven Development#

Enforces the RED → GREEN → REFACTOR cycle. Never writes implementation before tests.

The TDD cycle:

1. Scaffold interfaces
2. Write failing tests
3. Verify tests fail for the right reasons
4. Implement minimally to pass
5. Confirm tests pass
6. Refactor while keeping tests green
7. Re-verify
8. Check coverage (80% minimum)

/code-review - Code Review#

Analyzes code for issues, security concerns, and improvements.

/refactor-clean - Refactoring#

Clean up and refactor code while maintaining functionality.

/e2e - End-to-End Testing#

Set up and run E2E tests with proper patterns.

/build-fix - Build Error Resolution#

Systematically diagnose and fix build failures.

Multi-Agent Commands#

These orchestrate multiple specialized agents working together:

• /multi-plan - Coordinate planning across multiple services
• /multi-execute - Execute tasks across multiple codebases
• /multi-backend - Backend-specific multi-agent coordination
• /multi-frontend - Frontend-specific multi-agent coordination
• /orchestrate - General task orchestration

Utility Commands#

• /checkpoint - Save current state
• /sessions - Manage sessions
• /verify - Verification processes
• /test-coverage - Check test coverage
• /update-docs - Update documentation
• /update-codemaps - Refresh code maps

Agents (13 Specialists)#

Agents are specialized subagents that handle focused tasks. They run in isolated contexts, preserving the main agent's context window.

When to Use Subagents#

Use subagents when:

• You need focused expertise (security review, architecture)
• The task would consume too much context
• You want parallel execution of independent tasks

Available Agents#

Example: Using the Planner Agent#

The planner will:

1. Analyze requirements
2. Review existing architecture
3. Create phased implementation steps
4. Identify risks and testing strategies

Skills (29 Workflows)#

Skills are detailed workflow definitions with domain knowledge. They tell Claude how to do things (vs rules which say what to do).

Core Skills#

tdd-workflow#

Complete TDD methodology including when to write tests, coverage targets, and anti-patterns to avoid.

coding-standards#

General code quality guidelines - file sizes, error handling, validation patterns.

verification-loop#

Ensures code meets requirements through systematic verification.

continuous-learning#

System for Claude to learn from patterns and improve over time.

Framework-Specific Skills#

TypeScript/JavaScript:

• frontend-patterns - React, Next.js patterns
• backend-patterns - Node.js, API patterns

Python:

• python-patterns - Pythonic code patterns
• python-testing - pytest, testing strategies
• django-patterns - Django-specific patterns
• django-tdd - TDD with Django
• django-security - Django security

Go:

• golang-patterns - Idiomatic Go
• golang-testing - Go testing patterns

Java:

• java-coding-standards - Java conventions
• springboot-patterns - Spring Boot patterns
• springboot-tdd - TDD with Spring
• springboot-security - Spring security
• jpa-patterns - JPA/Hibernate patterns

Database:

• postgres-patterns - PostgreSQL best practices
• clickhouse-io - ClickHouse analytics

Using Skills#

Skills are typically activated automatically based on context, but you can explicitly request them:

Rules#

Rules are always-follow guidelines that Claude checks automatically. They're organized by scope:

Common Rules Include#

Coding Style:

• Keep files 200-400 lines (max 800)
• Prefer immutability
• Validate all inputs
• No console.log in production

Git Workflow:

• Use conventional commits
• Require PR reviews
• Branch naming conventions

Testing:

• 80% minimum coverage
• 100% for critical paths (auth, security, payments)
• Write tests before implementation

Security:

• No hardcoded credentials
• Use environment variables
• Parameterized queries
• CSRF protection

Hooks#

Hooks automate actions based on triggers. They're defined in ~/.claude/hooks/hooks.json.

Available Triggers#

Example Hooks#

Remind to use tmux for long commands:

Auto-format TypeScript on edit:

Block random markdown creation:

Review reminder before git push:

Contexts#

Contexts inject different system prompts for different modes of work.

Available Contexts#

Switch contexts by referencing them:

MCP Configs#

Pre-configured integrations for external services. Edit credentials in ~/.claude/mcp-configs/mcp-servers.json.

Available Integrations#

Development:

• GitHub - PRs, issues, repos (requires PAT)
• Supabase - Database operations
• Vercel - Deployments
• Railway - Railway deployments

Utilities:

• Memory - Persistent memory across sessions
• Sequential Thinking - Chain-of-thought reasoning
• Filesystem - Local file operations
• Firecrawl - Web scraping

Documentation:

• Context7 - Live docs lookup
• Cloudflare Docs - CF documentation search

Analytics:

• ClickHouse - Analytics queries

Performance Note#

"Your 200k context window might only be 70k with too many tools enabled."

Recommendation: Keep 20-30 MCPs configured but enable fewer than 10 simultaneously.

Example CLAUDE.md Structure#

The repo includes an example project CLAUDE.md you can adapt:

Quick Reference#

Daily Workflow Commands#

When to Use What#

Tips from the Author#

1. Don't over-engineer your config - Treat it as fine-tuning, not architecture
2. Context window management - Keep MCPs under 10 active at once
3. Use tmux - For long-running commands and log persistence
4. TDD is non-negotiable - "Never skip the RED phase"
5. Subagents for focus - Delegate specialized tasks to preserve main context

Resources#

• Repository
• The Shortform Guide
• The Longform Guide
• Example CLAUDE.md