🚀 Claude Code: Comprehensive AI Agent System for Developers

Enhance your development workflow with specialized AI agents that help deliver quality code through orchestration, resilience engineering, and organizational memory.

🌟 Why Claude Code Agents Can Improve Your Development

⚡ Specialized Expertise Across Technologies

Reduce context switching between documentation, Stack Overflow, and your IDE. Get access to specialized agents covering major frameworks, languages, and domains.

# Instead of spending hours researching...
claude "Build a resilient authentication system with circuit breakers and structured logging"
# → @rails-expert + @resilience-engineer + @security-specialist work in perfect coordination

🧠 AI System with Organizational Memory

These agents can remember and learn from projects when configured with Basic Memory MCP, helping build institutional knowledge over time.

• Pattern Reuse: "Use patterns from previous authentication implementations"
• Context Building: "Reference similar microservice architectures we've built"
• Knowledge Evolution: "Update our React component patterns based on this success"

🎭 Agent Orchestration System

The system includes coordination features that can help with agent selection and workflow management for complex tasks.

# Just describe what you want - the system handles everything automatically:
claude "Build an e-commerce platform"
# → Vibe Coding Coordinator: 15-20 minute preparation phase, analyzes requirements
# → Exponential Planner: Strategic planning with capability scaling awareness
# → Parallel Coordinator: Coordinates (@react-expert + @rails-expert + @payment-specialist + @security-specialist)
# → Session Manager: Maintains context across extended development sessions
# → Safety Specialists: Pre-deployment validation and architectural analysis

🚀 IMPORTANT: Bootstrap Required ⚠️

⚡ ONE-TIME SETUP: Every project needs bootstrapping before using Claude 007 Agents!

# After installing agents, bootstrap each project once:
claude "Use @bootstrap-orchestrator to analyze and setup this project"

Why Bootstrap?

• 🔍 Analyzes your tech stack and selects optimal agents
• ⚙️ Creates proper CLAUDE.md configuration with commit attribution
• 🎯 Sets up project-specific agent selection and workflows
• 📋 Configures Task Master integration for codebase-aware development
• ✅ Validates complete system readiness

Skip this step and agents won't work properly in your project!

🚀 Key Features

1. 🏗️ Engineering Excellence by Design

Every agent prioritizes production-grade quality:

• ⚡ Fault Tolerance: Circuit breakers, retry mechanisms, graceful degradation
• 📊 Structured Logging: JSON logging with contextual information
• 🔄 Self-Healing: Automatic recovery patterns
• 🛡️ Automated Quality: Trunk.io integration for linting and security

2. 🤖 Advanced Orchestration System

Built on insights from Anthropic's "Code with Claude" conference:

• Vibe Coding Coordinator: 15-20 minute preparation phases for autonomous development
• Exponential Planner: Strategic planning with AI capability doubling awareness (7-month cycles)
• Session Manager: Resumable workflows with context preservation across extended sessions
• Parallel Coordinator: Multi-agent execution with coordinated tool calling
• Safety Specialists: Pre-deployment testing, architectural analysis, and risk management
• Sequential Thinking: Complex multi-step reasoning with adaptive planning and course correction

3. 🚀 Task Master Integration ⭐ NEW

Revolutionary codebase-aware autonomous development ecosystem:

• Codebase-Aware Intelligence: Tasks generated with deep understanding of existing code architecture and patterns
• Bridge Agent Architecture: 5 specialized Task Master agents seamlessly integrated with Claude 007's 112 agents
• Multi-Model AI Configuration: Support for Claude, Gemini, Perplexity, OpenAI, and more
• Template Intelligence: Smart generation of MCP configs, environment files, and PRD templates
• Autonomous Development: 30-40% development time reduction with quality assurance

4. 🎯 Live MCP Integrations

Direct access to live systems and real-time data:

• GitHub MCP: Live repository operations and PR management
• Task Master MCP: Project management with complexity analysis and codebase awareness
• Context7 MCP: Up-to-date library documentation
• Basic Memory MCP: Persistent organizational knowledge
• Sequential Thinking MCP: Complex reasoning with adaptive planning and course correction

5. 📋 Professional-Grade Workflows

• Vibe Coding: 15-20 minute autonomous development preparation phases
• Parallel Execution: Coordinated multi-agent development with tool call batching
• Exponential Planning: Long-term development planning with AI capability scaling awareness
• Sequential Reasoning: Multi-step problem analysis with adaptive strategy revision
• Safety Validation: Pre-deployment testing and architectural safety analysis
• Dynamic Permissions: Real-time permission management with risk-based escalation
• Automatic Commit Attribution: Every commit traces back to contributing agents
• Quality Gates: Pre-commit hooks with comprehensive linting

