/orchestrate

Analyze project requirements and create intelligent development plans that adapt to your specific context and needs.

Overview

• Purpose: Requirements analysis and adaptive planning
• Category: Core Orchestration
• Type: Dynamic prompt
• MCP Tools: analyze_project, generate_plan

Syntax

/orchestrate [requirements]

Parameters

Parameter	Required	Description	Examples
requirements	Yes	Requirements file or description	requirements.md, "Build a chat app"

Usage Examples

With Requirements File

# Analyze requirements from file
/orchestrate requirements.md

# Specific requirements document
/orchestrate docs/product-spec.md

With Direct Description

# Inline requirements
/orchestrate "Build a real-time collaborative document editor with user management"

# Complex requirements
/orchestrate "Create a B2B SaaS platform with:
- Multi-tenant architecture
- Subscription billing
- API access
- Admin dashboard
- Mobile app support"

How It Works

Discovery Phase

The prompt begins by understanding:

1. Project Context - Existing code and structure
2. Requirements - What you want to build
3. Constraints - Technical and business limitations
4. Patterns - Established conventions

Analysis Phase

Using Gemini AI, it performs:

• Complexity Assessment - How challenging is this?
• Component Identification - Major parts needed
• Risk Analysis - Potential challenges
• Technology Recommendations - Best tools for the job

Planning Phase

Creates an adaptive plan with:

• Phased Approach - Logical development stages
• Task Breakdown - Specific work items
• Dependencies - What needs what
• Timeline Estimates - Realistic durations

Output Example

📊 Analyzing requirements...

## Project Analysis

**Summary**: Building a real-time collaborative platform
**Complexity**: 7.5/10 (High)

### Key Components
1. Real-time Sync Engine (Complexity: 9/10)
2. User Management System (Complexity: 6/10)
3. Document Storage (Complexity: 5/10)
4. Permissions System (Complexity: 7/10)

### Major Challenges
- Conflict resolution for simultaneous edits
- Scalable WebSocket architecture
- Efficient document diffing

### Recommended Approach
- Start with core editor functionality
- Add real-time features incrementally
- Use proven libraries (Yjs, Socket.io)

## Development Plan

### Phase 1: Foundation (1-2 weeks)
- Set up project structure
- Implement basic editor
- Create user authentication
- Design document schema

### Phase 2: Collaboration (2-3 weeks)
- Add WebSocket server
- Implement real-time sync
- Handle conflict resolution
- Add presence awareness

### Phase 3: Advanced Features (1-2 weeks)
- Permission system
- Version history
- Export functionality
- Performance optimization

### Next Steps
1. Run: /execute-task "Set up project foundation"
2. Review the generated plan in PLAN.md
3. Adjust phases based on your timeline

Requirements Format

Markdown File Format

# Project Requirements

## Overview
Brief description of what you're building

## Core Features
- Feature 1: Description
- Feature 2: Description
- Feature 3: Description

## Technical Requirements
- Performance: Must handle X users
- Security: Requirements
- Scalability: Growth expectations

## Constraints
- Timeline: X weeks
- Team size: Y developers
- Budget: Considerations

## Success Criteria
- Metric 1
- Metric 2
- Metric 3

Inline Format

For simpler projects:

/orchestrate "Todo app with:
- User accounts
- Task categories
- Due dates
- Sharing capability
- Mobile responsive"

Advanced Features

Contextual Analysis

The prompt adapts based on:

• Existing Stack - Uses your current technologies
• Team Expertise - Considers skill levels
• Project Type - SaaS vs API vs Mobile
• Industry Domain - Specific requirements

Intelligent Recommendations

Provides smart suggestions:

Based on your requirements:
- Use PostgreSQL for complex relationships
- Implement Redis for real-time features
- Consider microservices for scalability
- Add monitoring early for observability

Risk Mitigation

Identifies and addresses risks:

⚠️ High Risk: Real-time synchronization
Mitigation:
- Use established CRDT library
- Implement comprehensive testing
- Plan for conflict resolution
- Add fallback mechanisms

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. Be Specific but Flexible

