/initialize

Add Orchestre orchestration capabilities to existing projects without disrupting current workflows or code.

Overview

• Purpose: Enhance existing projects with AI orchestration
• Category: Core Orchestration
• Type: Dynamic prompt
• MCP Tool: install_commands

Syntax

/initialize [project-path]

Parameters

Parameter	Required	Description	Default
project-path	No	Path to existing project	Current directory (.)

Usage Examples

Basic Usage

# Initialize in current directory
/initialize

# Initialize specific project
/initialize ../my-existing-app

# Initialize with absolute path
/initialize /Users/me/projects/legacy-app

Common Scenarios

# Existing Next.js app
cd my-nextjs-app
/initialize

# Legacy API project
/initialize ./backend-api

# Monorepo workspace
cd packages/web-app
/initialize

How It Works

Phase 1: Discovery

The prompt explores your project:

1. Technology Detection - Identifies stack from config files
2. Structure Analysis - Maps directory organization
3. Pattern Recognition - Finds coding conventions
4. Workflow Discovery - Detects existing processes

Phase 2: Analysis

Evaluates integration approach:

1. Value Assessment - Where Orchestre adds most benefit
2. Compatibility Check - Ensures no conflicts
3. Command Selection - Picks relevant commands
4. Integration Planning - Maps enhancement strategy

Phase 3: Installation

Non-destructive setup:

1. Prompt Configuration - Creates .orchestre/prompts.json
2. Memory Structure - Creates initial CLAUDE.md
3. Preservation - Keeps all existing files intact
4. Documentation - Records what was added

Phase 4: Guidance

Provides next steps:

1. Quick Wins - Immediate value commands
2. Usage Examples - Tailored to your project
3. Best Practices - Integration guidelines
4. Success Metrics - How to measure improvement

Output

🔍 Analyzing existing project...
📊 Detected: Next.js 14 application with TypeScript
📁 Structure: App Router, Tailwind CSS, Prisma ORM
🎯 Patterns: Feature-based organization, custom hooks

✅ Installing Orchestre commands...
📚 Created: .orchestre/prompts.json (20 prompts)
📖 Initialized: CLAUDE.md with project context
🔧 Updated: .gitignore (added .orchestre/)

🎯 Recommended first commands:
- /discover-context src/components
- /orchestrate "Your next feature"
- /review "Recent changes"
- /performance-check

💡 Quick win: Run /discover-context on your core module

Project Types

Web Applications

For Next.js, React, Vue, Angular projects:

/initialize
# Adds focus on:
# - Component architecture
# - State management
# - API integration
# - Performance optimization

API Services

For Express, Fastify, NestJS projects:

/initialize
# Adds focus on:
# - Endpoint validation
# - Security patterns
# - Database operations
# - Error handling

Mobile Applications

For React Native, Flutter projects:

/initialize
# Adds focus on:
# - Screen navigation
# - Native modules
# - Offline capability
# - Platform differences

Libraries/Packages

For npm packages, utilities:

/initialize
# Adds focus on:
# - API design
# - Documentation
# - Testing coverage
# - Version management

Monorepos

For Lerna, Nx, Turborepo projects:

/initialize
# Adds focus on:
# - Package coordination
# - Shared dependencies
# - Cross-package testing
# - Parallel development

Memory Structure

Root CLAUDE.md

Created at project root:

# [Project Name]

## Project Overview
[Discovered purpose and description]

## Existing Architecture
- **Type**: [Web app/API/Library/etc]
- **Stack**: [Technologies found]
- **Structure**: [Organization pattern]
- **Patterns**: [Conventions observed]

## Orchestre Integration
- **Added**: [Date]
- **Purpose**: Enhance with AI orchestration
- **Preserves**: All existing code and patterns
- **Adds**: Intelligent planning and execution

## Key Areas for Enhancement
1. [Area]: How Orchestre helps
2. [Area]: Potential improvements
3. [Area]: Automation opportunities

## Development Workflow
- Continue using existing tools
- Enhance with Orchestre commands
- Maintain compatibility

Feature CLAUDE.md Files

Created as you work:

# Feature: [Name]

## Context
[How this fits in the project]

## Patterns
[Existing patterns to follow]

## Enhancements
[How Orchestre improved this]

Best Practices

Prompt Adaptation

This prompt dynamically adapts based on:

Context Discovery

• Analyzes current project state and structure
• Discovers existing patterns and conventions
• Understands team workflows and preferences
• Adapts to technology stack and architecture

Intelligence Patterns

• Learns from previous executions in the project
• Adapts complexity based on team expertise
• Prioritizes based on project phase
• Suggests optimizations from accumulated knowledge

