/orchestrate - Intelligent Requirement Analysis & Planning

Purpose

The /orchestrate prompt reads requirement files and uses Orchestre's MCP tools to perform deep analysis and generate adaptive development plans. It creates comprehensive, actionable blueprints based on documented requirements.

How It Actually Works

1. Reads Requirements File: Expects a file path (e.g., "requirements.md")
2. Calls MCP Analysis Tool: Uses mcp__orchestre__analyze_project for complexity assessment
3. Calls MCP Planning Tool: Uses mcp__orchestre__generate_plan for development roadmap
4. Documents Results: Updates CLAUDE.md and creates plan files

Use Cases

1. Project Planning: Transform documented requirements into structured development plans
2. Requirement Analysis: Deep dive into technical and business needs from requirement docs
3. Architecture Design: Generate scalable system architectures based on analysis
4. Complexity Assessment: Get quantified project scope evaluation (1-10 scale)
5. Roadmap Creation: Build phased implementation strategies with dependencies

Argument Structure

/orchestrate <requirements-file-path>

Arguments

1. requirements-file-path (required)
   • Path to requirements file (e.g., "requirements.md", "docs/requirements.md")
   • Can also accept direct requirements text (will guide to create file)

Examples

# Standard flow with requirements file
/orchestrate requirements.md

# With requirements in specific location
/orchestrate docs/project-requirements.md

# If no file exists (will help locate or create)
/orchestrate "requirements.txt"

Error Handling

If requirements file is not found, the prompt will:

1. Search for common requirement file names
2. Guide you to create a requirements.md with proper structure
3. Suggest what to include in requirements documentation

Technical Details

MCP Tool Integration

1. Analysis Tool (mcp__orchestre__analyze_project):

   • Input: Requirements text and optional context
   • Output:
     • Complexity score (1-10)
     • Recommended approach
     • Suggested templates
     • Key technical decisions
     • Risk factors

2. Planning Tool (mcp__orchestre__generate_plan):

   • Input: Requirements, analysis results, template
   • Output:
     • Phased development plan
     • Task breakdown with dependencies
     • Parallel vs sequential work identification
     • Resource requirements
     • Timeline estimates

Generated Artifacts

The orchestration process creates:

1. Updated CLAUDE.md with:

   • Project overview and vision
   • Architecture decisions
   • Technology stack recommendations
   • Phase breakdown
   • Key milestones

2. Plan Files in .orchestre/plans/:

   • plan-[date].md - Complete development plan
   • Includes analysis and planning results
   • Documents key decisions and rationale

Memory Usage

Created Memory Structure

.orchestre/
├── CLAUDE.md                    # Orchestration decisions
├── plans/
│   ├── master-plan.md          # Comprehensive plan
│   ├── architecture.md         # System design
│   └── roadmap.md             # Implementation phases
├── knowledge/
│   ├── requirements.md         # Analyzed requirements
│   ├── constraints.md          # Technical constraints
│   └── decisions.md           # Key decisions
└── templates/
    └── plan-template.md        # Reusable patterns

Memory Content Example

# Orchestration: Invoice Management Platform

## Project Analysis
- Type: B2B SaaS Platform
- Complexity: Medium-High
- Primary Focus: Team collaboration and workflow automation
- Key Differentiator: AI-powered invoice processing

## Technical Decisions
1. **Architecture**: Microservices with event-driven communication
2. **Frontend**: Next.js with real-time updates (WebSockets)
3. **Backend**: Node.js services with PostgreSQL and Redis
4. **Infrastructure**: Kubernetes on AWS with auto-scaling

## Implementation Phases
### Phase 1: MVP (Weeks 1-6)
- Core invoice CRUD operations
- Basic team management
- Simple approval workflows
- Email notifications

### Phase 2: Enhancement (Weeks 7-12)
- AI invoice data extraction
- Advanced workflow builder
- Integration marketplace
- Analytics dashboard

Workflow Examples

Startup MVP Planning

# 1. Initial orchestration
/orchestrate "Peer-to-peer tutoring platform with video calls and scheduling"

