workflow-orchestrator

name	workflow-orchestrator
description	Intelligent workflow delegation system that automatically analyzes every prompt and routes to appropriate specialized workflows with architecture-first development principles. This skill runs on every prompt with highest priority to ensure intelligent task delegation before any other skill execution.

Workflow Orchestrator

Intelligent task analysis and automatic workflow delegation system that combines architecture-first development with smart workflow routing.

Core Philosophy

You are the central intelligence that routes complex development tasks to specialized workflows while ensuring architectural integrity and production-ready code generation.

Task Analysis Engine

Semantic Analysis

Before delegating to any workflow, perform comprehensive task analysis:

interface TaskAnalysis {
  taskType: 'setup' | 'development' | 'deployment' | 'maintenance' | 'design' | 'testing';
  complexity: 'simple' | 'moderate' | 'complex';
  estimatedTime: number; // in minutes
  requiredSkills: string[];
  suggestedWorkflow: string;
  confidence: number; // 0-1
  architecturalImpact: 'low' | 'medium' | 'high';
  dependencies: string[];
}

Workflow Routing Matrix

• /setup-project → setup-project workflow
• /add-entity → add-entity workflow
• /create-component → create-component workflow
• /create-ui → frontend-design workflow
• /setup-auth → setup-auth-flow workflow
• /deploy-app → deploy-production workflow
• /optimize-performance → performance-optimization workflow
• /scrape-data → scraper workflow
• /test-standards → testing-standards workflow

Architecture-First Delegation

Pre-Delegation Analysis

1. Read Architecture Documents — Understand system structure
2. Identify Integration Points — Where does this fit?
3. Assess Impact — What changes are required?
4. Validate Dependencies — Are required tools available?

Delegation Protocol

interface DelegationRequest {
  task: string;
  analysis: TaskAnalysis;
  context: ProjectContext;
  architecturalConstraints: ArchitecturalConstraints;
}

class WorkflowOrchestrator {
  async delegateToWorkflow(request: DelegationRequest): Promise<DelegationResult> {
    // 1. Select appropriate workflow
    const workflow = this.selectWorkflow(request.analysis.suggestedWorkflow);
    
    // 2. Prepare context with architectural constraints
    const enhancedContext = {
      ...request.context,
      architecturalConstraints: request.architecturalConstraints,
      delegationSource: 'orchestrator'
    };
    
    // 3. Execute with full context
    return await workflow.execute(request.task, enhancedContext);
  }
}

Multi-Workflow Coordination

Parallel Execution

interface WorkflowExecution {
  id: string;
  workflow: string;
  status: 'pending' | 'running' | 'completed' | 'failed';
  dependencies: string[];
  result?: any;
}

class WorkflowCoordinator {
  async executeParallelWorkflows(tasks: TaskAnalysis[]): Promise<WorkflowExecution[]> {
    // Group by workflow type and resolve dependencies
    const executionPlan = this.createExecutionPlan(tasks);
    
    // Execute in dependency order
    return await this.executeWithDependencies(executionPlan);
  }
}

Context Management

interface ProjectContext {
  projectType: 'hustlestack' | 'custom';
  currentPhase: 'setup' | 'development' | 'deployment' | 'maintenance';
  environment: 'development' | 'staging' | 'production';
  architecture: ArchitectureDocument;
  userPreferences: Record<string, any>;
  activeWorkflows: WorkflowExecution[];
}

Learning and Adaptation

Confidence Scoring

class SkillMatcher {
  calculateConfidence(skill: WorkflowSkill, analysis: TaskAnalysis): number {
    let confidence = 0.5;
    
    // Keyword matching (30% weight)
    const keywordMatches = skill.keywords.filter(keyword => 
      analysis.task.toLowerCase().includes(keyword.toLowerCase())
    ).length;
    confidence += (keywordMatches / skill.keywords.length) * 0.3;
    
    // Semantic similarity (20% weight)
    const semanticSimilarity = this.calculateSemanticSimilarity(skill, analysis);
    confidence += semanticSimilarity * 0.2;
    
    // Historical success (30% weight)
    const historicalSuccess = this.getHistoricalSuccessRate(skill);
    confidence += historicalSuccess * 0.3;
    
    // Complexity matching (20% weight)
    const complexityMatch = this.complexityMatches(skill, analysis);
    confidence += complexityMatch * 0.2;
    
    return Math.min(confidence, 1.0);
  }
}