Memory Integration

This prompt actively uses and updates distributed memory:

Reads From

• CLAUDE.md - Project context and conventions
• .orchestre/ - Orchestration state and patterns
• Feature-specific CLAUDE.md files
• Previous execution results

Updates

• Relevant CLAUDE.md files with new insights
• .orchestre/ with execution patterns
• Documentation as part of the workflow
• Pattern library with successful approaches

1. Respect Existing Code

# Good: Discover before changing
/initialize
/discover-context src/
/orchestrate "Add new feature following patterns"

# Poor: Jump to changes
/initialize
/execute-task "Refactor everything"

2. Gradual Adoption

Start small and expand:

1. Initialize project
2. Run discovery commands
3. Try one feature with Orchestre
4. Measure improvement
5. Expand usage

3. Preserve Workflows

# Keep existing scripts
npm run dev        # Still works
npm run test       # Still works
npm run build      # Still works

# Add Orchestre for enhancement
/review            # Before PR
/performance-check # Optimization
/security-audit    # Security review

4. Document Integration

Update your README:

## Development

This project uses Orchestre for enhanced development:
- `/orchestrate` - Plan new features
- `/review` - Multi-perspective code review
- `/performance-check` - Find optimizations

Traditional commands still work:
- `npm run dev` - Start development
- `npm test` - Run tests

Common Patterns

Legacy Modernization

/initialize
/discover-context "legacy modules"
/extract-patterns
/orchestrate "Gradual modernization plan"

Team Onboarding

/initialize
/document-feature "Authentication system"
/document-feature "API architecture"
/learn "Development patterns"

Performance Improvement

/initialize
/performance-check
/orchestrate "Optimize based on findings"
/validate-implementation

Security Hardening

/initialize
/security-audit
/orchestrate "Fix security issues"
/review "Security fixes"

Error Handling

Common Issues

Issue	Cause	Solution
Not a project directory	No package.json, etc.	Navigate to project root
Commands already exist	Previous installation	Use without overwrite
Permission denied	Directory permissions	Check write access
Unknown project type	Uncommon structure	Proceeds with core commands

Conflict Resolution

When .orchestre/prompts.json exists:

• Preserves existing commands
• Adds only missing ones
• Reports what was skipped
• Suggests manual review

Advanced Usage

Selective Enhancement

Focus on specific areas:

# Just the API layer
cd src/api
/initialize .

# Just the frontend
cd src/frontend
/initialize .

Custom Integration

After initialization:

# Add project-specific command
# Custom prompts are now added through MCP prompt system

# Document team patterns
/extract-patterns > .orchestre/patterns/team-conventions.md

Workspace Integration

For multiple projects:

# Initialize each project
for dir in */; do
  cd "$dir"
  /initialize
  cd ..
done

Integration Strategies

Minimal Approach

Just add commands:

/initialize
# Use only when needed

Balanced Approach

Regular integration:

/initialize
# Use for new features
# Review before merges
# Document as you go

Full Integration

Complete adoption:

/initialize
# All development through Orchestre
# Parallel workflows
# Continuous improvement

Success Indicators

You've successfully integrated when:

✅ Commands Available - All /commands work
✅ No Disruption - Existing workflows intact
✅ Clear Value - Measurable improvements
✅ Team Adoption - Others using commands
✅ Better Velocity - Faster development
✅ Higher Quality - Fewer bugs, better code

Next Steps

Immediate (First Hour)

1. Run /discover-context on core module
2. Read generated CLAUDE.md
3. Try /orchestrate for next task

Short Term (First Week)

1. Use /review before commits
2. Document one feature
3. Extract patterns from code
4. Share with team

Long Term (First Month)

1. Measure velocity improvement
2. Track bug reduction
3. Assess team satisfaction
4. Plan broader adoption

Tips and Tricks

Quick Context Check

# See what Orchestre learned
cat CLAUDE.md
cat src/CLAUDE.md

Command Discovery

# List all available commands
cat .orchestre/prompts.json

Effectiveness Metrics

Track improvements:

• Feature development time
• Bug count per release
• Code review feedback
• Team satisfaction

Direct Invocation

This is a dynamic prompt that Claude executes directly - no file installation needed:

# Simply type the command
/initialize [parameters]

# Claude will:
# 1. Analyze current context
# 2. Discover relevant patterns
# 3. Execute intelligently
# 4. Update distributed memory
# 5. Provide detailed results

Related

• install_commands tool - Underlying MCP tool
• /create command - For new projects
• /discover-context command - First command to run
• Getting Started - Getting started guide