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