# Good: Clear goals, open implementation
/orchestrate "Build a customer support system that integrates with our existing CRM"

# Too vague: No clear objectives
/orchestrate "Make a support app"

# Too rigid: Prescribes implementation
/orchestrate "Build Express.js API with PostgreSQL using specific schema"

2. Include Context

Provide relevant background:

## Context
- Existing system: Ruby on Rails monolith
- Users: 10,000 active
- Team: 3 full-stack developers
- Timeline: 3 months

3. Define Success Metrics

Clear criteria help planning:

## Success Criteria
- Handle 1000 concurrent users
- Page load time < 2 seconds
- 99.9% uptime
- Mobile-first design

4. Iterate on Plans

Plans aren't final:

# Initial planning
/orchestrate requirements.md

# After Phase 1
/orchestrate "Updated requirements based on learnings"

# Adjust for discoveries
/update-state "Switching from WebSockets to SSE"

Integration Patterns

With Analysis Tools

# First understand complexity
/research "Real-time collaboration approaches"

# Then orchestrate with knowledge
/orchestrate requirements.md

With Execution

# Orchestrate creates plan
/orchestrate requirements.md

# Execute phases
/execute-task "Phase 1: Set up foundation"
/execute-task "Phase 2: Add core features"

With Review Cycle

# Plan → Execute → Review → Adjust
/orchestrate requirements.md
/execute-task "Implement authentication"
/review
/orchestrate "Adjusted requirements based on review"

Error Handling

Common Issues

Issue	Cause	Solution
Requirements not found	File doesn't exist	Check file path
Requirements too vague	Insufficient detail	Add specific features
Analysis timeout	Complex requirements	Break into sections
No clear plan	Conflicting requirements	Clarify priorities

Recovery Strategies

# If requirements are unclear
/research "Best practices for [your domain]"
# Then re-orchestrate with insights

# If plan seems wrong
/update-state "Additional context: [details]"
/orchestrate "Revised requirements"

Output Files

The prompt creates:

PLAN.md

Detailed development plan with:

• Phase breakdown
• Task lists
• Dependencies
• Timeline estimates

CLAUDE.md Files

Updates distributed memory:

• Root CLAUDE.md with project overview
• Feature-specific CLAUDE.md files
• Architecture decisions
• Implementation details

Analysis Results

Stored in .orchestre/analysis/:

• Complexity metrics
• Risk assessment
• Technology recommendations

Customization

Template-Specific Orchestration

Different templates adapt differently:

# MakerKit focuses on SaaS patterns
/orchestrate "Multi-tenant analytics platform"
# → Plans for teams, billing, permissions

# Cloudflare focuses on edge computing
/orchestrate "Global API with caching"
# → Plans for Workers, KV, geographic distribution

# React Native focuses on mobile UX
/orchestrate "Offline-first task manager"
# → Plans for local storage, sync, native features

Domain Adaptation

Specify domain for better results:

/orchestrate "E-commerce platform for handmade goods
Context: Small businesses, global shipping, artisan focus"

/orchestrate "Healthcare appointment system
Context: HIPAA compliance, patient privacy, integrations"

Performance Tips

Efficient Orchestration

1. Clear Requirements - Better input = better output
2. Incremental Planning - Plan in phases
3. Context Caching - Builds on previous analysis
4. Focused Scope - One project at a time

Large Projects

For complex systems:

# Break into subsystems
/orchestrate "Phase 1: Core user system"
/orchestrate "Phase 2: Payment processing"
/orchestrate "Phase 3: Admin dashboard"

Command Intelligence

Learning from Context

The prompt learns from:

• Existing code patterns
• Previous decisions
• Team preferences
• Project evolution

Adaptive Planning

Plans adjust based on:

• Technology discoveries
• Complexity findings
• Risk assessments
• Available resources

Direct Invocation

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

# Simply type the command
/orchestrate [parameters]

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

Related

• analyze_project tool - Analysis engine
• generate_plan tool - Planning engine
• /execute-task command - Execute the plan
• /status command - Check plan progress
• Requirements Guide - Writing good requirements