# 2. Review generated plan
/status

# 3. Begin implementation
/execute-task "Implement Phase 1: User authentication and profiles"

# 4. Iterate on plan
/orchestrate "Add payment processing and subscription tiers" --phase=growth

Enterprise Migration

# 1. Analyze existing system
/discover-context ./legacy-app

# 2. Orchestrate migration
/orchestrate "Modernize monolithic Java app to microservices" --depth=comprehensive

# 3. Security planning
/security-audit

# 4. Execute migration phases
/execute-task "Extract user service as first microservice"

Complex Integration Project

# 1. Define integration needs
/orchestrate "Multi-channel e-commerce with ERP, CRM, and warehouse sync"

# 2. Focus on specific area
/orchestrate "Real-time inventory synchronization" "integration-architecture"

# 3. Plan data flows
/execute-task "Design event-driven inventory update system"

Intelligent Features

Requirement Discovery

• Asks clarifying questions when needed
• Infers implicit requirements
• Identifies missing considerations
• Suggests related features

Technology Selection

Based on requirements, suggests:

• Appropriate frameworks
• Database choices
• Infrastructure options
• Third-party services
• Development tools

Risk Assessment

Automatically identifies:

• Technical challenges
• Scalability concerns
• Security vulnerabilities
• Integration complexities
• Maintenance burden

Resource Planning

Estimates and plans for:

• Development timeline
• Technical expertise needed
• Infrastructure costs
• Third-party service costs
• Maintenance requirements

Generated Artifacts

1. Master Plan

Comprehensive document including:

• Executive summary
• Technical architecture
• Implementation roadmap
• Risk mitigation strategies
• Success metrics

2. Architecture Diagrams

Text-based diagrams for:

• System components
• Data flow
• API structure
• Deployment topology
• Security boundaries

3. Task Breakdown

Detailed task lists with:

• Dependencies mapped
• Effort estimates
• Priority levels
• Technical requirements
• Acceptance criteria

4. Decision Log

Documents all major decisions:

• Technology choices
• Architecture patterns
• Trade-offs made
• Alternatives considered
• Rationale provided

Integration Points

With Other Prompts

• ← /create: After project initialization
• → /execute-task: Implement planned phases
• → /compose-saas-mvp: Rapid prototype from plan
• → /generate-implementation-tutorial: Detailed implementation
• → /add-enterprise-feature: Enhance with enterprise features

With MCP Tools

• Uses analyzeProject for requirement analysis
• Uses generatePlan for plan creation
• Prepares for multiLlmReview validation
• Enables research for technical decisions

Best Practices

1. Start Broad, Then Focus

   # Initial broad analysis
   /orchestrate "Online education platform"
   
   # Follow up with specifics
   /orchestrate "Live streaming for online education" "real-time-infrastructure"

2. Include Constraints

   # Good: Clear constraints
   /orchestrate "E-commerce site with 100k daily users, AWS infrastructure, $10k/month budget"
   
   # Basic: No constraints
   /orchestrate "E-commerce site"

3. Iterative Refinement

   # Round 1: High-level
   /orchestrate "Project management tool"
   
   # Round 2: With learnings
   /orchestrate "Agile project management with Jira integration" --phase=enhancement

Advanced Usage

Multi-Tenant Planning

/orchestrate "Convert single-tenant app to multi-tenant SaaS" --depth=comprehensive
# Generates migration strategy, data isolation plan, tenant management design

Performance-First Design

/orchestrate "High-frequency trading platform" "performance" --constraints="<10ms latency"
# Creates architecture optimized for speed, suggests performance patterns

Compliance-Driven Planning

/orchestrate "Healthcare data platform" --constraints="HIPAA,GDPR" --depth=comprehensive
# Embeds compliance requirements into every architectural decision

Tips

1. Be Specific About Goals: Clear business objectives lead to better plans
2. Mention Constraints Early: Budget, time, and technical limits shape the plan
3. Use Iteratively: Plans should evolve as you learn
4. Review Generated Plans: The AI creates starting points for discussion
5. Combine with Discovery: Use /discover-context first for existing projects