6. 🧠 Organizational Intelligence

• Cross-Project Learning: Patterns and knowledge shared across all projects
• Decision History: Track architectural decisions and their outcomes
• Performance Analytics: Agent effectiveness measurement and optimization
• Knowledge Graphs: Dynamic project understanding with real-time updates

🎯 Perfect For

⚡ Get Started in 60 Seconds

🚀 BOOTSTRAP FIRST: One-Time Project Setup ⭐

IMPORTANT: You must bootstrap the agent system once for every new repo/project before using Claude 007 Agents.

# 1. Clone the system
git clone https://github.com/avivl/claude-007-agents.git
cd claude-007-agents

# 2. Copy to your project (any project)
cp -r .claude/agents /path/to/your/project/.claude/
cp agents.json /path/to/your/project/

# 3. BOOTSTRAP your project (REQUIRED - once per project)
cd /path/to/your/project
claude "Use @bootstrap-orchestrator to analyze and setup this project"

# 4. Start development immediately
claude "Use @software-engineering-expert to begin development"

What Bootstrap Does:

• 🔍 Analyzes your codebase (tech stack, architecture, complexity)
• 🎯 Selects optimal agents based on your technology stack
• ⚙️ Creates CLAUDE.md with proper agent configuration and commit attribution
• 📋 Sets up Task Master integration (if desired)
• 🔗 Configures MCP servers for enhanced capabilities
• ✅ Validates complete system readiness

Bootstrap Works With:

• ✅ New projects (empty directories) → Full system initialization
• ✅ Existing projects without Claude → Intelligent integration
• ✅ Projects with existing CLAUDE.md → Enhancement and upgrade
• ✅ Partial setups → Completion of missing components

Prerequisites & Installation

Required Software:

# Essential: Claude Code CLI (required)
# Visit: https://docs.anthropic.com/en/docs/claude-code

# Essential: Node.js for bootstrap system and advanced features
node --version  # v18+ REQUIRED for bootstrap engine and Task Master integration
npm --version   # npm v6+ required for package management

Required Packages (for enhanced features):

# Task Master integration (for codebase-aware development)
npm install -g task-master-ai

# Basic Memory MCP (for organizational learning)
npm install -g @modelcontextprotocol/server-memory

# Context7 MCP (for live documentation)
npm install -g @upstash/context7-mcp

# Bootstrap System Dependencies (automatically handled)
# These are included when you clone the repo - no separate installation needed

Environment Setup:

# API keys (add to your ~/.bashrc or ~/.zshrc)
export ANTHROPIC_API_KEY="your_anthropic_key_here"
export PERPLEXITY_API_KEY="your_perplexity_key_here"  # For research features
export OPENAI_API_KEY="your_openai_key_here"         # Optional
export GOOGLE_API_KEY="your_gemini_key_here"         # Optional (for Zen MCP)

# Or create .env file in your project directory
echo "ANTHROPIC_API_KEY=your_key_here" > .env
echo "PERPLEXITY_API_KEY=your_key_here" >> .env

Alternative: Standard Claude Code Installation

# Install to standard Claude Code directory (most common)
git clone https://github.com/avivl/claude-007-agents.git
cd claude-007-agents

