name	tech-stack-evaluator
description	Comprehensive technology stack evaluation and comparison tool with TCO analysis, security assessment, and intelligent recommendations for engineering teams

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:

Scoring & Comparison Matrix
- Weighted decision scores
- Head-to-head comparison tables
- Strengths and weaknesses
Financial Analysis
- TCO breakdown (5-year projection)
- ROI analysis
- Cost per user/request metrics
- Hidden cost identification
Ecosystem Health
- Community size and activity
- GitHub stars, npm downloads
- Release frequency and maintenance
- Issue response times
- Viability assessment
Security & Compliance
- Vulnerability count (CVE database)
- Security patch frequency
- Compliance readiness (GDPR, SOC2, HIPAA)
- Security scoring
Migration Analysis (when applicable)
- Migration complexity scoring
- Code change estimates
- Data migration requirements
- Downtime assessment
- Risk mitigation strategies
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

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

For TCO Analysis

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

For Migration Decisions

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

For Security Evaluation

Check Recent Vulnerabilities: Focus on last 12 months for current security posture
Review Patch Response Time: Fast patching is more important than zero vulnerabilities
Validate Compliance Claims: Vendor claims ≠ actual compliance readiness
Consider Supply Chain: Evaluate security of all dependencies
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

tech-stack-evaluator

Install Skill

SKILL.md