/elaborate

allowed-tools: Read, Write, Bash(fd:*), Bash(rg:*), Bash(git:*), Bash(gdate:*), Bash(jq:*), Bash(wc:*), Task, WebFetch
name: "Elaborate"
description: "Generate comprehensive technical analysis and implementation guide with adaptive research and project-specific optimization"
author: "wcygan"
tags: ["analyze","code"]
version: "1.0.0"
created_at: "2025-07-14T00:00:00Z"
updated_at: "2025-07-14T00:00:00Z"

Context

• Session ID: !`gdate +%s%N`
• Current directory: !`pwd`
• Analysis target: $ARGUMENTS
• Project structure: !`fd . -t d -d 3 | head -15 || echo "No directories found"`
• Code files: !`fd "\.(rs|go|java|py|js|ts|cpp|c|kt|scala|rb|php|cs|swift)$" . | wc -l | tr -d ' ' || echo "0"`
• Configuration files: !`fd "(package\.json|Cargo\.toml|go\.mod|pom\.xml|deno\.json|requirements\.txt|composer\.json|build\.gradle)$" . -d 3 || echo "No config files"`
• Documentation: !`fd "(README|CHANGELOG|CONTRIBUTING|LICENSE)\.md$" . -d 2 | head -5 || echo "No docs found"`
• Test files: !`fd "(test|spec)" . -t f | wc -l | tr -d ' ' || echo "0"`
• Git repository: !`git rev-parse --is-inside-work-tree 2>/dev/null && echo "Yes" || echo "No"`
• Recent changes: !`git log --oneline -5 2>/dev/null || echo "No git repository"`
• Branch status: !`git status --porcelain 2>/dev/null | wc -l | tr -d ' ' | xargs -I {} echo "{} uncommitted files" || echo "N/A"`
• Technology stack indicators: !`rg "(import|require|use|include|from)" . --type rust --type go --type java --type python --type typescript | head -10 | cut -d: -f3 | sort -u | head -5 || echo "No imports detected"`

Your Task

**IMMEDIATELY DEPLOY 10 PARALLEL ANALYSIS AGENTS** for ultra-fast comprehensive technical analysis: **$ARGUMENTS**

Think deeply about comprehensive technical implementation while maximizing parallel execution for 10x speedup.

**CRITICAL**: Launch ALL agents simultaneously in first response - NO conditional complexity logic.

Parallel Analysis Framework

STEP 1: **LAUNCH ALL 10 AGENTS SIMULTANEOUSLY**

**NO CONDITIONAL PROCESSING** - Deploy these specialized analysis agents in parallel:

1. **Technology Stack Agent**: Detect languages, frameworks, dependencies, and architectural patterns 2. **Implementation Strategy Agent**: Research best practices, design patterns, and technology-specific solutions 3. **Testing & Quality Agent**: Testing frameworks, coverage strategies, CI/CD pipelines, and quality gates 4. **DevOps & Deployment Agent**: Infrastructure, monitoring, deployment automation, and production readiness 5. **Security & Compliance Agent**: Security patterns, authentication, authorization, and compliance requirements 6. **Performance & Scalability Agent**: Optimization strategies, caching, load balancing, and scaling patterns 7. **Code Examples Agent**: Working implementations, advanced patterns, and real-world use cases 8. **Risk Assessment Agent**: Technical debt, alternative approaches, migration paths, and trade-off analysis 9. **Documentation & Standards Agent**: API documentation, architectural decisions, and team coordination 10. **Integration & APIs Agent**: Service integration, external APIs, data flow, and system boundaries

**Expected speedup**: 10x faster than sequential analysis.

STEP 2: Initialize Parallel Session Management

// /tmp/elaborate-analysis-$SESSION_ID.json
{
  "sessionId": "$SESSION_ID",
  "target": "$ARGUMENTS",
  "phase": "parallel_analysis",
  "technology_stack": "auto-detect",
  "analysis_domains": [
    "technology",
    "implementation",
    "testing",
    "devops",
    "security",
    "performance",
    "examples",
    "risks",
    "documentation",
    "integration"
  ],
  "research_findings": {},
  "implementation_phases": [],
  "artifacts_created": [],
  "checkpoints": []
}

STEP 3: Parallel Research & Analysis Execution

**ALL AGENTS WORK CONCURRENTLY:**

**Comprehensive Analysis Discovery:**

# Technology stack and dependencies
fd . -t f -e json -e toml -e xml -e py -e rs -e go -e java -e ts -e js | head -20

# Architecture and patterns
rg "(class|interface|struct|enum|type|module)" . --type rust --type go --type java --type typescript | head -10

# Testing and quality frameworks
rg "(test|spec|mock|assert|describe|it)" . | head -10

# Configuration and deployment
fd . -t f | rg "(docker|k8s|config|deploy|ci|cd)" | head -10

TRY: Launch all 10 parallel agents for comprehensive technical analysis Execute concurrent research across all analysis domains Synthesize findings from all agent results Generate multi-phase implementation roadmap Create comprehensive technical documentation Update session state: phase = "analysis_complete"

CATCH (agent_failures): Continue with available agent results Document failed analysis areas Provide partial guidance with gaps identified Generate basic implementation roadmap

FINALLY: Aggregate all parallel agent findings Synthesize comprehensive technical analysis Generate implementation phases and roadmap Create technology-specific code examples Save artifacts: comprehensive-guide.md, implementation-checklist.md, code-examples/ Clean up temporary analysis files

STEP 4: **Parallel Results Synthesis**

WAIT for ALL 10 agents to complete technical analysis AGGREGATE findings from all parallel streams:

• Complete technology stack analysis and recommendations
• Implementation strategy with best practices and patterns
• Testing framework recommendations and quality gates
• DevOps pipeline and deployment automation strategies
• Security patterns and compliance requirements
• Performance optimization and scalability approaches
• Working code examples and advanced implementation patterns
• Risk assessment and alternative architecture options
• Documentation standards and team coordination strategies
• Integration patterns and API design recommendations

GENERATE multi-phase implementation roadmap:

• Phase 1: Foundation Setup (1-2 weeks)
• Phase 2: Core Implementation (3-4 weeks)
• Phase 3: Production Readiness (1-2 weeks)