# Option A: Copy files (simple)
cp -r .claude/agents/* ~/.claude/agents/
cp agents.json ~/.claude/agents/

# Option B: Create symbolic links (recommended - stays updated)
ln -sf "$(pwd)/.claude/agents"/* ~/.claude/agents/
ln -sf "$(pwd)/agents.json" ~/.claude/agents/

# Now you can use all agents globally
claude "Use @code-archaeologist-time-traveler to analyze git history"

🚀 NEW: Intelligent Bootstrap System ⭐

Universal deployment that works with ANY project - automatically detects and configures optimal agent setup!

# Command-line bootstrap (after cloning repo)
node src/bootstrap/bootstrap-engine.js /path/to/any/project

# Or use via package.json command
npm run bootstrap /path/to/your/project

# Or use directly in Claude Code (RECOMMENDED)
claude "Use @bootstrap-orchestrator to analyze and setup this project"

# Advanced options
node src/bootstrap/bootstrap-engine.js --setupMCP=true --setupTaskMaster=true /path/to/project

What the Bootstrap System Does:

• 🔍 Analyzes your codebase (tech stack, architecture, complexity)
• 🎯 Selects optimal agents based on your technology stack and project scenario
• ⚙️ Creates configuration files (CLAUDE.md with commit attribution requirements)
• 📋 Sets up Task Master with codebase-aware features (if requested)
• 🔗 Configures MCP servers (optional - respects global MCP configuration)
• ✅ Validates complete system readiness with comprehensive checks
• 📖 Generates next steps tailored to your specific project scenario

Works with ANY project scenario:

• 🆕 New/Empty Projects → Complete system initialization with scaffolding
• 🏗️ Existing Projects (No Claude) → Intelligent integration without disruption
• 🔧 Projects with Claude Setup → Enhancement and upgrade of existing configuration
• 🔄 Partial Setups → Completion of missing components and validation
• ✅ React/Next.js → Gets @react-expert, @nextjs-expert, @typescript-cockatiel-resilience
• ✅ Node.js APIs → Gets @nodejs-expert, @fastify-expert, @typescript-pino-logging
• ✅ Python/Django → Gets @django-expert, @python-hyx-resilience, @fastapi-expert
• ✅ Go Applications → Gets @gin-expert, @go-zap-logging, @go-resilience-engineer
• ✅ Ruby/Rails → Gets @rails-expert, @rails-api-developer
• ✅ Any Stack → Gets @software-engineering-expert + optimal tech-specific agents

Global Installation (Power Users)

# Install once, use everywhere
mkdir -p ~/.local/share/claude-agents
cp -r .claude/agents ~/.local/share/claude-agents/

# Copy agents.json for agent registration (IMPORTANT!)
cp agents.json ~/.local/share/claude-agents/agents/

# Configure Claude Code globally
cat > ~/.claude/config.json << 'EOF'
{
  "agents": {
    "globalPath": "~/.local/share/claude-agents/agents",
    "fallbackToLocal": true
  }
}
EOF

🎨 Advanced Agent Capabilities

After installation, you can use these specialized agents:

# Task Master - Revolutionary codebase-aware autonomous development ⭐ NEW
claude "Use @task-master-initialization-specialist to set up Task Master for my Rails project"
# → Analyzes codebase patterns, detects Rails stack, configures Claude + Perplexity models
# → Generates MCP config, environment templates, codebase-aware PRD template

claude "Use @task-orchestrator to coordinate user dashboard feature development"
# → Analyzes codebase dependencies, coordinates @react-expert + @rails-expert + @security-specialist
# → Ensures architectural alignment with existing patterns and conventions

claude "Use @task-executor to implement payment integration respecting existing patterns"
# → Implements with deep contextual awareness of existing code architecture
# → Follows established conventions, integrates with existing utilities and services

claude "Use @task-checker to verify authentication system implementation"
# → Validates requirements, runs tests, checks architectural alignment
# → Ensures pattern consistency and quality excellence before marking complete

# Vibe Coding - Autonomous development with preparation phases
claude "Use @vibe-coding-coordinator to implement user authentication system"

# Parallel Development - Coordinated multi-agent execution
claude "Use @parallel-coordinator to build full-stack e-commerce platform"

# Template Management - Smart configuration generation
claude "Use @task-master-template-manager to generate Django API project templates"
# → Creates tech stack-specific MCP configs, environment files, PRD templates
# → Includes Django-optimized settings and API-focused requirements

# Creative Problem Solving
claude "Use @rubber-duck-debugger to help me debug this complex state management issue"
claude "Use @code-archaeologist-time-traveler to analyze the evolution of this authentication module"

🦆 Demo:

🎉 That's it! Your agents are ready to assist with your development workflow.

🏆 What Makes This Different

Before: Traditional Development

• ❌ Hours researching best practices
• ❌ Inconsistent code quality across team
• ❌ Manual code reviews with human bias
• ❌ Lost context between projects
• ❌ Repeated architectural mistakes

After: Claude Code Agents

• ✅ Specialized assistance in various domains
• ✅ Quality tooling with linting integration
• ✅ AI-assisted reviews with multi-dimensional analysis
• ✅ Optional organizational memory with MCP
• ✅ Agent coordination for complex tasks

🌍 Supported Technologies

🎯 Bootstrap System Examples

Real-World Bootstrap Scenarios

Scenario 1: External React Project

# Developer inherits existing React project with no Claude Code setup
cd /path/to/existing-react-app

# Bootstrap analyzes and sets up complete intelligent development environment
claude "Use @bootstrap-orchestrator to analyze and setup this project"
# 🔍 Phase 1: Detects React + Node.js stack, existing complexity level 6/10
# 🎯 Phase 2: Selects @react-expert, @nodejs-expert, @typescript-cockatiel-resilience, @test-automation-expert
# 🚀 Phase 3: Creates CLAUDE.md with React-optimized configuration and commit attribution
# 🧪 Phase 4: Validates system readiness, provides React-specific next steps

# Start using immediately - agents are already configured
claude "Use @react-expert to analyze this component architecture"

Scenario 2: Enterprise Django Project

# Enterprise team wants comprehensive setup for Django project
cd /path/to/django-enterprise-app

# Bootstrap detects enterprise complexity and configures accordingly
claude "Use @bootstrap-orchestrator to analyze and setup this project"
# 🔍 Phase 1: Detects Django + Python stack, high complexity (8/10), enterprise scenario
# 🎯 Phase 2: Selects @django-expert, @security-specialist, @database-architect, @performance-optimizer
# 🚀 Phase 3: Creates enterprise-grade CLAUDE.md with commit attribution and security requirements
# 🧪 Phase 4: Validates system, recommends Task Master initialization for project management

# Immediate productivity boost with proper agent coordination
claude "Use @django-expert to review our ORM patterns and suggest optimizations"
claude "Use @security-specialist to audit authentication implementation"

Scenario 3: Open Source Go Project

# Open source Go project wants contributor-friendly setup
cd /path/to/go-opensource-project

# Bootstrap detects open source scenario and optimizes for contributors
claude "Use @bootstrap-orchestrator to analyze and setup this project"
# 🔍 Phase 1: Detects Go stack, moderate complexity (5/10), open source patterns
# 🎯 Phase 2: Selects @gin-expert, @go-zap-logging, @go-resilience-engineer, @test-automation-expert
# 🚀 Phase 3: Creates contributor-friendly CLAUDE.md with clear commit attribution rules
# 🧪 Phase 4: Validates setup, provides Go-specific development guidelines

# Contributors can immediately use intelligent assistance
claude "Use @gin-expert to explain this middleware pattern"
claude "Use @code-reviewer to check this PR before submitting"

Scenario 4: Full-Stack Next.js + Python API

# Complex full-stack project with multiple technologies
cd /path/to/fullstack-project

# Bootstrap intelligently detects and configures multi-stack setup
claude "Use @bootstrap-orchestrator to analyze and setup this project"
# 🔍 Phase 1: Detects Next.js frontend + FastAPI backend, high complexity (7/10)
# 🎯 Phase 2: Selects @nextjs-expert, @react-expert, @fastapi-expert, @database-architect, @api-architect
# 🚀 Phase 3: Creates full-stack CLAUDE.md with coordinated commit attribution for both stacks
# 🧪 Phase 4: Validates cross-stack compatibility, recommends parallel development workflows

# Coordinated full-stack development with proper orchestration
claude "Use @vibe-coding-coordinator to coordinate full-stack user authentication implementation"
claude "Use @parallel-coordinator to orchestrate @nextjs-expert and @fastapi-expert for API integration"

Bootstrap Scenarios Explained

New Project Scenario (Empty/New Directories)

• 🔍 Detection: Empty directory or minimal project structure
• 🎯 Configuration: Complete system initialization with project scaffolding
• ⚙️ Setup: Creates CLAUDE.md, basic project files, git initialization
• 📋 Task Master: Full integration with enhanced capabilities
• ✅ Result: Ready-to-develop project with complete Claude 007 ecosystem

Existing Project (No Claude) (Most Common)

• 🔍 Detection: Existing codebase without Claude Code setup
• 🎯 Configuration: Intelligent integration based on tech stack analysis
• ⚙️ Setup: Non-disruptive CLAUDE.md creation with optimal agents
• 📋 Task Master: Optional integration based on project complexity
• ✅ Result: Enhanced existing project with AI development assistance

Existing Claude Setup (Enhancement Mode)

• 🔍 Detection: Existing CLAUDE.md or .claude directory found
• 🎯 Configuration: Enhancement and upgrade of current setup
• ⚙️ Setup: Merges with existing configuration, adds missing components
• 📋 Task Master: Upgrades to codebase-aware intelligence
• ✅ Result: Enhanced existing setup with latest Claude 007 features

Partial Setup (Completion Mode)

• 🔍 Detection: Incomplete Claude Code configuration detected
• 🎯 Configuration: Completes missing components and validates system
• ⚙️ Setup: Fills gaps in agent configuration, fixes broken setups
• 📋 Task Master: Adds if missing, validates if present
• ✅ Result: Complete, validated, and operational Claude 007 system

Advanced Bootstrap Options

Command-Line Bootstrap Options

# Setup MCP servers explicitly (respects global Claude MCP config by default)
node src/bootstrap/bootstrap-engine.js --setupMCP=true /path/to/project

# Skip Task Master integration
node src/bootstrap/bootstrap-engine.js --setupTaskMaster=false /path/to/project

# Dry run to see what would be configured
node src/bootstrap/bootstrap-engine.js --dryRun=true /path/to/project

Via Claude Code (Recommended)

# Standard bootstrap (auto-detects optimal configuration)
claude "Use @bootstrap-orchestrator to analyze and setup this project"

# Request specific features
claude "Use @bootstrap-orchestrator with Task Master integration for this Django project"
claude "Use @bootstrap-orchestrator to upgrade my existing Claude setup"

Multiple Projects Bootstrap

# Bootstrap multiple projects efficiently
for project in ~/projects/*/; do
  echo "Bootstrapping $project"
  cd "$project"
  claude "Use @bootstrap-orchestrator to analyze and setup this project"