Learning System

interface ExecutionHistory {
  workflow: string;
  task: string;
  success: boolean;
  executionTime: number;
  userFeedback?: number; // 1-5 rating
  timestamp: Date;
}

class AdaptiveLearning {
  updateConfidence(execution: ExecutionHistory): void {
    // Adjust confidence based on actual outcomes
    const skill = this.findSkill(execution.workflow);
    const adjustment = this.calculateAdjustment(execution);
    skill.confidence += adjustment;
  }
  
  generateInsights(): WorkflowInsights {
    return {
      mostUsedWorkflows: this.getMostUsedWorkflows(),
      averageExecutionTime: this.getAverageExecutionTime(),
      successPatterns: this.getSuccessPatterns(),
      recommendations: this.generateRecommendations()
    };
  }
}

Integration with Delegation Principles

Architecture Compliance

All delegated workflows must follow delegation skill principles:

1. Read architecture document before writing code
2. Declare target filepath explicitly
3. List dependencies and consumers
4. Check for conflicts with existing functionality
5. Implement fully typed production-ready code
6. Follow naming conventions strictly
7. Write comprehensive tests for all implementations

Quality Gates

interface QualityGate {
  validateArchitecture(code: string, context: ProjectContext): boolean;
  validateDependencies(code: string): boolean;
  validateTesting(code: string): boolean;
  validateDocumentation(code: string): boolean;
}

class DelegationQualityGate {
  async validateDelegation(result: DelegationResult): Promise<ValidationReport> {
    return {
      architectureCompliant: await this.validateArchitecture(result.code),
      dependenciesResolved: this.validateDependencies(result.code),
      testsIncluded: this.validateTesting(result.code),
      documented: this.validateDocumentation(result.code),
      overallScore: this.calculateQualityScore(result)
    };
  }
}

Error Handling and Recovery

Graceful Degradation

class ErrorRecovery {
  async handleWorkflowFailure(execution: WorkflowExecution): Promise<RecoveryResult> {
    // 1. Analyze failure mode
    const failureAnalysis = this.analyzeFailure(execution);
    
    // 2. Attempt alternative workflow
    if (failureAnalysis.canRetry) {
      return await this.retryWithAlternative(execution);
    }
    
    // 3. Degrade gracefully
    return await this.degradeToSimplerWorkflow(execution);
  }
}

Configuration

Orchestrator Settings

{
  "orchestrator": {
    "confidence_threshold": 0.7,
    "max_parallel_workflows": 3,
    "learning_rate": 0.1,
    "context_retention": "24h",
    "auto_delegation": true,
    "architecture_first": true,
    "quality_gates": true
  },
  "workflows": {
    "timeout_duration": "30m",
    "retry_attempts": 3,
    "progress_tracking": true,
    "error_handling": "graceful_degradation",
    "require_architecture_compliance" 
  
   
     
     
     
     
     
     
  

Usage Examples

Basic Delegation

User: "Add user authentication to my app"
→ Analyze task → Match to setup-auth-flow → Delegate with architecture context

Complex Multi-Workflow Coordination

User: "Build a complete e-commerce site with auth, payment, and deployment"
→ Analyze components → Route to multiple workflows → Coordinate parallel execution → Integrate results

Learning Adaptation

User provides feedback on workflow quality
→ Update confidence scores → Improve future routing → Generate insights

Benefits

1. Intelligent Routing - Automatically selects optimal workflows
2. Architecture Protection - Ensures all code follows system design
3. Quality Assurance - Built-in quality gates and validation
4. Learning System - Improves accuracy through usage patterns
5. Multi-Workflow Support - Coordinates complex, multi-step projects
6. Error Recovery - Graceful handling of workflow failures
7. Context Awareness - Maintains project state across delegations

Related Skills

• Use /frontend-design for UI implementation workflows
• Use /senior-dev for PR and code review workflows
• Use /web-architecture for system architecture design
• Use individual workflow skills for specific domain tasks

This orchestrator combines intelligent delegation with the rigorous architecture-first approach of the delegation skill, providing a comprehensive system for managing complex development projects while maintaining code quality and architectural integrity.