Tech Stack Evaluator

Technology Stack Evaluator

A comprehensive evaluation framework for comparing technologies, frameworks, cloud providers, and complete technology stacks. Provides data-driven recommendations with TCO analysis, security assessment, ecosystem health scoring, and migration path analysis.

Capabilities

This skill provides eight comprehensive evaluation capabilities:

• Technology Comparison: Head-to-head comparisons of frameworks, languages, and tools (React vs Vue, PostgreSQL vs MongoDB, Node.js vs Python)
• Stack Evaluation: Assess complete technology stacks for specific use cases (real-time collaboration, API-heavy SaaS, data-intensive platforms)
• Maturity & Ecosystem Analysis: Evaluate community health, maintenance status, long-term viability, and ecosystem strength
• Total Cost of Ownership (TCO): Calculate comprehensive costs including licensing, hosting, developer productivity, and scaling
• Security & Compliance: Analyze vulnerabilities, compliance readiness (GDPR, SOC2, HIPAA), and security posture
• Migration Path Analysis: Assess migration complexity, risks, timelines, and strategies from legacy to modern stacks
• Cloud Provider Comparison: Compare AWS vs Azure vs GCP for specific workloads with cost and feature analysis
• Decision Reports: Generate comprehensive decision matrices with pros/cons, confidence scores, and actionable recommendations

Input Requirements

Flexible Input Formats (Automatic Detection)

The skill automatically detects and processes multiple input formats:

Text/Conversational:

"Compare React vs Vue for building a SaaS dashboard"
"Evaluate technology stack for real-time collaboration platform"
"Should we migrate from MongoDB to PostgreSQL?"

Structured (YAML):

comparison:
  technologies:
    - name: "React"
    - name: "Vue"
  use_case: "SaaS dashboard"
  priorities:
    - "Developer productivity"
    - "Ecosystem maturity"
    - "Performance"

Structured (JSON):

{
  "comparison": {
    "technologies": ["React", "Vue"],
    "use_case": "SaaS dashboard",
    "priorities": ["Developer productivity", "Ecosystem maturity"]
  }
}

URLs for Ecosystem Analysis:

• GitHub repository URLs (for health scoring)
• npm package URLs (for download statistics)
• Technology documentation URLs (for feature extraction)

Analysis Scope Selection

Users can select which analyses to run:

• Quick Comparison: Basic scoring and comparison (200-300 tokens)
• Standard Analysis: Scoring + TCO + Security (500-800 tokens)
• Comprehensive Report: All analyses including migration paths (1200-1500 tokens)
• Custom: User selects specific sections (modular)

Output Formats

Context-Aware Output

The skill automatically adapts output based on environment:

Claude Desktop (Rich Markdown):

• Formatted tables with color indicators
• Expandable sections for detailed analysis
• Visual decision matrices
• Charts and graphs (when appropriate)

CLI/Terminal (Terminal-Friendly):

• Plain text tables with ASCII borders
• Compact formatting
• Clear section headers
• Copy-paste friendly code blocks

Progressive Disclosure Structure

Executive Summary (200-300 tokens):

• Recommendation summary
• Top 3 pros and cons
• Confidence level (High/Medium/Low)
• Key decision factors

Detailed Breakdown (on-demand):

• Complete scoring matrices
• Detailed TCO calculations
• Full security analysis
• Migration complexity assessment
• All supporting data and calculations

Report Sections (User-Selectable)

Users choose which sections to include:

1. Scoring & Comparison Matrix

   • Weighted decision scores
   • Head-to-head comparison tables
   • Strengths and weaknesses

2. Financial Analysis

   • TCO breakdown (5-year projection)
   • ROI analysis
   • Cost per user/request metrics
   • Hidden cost identification

3. Ecosystem Health

   • Community size and activity
   • GitHub stars, npm downloads
   • Release frequency and maintenance
   • Issue response times
   • Viability assessment

4. Security & Compliance

   • Vulnerability count (CVE database)
   • Security patch frequency
   • Compliance readiness (GDPR, SOC2, HIPAA)
   • Security scoring

5. Migration Analysis (when applicable)

   • Migration complexity scoring
   • Code change estimates
   • Data migration requirements
   • Downtime assessment
   • Risk mitigation strategies

6. Performance Benchmarks

   • Throughput/latency comparisons
   • Resource usage analysis
   • Scalability characteristics

How to Use

Basic Invocations

Quick Comparison:

"Compare React vs Vue for our SaaS dashboard project"
"PostgreSQL vs MongoDB for our application"

Stack Evaluation:

