Transform Claude Code into an intelligent development team with 14+ specialized agent roles using Product Requirement Blueprints (PRBs) for predictable, autonomous execution.
# Install
git clone https://github.com/intelligentcode-ai/intelligent-claude-code.git
cd intelligent-claude-code
make install
# Initialize
/icc-init-system
# Start working with agents
@PM Build a user authentication system
# System: Generates PRB → Creates specialist agents → Agents execute → Work completesComplete virtual development team with 14+ specialized agent roles that work together autonomously. Each agent has deep domain expertise and behavioral patterns optimized for their specialty.
Self-contained blueprints replace complex workflows. Each PRB includes everything needed for single-pass execution: context, standards, examples, validation, and agent coordination.
Core Agents:
- @PM, @Architect, @Developer, @AI-Engineer
- @System-Engineer, @DevOps-Engineer, @Database-Engineer
- @Security-Engineer, @QA-Engineer, @Backend-Tester
- @Requirements-Engineer, @Web-Designer, @User-Role
Dynamic Agent Creation:
- Unlimited specialists for any technology (@React-Developer, @AWS-Engineer, @ML-Specialist)
- Domain experts created automatically based on project needs
- All agents have 10+ years of expertise in their specialization
- Agent execution generates learnings automatically
- Successful patterns captured and shared between agents
- Agents apply previous learnings to new tasks
- Continuous improvement through cross-agent knowledge sharing
- All agent operations check memory before action
- Automatic pattern capture and storage across agent interactions
- Memory pattern application tracking
- Version-controlled in memory/ directory
- Topic-based organization with auto-pruning
- Add methodological approaches to
best-practices/directory - Auto-discovery during PRB generation and agent coordination
- Support for ANY methodology (GitOps, DevSecOps, TDD, Clean Architecture, etc.)
- Template placeholders replaced with your project's practices
- Zero system modification required
- L1: Manual approval required for all agent actions
- L2: Agent coordination with architect approval (default)
- L3: Fully autonomous multi-agent execution
Configure in CLAUDE.md where your docs/standards are. Agents find and include them automatically in PRBs and execution patterns.
- Request Work → "@PM Implement OAuth2 login"
- Agent Activation → @PM analyzes and creates specialist agents as needed
- Memory Check → Agents search for existing patterns/learnings
- Best-Practices Discovery → Agents find relevant methodological approaches
- Analyze Complexity → Agent team scores complexity (@PM + @Architect for Large/Mega)
- Generate PRB → Self-contained blueprint with embedded context + practices + agent coordination
- Agent Execution → Multi-agent collaborative implementation
- Git Integration → Auto version bump + commit + push
- Cross-Agent Learning → Capture new patterns shared across agent memory
Transform natural language stories into executable PRBs with multi-agent coordination:
- Story Creation → Write stories in
stories/directory - @PM Analysis → "@PM break down authentication story"
- Agent Collaboration → @PM + @Architect + domain specialists collaborate
- PRB Generation → Ready-to-execute blueprints with agent assignments in
prbs/ready/ - Agent Execution → Specialized agents execute PRBs collaboratively
- Story Selection → "@PM what story should we work on next?"
stories/
├── user-authentication.md # Business requirements
├── payment-system.md # Feature specifications
└── drafts/ # Work-in-progress stories
└── api-redesign.md
- Story Analysis: @PM reads business goals, specialist agents evaluate technical approaches
- Agent Team Assembly: Dynamic creation of domain specialists (@Auth-Engineer, @Frontend-Developer, etc.)
- Priority Setting: Multi-agent evaluation of business value + technical complexity
- PRB Creation: @PM generates complexity-appropriate PRBs with agent assignments
- Agent Coordination: Collaborative execution across specialized agent team
- Next Selection: Agent team considers dependencies, risk, current application state
<<<<<<< HEAD
# System Initialization
/icc-init-system # Initialize agent system
# Agent Interaction Commands
@PM Build a [project] # Start any project with PM agent coordination
@Architect Design the API # Request architecture design from architect agent
@Developer Implement auth # Assign implementation task to developer agent
@Security-Engineer Review # Request security review from security agent
# Story & PRB Management
@PM break down [story] # Convert story to PRBs with agent assignments
@PM what story next? # Agent-driven story selection with priorities
/icc-create-prb # Generate PRB with agent coordination
# Memory & Learning (Cross-Agent)
/icc-store-memory # Save learnings shared across agents (auto-prunes)
/icc-search-memory # Search agent knowledge base
# Advanced Agent Operations
# Agents automatically create specialists when needed - no manual commands required
=======
## Essential Commands (Lean System)
```bash
/icc-init-system # Initialize virtual team system
/icc-get-setting [key] # Access configuration values
/icc-search-memory [query] # Search stored learnings
>>>>>>> feature/enhance-pm-placeholder-processEverything else is automatic:
- PRB generation happens on work detection
- Specialist creation via <70% capability matching
- Memory storage during PRB execution
- Story management through @PM natural language
Install with automatic MCP server configuration:
# Create MCP configuration
cat > config/mcps.json << 'EOF'
{
"mcpServers": {
"sequential-thinking": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
},
"playwright": {
"command": "npx",
"args": ["-y", "@modelcontextprotocol/server-playwright"]
},
"custom-api": {
"command": "node",
"args": ["/path/to/custom-mcp.js"],
"env": {
"API_KEY": "${OPENAI_API_KEY}",
"DATABASE_URL": "${DB_CONNECTION}"
}
}
}
}
EOF
# Install with MCP integration
make install MCP_CONFIG=./config/mcps.json- Use
${VARIABLE_NAME}placeholders in MCP configurations - Variables resolved from environment or API keys file
- Validation and backup included automatically
- Rollback on failure to previous settings
- JSON Syntax Validation: Comprehensive JSON structure checking
- Backup & Rollback: Automatic settings.json backup before changes
- Permission Handling: Graceful file permission error handling
- Environment Resolution: Safe environment variable substitution
- Detailed Logging: Complete error logs with troubleshooting steps
# Tell system where YOUR files are
prb_configuration:
best_practices_paths:
- "docs/standards/" # Your location
- "engineering/patterns/" # Your location
code_pattern_search:
paths: ["src/", "lib/"] # Your code
behavioral_overrides:
testing_approach: "tdd" # Your preferences
# Memory configuration - where AI agents store learnings
memory_configuration:
external_path: "~/claude-memory" # External memory location
# Or use project-local (default): "./memory/"The AI agents can store their learnings in different locations:
# Memory stored in ./memory/ within your project
# No configuration needed - this is the default# In CLAUDE.md
memory_configuration:
external_path: "~/claude-memory" # Home directory
external_path: "../shared-memory" # Relative to project
external_path: "/path/to/memory" # Absolute pathBenefits of External Memory:
- Privacy: Keep learnings separate from project code
- Sharing: Use same memory across multiple projects
- Git Integration: When
.gitexists in memory path, system auto-commits changes - Flexibility: Store anywhere accessible to the AI agents
your-project/
├── CLAUDE.md # Your config
├── docs/ # Your docs (anywhere)
├── src/ # Your code
├── stories/ # User stories for PRB generation
│ └── drafts/ # Work-in-progress stories
├── memory/ # Version-controlled learnings (default)
└── prbs/ # Version-controlled PRBs
├── ready/ # Ready to execute
└── completed/ # Executed PRBs
Work in YOUR structure - system adapts!
- Documentation Index - Start here!
- Virtual Team Guide - Meet the 14+ agent roles and dynamic specialist creation
- User Guide - Complete agent system usage guide
- Commands Reference - All commands and agent interactions explained
- PRB System Guide - How PRBs work with agent coordination
- Project Configuration - Setup guide for agent-driven projects
- No workflow interruptions - Single-pass multi-agent execution
- Token-optimized - Load only what each agent needs
- Project-adaptive - Agent team respects YOUR structure
- Truly autonomous - Agent specialists have full context and coordination
- Predictable - Same input → Same quality multi-agent output
- Agent collaboration - Cross-specialist knowledge sharing and coordination
MIT - See LICENSE file
Ready for autonomous agent-driven development? Install and let your specialized agent team handle the implementation details.