done

Integration with Existing Tools

Works with your existing workflow:

• ✅ Git repositories - Respects .gitignore, creates appropriate commits
• ✅ VS Code/Cursor - Compatible with existing settings
• ✅ Package managers - npm, pip, go mod, cargo, etc.
• ✅ CI/CD pipelines - Integrates with existing automation
• ✅ Docker projects - Detects containerized applications
• ✅ Monorepos - Handles complex project structures

No conflicts with existing tools:

• 🔒 Only creates files in .claude/, .taskmaster/, and root config files
• 🔄 Never modifies existing source code or configurations
• 📦 Installs as optional enhancement, not replacement
• 🚫 No breaking changes to existing development workflow

📊 System Overview

🎯 Potential Benefits

Getting Started

# Task Master - Codebase-aware autonomous development ⭐ NEW
claude "Use @task-master-initialization-specialist to set up Task Master for my Rails API project"
# → Analyzes existing codebase patterns and architecture
# → Detects Rails tech stack and configures optimal models (Claude, Perplexity)
# → Generates MCP configuration and environment templates
# → Creates codebase-aware PRD template aligned with existing patterns

claude "Use @task-orchestrator to coordinate development of user dashboard feature"
# → @task-orchestrator: Analyzes codebase dependencies and architectural alignment
# → Coordinates @react-expert + @rails-expert + @security-specialist with existing patterns
# → @task-executor: Implements features respecting established conventions
# → @task-checker: Validates architectural alignment and quality standards