"Evaluate technology stack for real-time collaboration platform:
Node.js, WebSockets, Redis, PostgreSQL"

TCO Analysis:

"Calculate total cost of ownership for AWS vs Azure for our workload:
- 50 EC2/VM instances
- 10TB storage
- High bandwidth requirements"

Security Assessment:

"Analyze security posture of our current stack:
Express.js, MongoDB, JWT authentication.
Need SOC2 compliance."

Migration Path:

"Assess migration from Angular.js (1.x) to React.
Application has 50,000 lines of code, 200 components."

Advanced Invocations

Custom Analysis Sections:

"Compare Next.js vs Nuxt.js.
Include: Ecosystem health, TCO, and performance benchmarks.
Skip: Migration analysis, compliance."

Weighted Decision Criteria:

"Compare cloud providers for ML workloads.
Priorities (weighted):
- GPU availability (40%)
- Cost (30%)
- Ecosystem (20%)
- Support (10%)"

Multi-Technology Comparison:

"Compare: React, Vue, Svelte, Angular for enterprise SaaS.
Use case: Large team (20+ developers), complex state management.
Generate comprehensive decision matrix."

Scripts

Core Modules

• stack_comparator.py: Main comparison engine with weighted scoring algorithms
• tco_calculator.py: Total Cost of Ownership calculations (licensing, hosting, developer productivity, scaling)
• ecosystem_analyzer.py: Community health scoring, GitHub/npm metrics, viability assessment
• security_assessor.py: Vulnerability analysis, compliance readiness, security scoring
• migration_analyzer.py: Migration complexity scoring, risk assessment, effort estimation
• format_detector.py: Automatic input format detection (text, YAML, JSON, URLs)
• report_generator.py: Context-aware report generation with progressive disclosure

Utility Modules

• data_fetcher.py: Fetch real-time data from GitHub, npm, CVE databases
• benchmark_processor.py: Process and normalize performance benchmark data
• confidence_scorer.py: Calculate confidence levels for recommendations

Metrics and Calculations

1. Scoring & Comparison Metrics

Technology Comparison Matrix:

• Feature completeness (0-100 scale)
• Learning curve assessment (Easy/Medium/Hard)
• Developer experience scoring
• Documentation quality (0-10 scale)
• Weighted total scores

Decision Scoring Algorithm:

• User-defined weights for criteria
• Normalized scoring (0-100)
• Confidence intervals
• Sensitivity analysis

2. Financial Calculations

TCO Components:

• Initial Costs: Licensing, training, migration
• Operational Costs: Hosting, support, maintenance (monthly/yearly)
• Scaling Costs: Per-user costs, infrastructure scaling projections
• Developer Productivity: Time-to-market impact, development speed multipliers
• Hidden Costs: Technical debt, vendor lock-in risks

ROI Calculations:

• Cost savings projections (3-year, 5-year)
• Productivity gains (developer hours saved)
• Break-even analysis
• Risk-adjusted returns

Cost Per Metric:

• Cost per user (monthly/yearly)
• Cost per API request
• Cost per GB stored/transferred
• Cost per compute hour

3. Maturity & Ecosystem Metrics

Health Scoring (0-100 scale):

• GitHub Metrics: Stars, forks, contributors, commit frequency
• npm Metrics: Weekly downloads, version stability, dependency count
• Release Cadence: Regular releases, semantic versioning adherence
• Issue Management: Response time, resolution rate, open vs closed issues

Community Metrics:

• Active maintainers count
• Contributor growth rate
• Stack Overflow question volume
• Job market demand (job postings analysis)

Viability Assessment:

• Corporate backing strength
• Community sustainability
• Alternative availability
• Long-term risk scoring

4. Security & Compliance Metrics

Security Scoring:

• CVE Count: Known vulnerabilities (last 12 months, last 3 years)
• Severity Distribution: Critical/High/Medium/Low vulnerability counts
• Patch Frequency: Average time to patch (days)
• Security Track Record: Historical security posture

Compliance Readiness:

• GDPR: Data privacy features, consent management, data portability
• SOC2: Access controls, encryption, audit logging
• HIPAA: PHI handling, encryption standards, access controls
• PCI-DSS: Payment data security (if applicable)

Compliance Scoring (per standard):

• Ready: 90-100% compliant
• Mostly Ready: 70-89% (minor gaps)
• Partial: 50-69% (significant work needed)
• Not Ready: <50% (major gaps)

5. Migration Analysis Metrics

Complexity Scoring (1-10 scale):

• Code Changes: Estimated lines of code affected
• Architecture Impact: Breaking changes, API compatibility
• Data Migration: Schema changes, data transformation complexity
• Downtime Requirements: Zero-downtime possible vs planned outage

