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