# Sequential Thinking - Complex multi-step reasoning with adaptive planning
claude "Use @orchestrator to design a scalable microservices architecture"
# → Sequential reasoning: analyze requirements → evaluate patterns → revise strategy → finalize architecture
# → Adaptive planning with course correction based on discovered constraints

# Vibe Coding - Autonomous development with preparation
claude "Create a user authentication API with rate limiting and structured logging"
# → @vibe-coding-coordinator: 15-20 minute preparation phase
# → @parallel-coordinator: Coordinates @security-specialist + @api-architect + @performance-optimizer
# → @session-manager: Maintains context across implementation phases
# → Results in production-ready implementation with proper patterns and safety validation

Over Time

• Task Master Intelligence: Codebase-aware task generation becomes increasingly precise as it learns your architecture patterns
• Multi-Model Optimization: AI model selection automatically adapts based on task complexity and success patterns
• Template Evolution: Configuration templates become project-specific and increasingly sophisticated
• Agents can learn project-specific patterns with proper MCP configuration
• Quality gates can be customized to project requirements
• Organizational knowledge can accumulate with Basic Memory MCP

Long Term

• Architectural Consistency: Task Master ensures all new development respects established patterns and conventions
• Development Time Reduction: 30-40% time savings compound as codebase understanding deepens
• Quality Compound Effect: Continuous architectural alignment prevents technical debt accumulation
• Historical patterns can inform future projects
• Context-aware suggestions may improve decision-making
• Team knowledge can be preserved across projects

📚 Documentation & Resources

🤝 Community & Support

• ❓ Common Questions: FAQ - Performance, setup, and usage questions
• 🐛 Bug Reports: GitHub Issues
• 💡 Feature Requests: GitHub Discussions
• 📖 Documentation: docs/

📄 License

MIT License - Use freely in personal and commercial projects.

Keywords for SEO

Claude Code agents, AI development tools, automated code review, software engineering best practices, development automation, AI pair programming, code quality tools, development workflow optimization, intelligent code generation, automated testing, software architecture patterns, development team coordination, technical debt reduction, enterprise development tools, developer productivity tools