Effort Estimation:

• Development hours (by component)
• Testing hours
• Training hours
• Total person-months

Risk Assessment:

• Technical Risks: API incompatibilities, performance regressions
• Business Risks: Downtime impact, feature parity gaps
• Team Risks: Learning curve, skill gaps
• Mitigation Strategies: Risk-specific recommendations

Migration Phases:

• Phase 1: Planning and prototyping (timeline, effort)
• Phase 2: Core migration (timeline, effort)
• Phase 3: Testing and validation (timeline, effort)
• Phase 4: Deployment and monitoring (timeline, effort)

6. Performance Benchmark Metrics

Throughput/Latency:

• Requests per second (RPS)
• Average response time (ms)
• P95/P99 latency percentiles
• Concurrent user capacity

Resource Usage:

• Memory consumption (MB/GB)
• CPU utilization (%)
• Storage requirements
• Network bandwidth

Scalability Characteristics:

• Horizontal scaling efficiency
• Vertical scaling limits
• Cost per performance unit
• Scaling inflection points

Best Practices

For Accurate Evaluations

1. Define Clear Use Case: Specify exact requirements, constraints, and priorities
2. Provide Complete Context: Team size, existing stack, timeline, budget constraints
3. Set Realistic Priorities: Use weighted criteria (total = 100%) for multi-factor decisions
4. Consider Team Skills: Factor in learning curve and existing expertise
5. Think Long-Term: Evaluate 3-5 year outlook, not just immediate needs

For TCO Analysis

1. Include All Cost Components: Don't forget training, migration, technical debt
2. Use Realistic Scaling Projections: Base on actual growth metrics, not wishful thinking
3. Account for Developer Productivity: Time-to-market and development speed are critical costs
4. Consider Hidden Costs: Vendor lock-in, exit costs, technical debt accumulation
5. Validate Assumptions: Document all TCO assumptions for review

For Migration Decisions

1. Start with Risk Assessment: Identify showstoppers early
2. Plan Incremental Migration: Avoid big-bang rewrites when possible
3. Prototype Critical Paths: Test complex migration scenarios before committing
4. Build Rollback Plans: Always have a fallback strategy
5. Measure Baseline Performance: Establish current metrics before migration

For Security Evaluation

1. Check Recent Vulnerabilities: Focus on last 12 months for current security posture
2. Review Patch Response Time: Fast patching is more important than zero vulnerabilities
3. Validate Compliance Claims: Vendor claims ≠ actual compliance readiness
4. Consider Supply Chain: Evaluate security of all dependencies
5. Test Security Features: Don't assume features work as documented

Limitations

Data Accuracy

• Ecosystem metrics are point-in-time snapshots (GitHub stars, npm downloads change rapidly)
• TCO calculations are estimates based on provided assumptions and market rates
• Benchmark data may not reflect your specific use case or configuration
• Security vulnerability counts depend on public CVE database completeness

Scope Boundaries

• Industry-Specific Requirements: Some specialized industries may have unique constraints not covered by standard analysis
• Emerging Technologies: Very new technologies (<1 year old) may lack sufficient data for accurate assessment
• Custom/Proprietary Solutions: Cannot evaluate closed-source or internal tools without data
• Political/Organizational Factors: Cannot account for company politics, vendor relationships, or legacy commitments

Contextual Limitations

• Team Skill Assessment: Cannot directly evaluate your team's specific skills and learning capacity
• Existing Architecture: Recommendations assume greenfield unless migration context provided
• Budget Constraints: TCO analysis provides costs but cannot make budget decisions for you
• Timeline Pressure: Cannot account for business deadlines and time-to-market urgency

When NOT to Use This Skill

• Trivial Decisions: Choosing between nearly-identical tools (use team preference)
• Mandated Solutions: When technology choice is already decided by management/policy
• Insufficient Context: When you don't know your requirements, priorities, or constraints
• Real-Time Production Decisions: Use for planning, not emergency production issues
• Non-Technical Decisions: Business strategy, hiring, organizational issues

Confidence Levels

The skill provides confidence scores with all recommendations:

• High Confidence (80-100%): Strong data, clear winner, low risk
• Medium Confidence (50-79%): Good data, trade-offs present, moderate risk
• Low Confidence (<50%): Limited data, close call, high uncertainty
• Insufficient Data: Cannot make recommendation without more information

Confidence is based on:

• Data completeness and recency
• Consensus across multiple metrics
• Clarity of use case requirements
• Industry maturity and standards