alirezarezvani/claude-code-skill-factory / generated-skills/tech-stack-evaluator
tech-stack-evaluator
VerifiedComprehensive technology stack evaluation and comparison tool with TCO analysis, security assessment, and intelligent recommendations for engineering teams
| File | Kind | Size |
|---|---|---|
| HOW_TO_USE.md | markdown | 9.0 KB |
| README.md | markdown | 18.8 KB |
| SKILL.md | skill md | 14.6 KB |
| ecosystem_analyzer.py | script | 16.1 KB |
| expected_output_comparison.json | config | 1.9 KB |
| format_detector.py | script | 12.3 KB |
| migration_analyzer.py | script | 20.1 KB |
| report_generator.py | script | 15.5 KB |
| sample_input_structured.json | config | 1.1 KB |
| sample_input_tco.json | config | 1.1 KB |
| sample_input_text.json | config | 237 B |
| security_assessor.py | script | 17.3 KB |
| stack_comparator.py | script | 12.1 KB |
| tco_calculator.py | script | 15.8 KB |
HOW_TO_USE.md
View on GitHub# How to Use the Technology Stack Evaluator Skill
The Technology Stack Evaluator skill provides comprehensive evaluation and comparison of technologies, frameworks, and complete technology stacks for engineering teams.
## Quick Start Examples
### Example 1: Simple Technology Comparison
**Conversational (Easiest)**:
```
Hey Claude—I just added the "tech-stack-evaluator" skill. Can you compare React vs Vue for building a SaaS dashboard?
```
**What you'll get**:
- Executive summary with recommendation
- Comparison matrix with scores
- Top 3 pros and cons for each
- Confidence level
- Key decision factors
---
### Example 2: Complete Stack Evaluation
```
Hey Claude—I just added the "tech-stack-evaluator" skill. Can you evaluate this technology stack for a real-time collaboration platform:
- Frontend: Next.js
- Backend: Node.js + Express
- Database: PostgreSQL
- Real-time: WebSockets
- Hosting: AWS
Include TCO analysis and ecosystem health assessment.
```
**What you'll get**:
- Complete stack evaluation
- TCO breakdown (5-year projection)
- Ecosystem health scores
- Security assessment
- Detailed recommendations
---
### Example 3: Migration Analysis
```
Hey Claude—I just added the "tech-stack-evaluator" skill. We're considering migrating from Angular.js (1.x) to React. Our codebase:
- 75,000 lines of code
- 300 components
- 8-person development team
- Must minimize downtime
Can you assess migration complexity, effort, risks, and timeline?
```
**What you'll get**:
- Migration complexity score (1-10)
- Effort estimate (person-months and timeline)
- Risk assessment (technical, business, team)
- Phased migration plan
- Success criteria
---
### Example 4: TCO Analysis
```
Hey Claude—I just added the "tech-stack-evaluator" skill. Calculate total cost of ownership for AWS vs Azure for our workload:
- 50 EC2/VM instances (growing 25% annually)
- 20TB database storage
- Team: 12 developers
- 5-year projection
Include hidden costs like technical debt and vendor lock-in.
```
**What you'll get**:
- 5-year TCO breakdown
- Initial vs operational costs
- Scaling cost projections
- Cost per user metrics
- Hidden costs (technical debt, vendor lock-in, downtime)
- Cost optimization opportunities
---
### Example 5: Security & Compliance Assessment
```
Hey Claude—I just added the "tech-stack-evaluator" skill. Assess the security posture of our current stack:
- Express.js (Node.js)
- MongoDB
- JWT authentication
- Hosted on AWS
We need SOC2 and GDPR compliance. What are the gaps?
```
**What you'll get**:
- Security score (0-100) with grade
- Vulnerability analysis (CVE counts by severity)
- Compliance readiness for SOC2 and GDPR
- Missing security features
- Recommendations to improve security
---
### Example 6: Cloud Provider Comparison
```
Hey Claude—I just added the "tech-stack-evaluator" skill. Compare AWS vs Azure vs GCP for machine learning workloads:
- Priorities: GPU availability (40%), Cost (30%), ML ecosystem (20%), Support (10%)
- Need: High GPU availability for model training
- Team: 5 ML engineers, experienced with Python
Generate weighted decision matrix.
```
**What you'll get**:
- Weighted comparison matrix
- Scores across all criteria
- Best performer by category
- Overall recommendation with confidence
- Pros/cons for each provider
---
## Input Formats Supported
### 1. Conversational Text (Easiest)
Just describe what you want in natural language:
```
"Compare PostgreSQL vs MongoDB for a SaaS application"
"Evaluate security of our Express.js + JWT stack"
"Calculate TCO for migrating to microservices"
```
### 2. Structured JSON
For precise control over evaluation parameters:
```json
{
"comparison": {
"technologies": ["React", "Vue", "Svelte"],
"use_case": "Enterprise dashboard",
"weights": {
"performance": 25,
"developer_experience": 30,
"ecosystem": 25,
"learning_curve": 20
}
}
}
```
### 3. YAML (Alternative Structured Format)
```yaml
comparison:
technologies:
- React
- Vue
use_case: SaaS dashboard
priorities:
- Developer productivity
- Ecosystem maturity
```
### 4. URLs for Ecosystem Analysis
```
"Analyze ecosystem health for these technologies:
- https://github.com/facebook/react
- https://github.com/vuejs/vue
- https://www.npmjs.com/package/react"
```
The skill automatically detects the format and parses accordingly!
---
## Report Sections Available
You can request specific sections or get the full report:
### Available Sections:
1. **Executive Summary** (200-300 tokens) - Recommendation + top pros/cons
2. **Comparison Matrix** - Weighted scoring across all criteria
3. **TCO Analysis** - Complete cost breakdown (initial + operational + hidden)
4. **Ecosystem Health** - Community size, maintenance, viability
5. **Security Assessment** - Vulnerabilities, compliance readiness
6. **Migration Analysis** - Complexity, effort, risks, timeline
7. **Performance Benchmarks** - Throughput, latency, resource usage
### Request Specific Sections:
```
"Compare Next.js vs Nuxt.js. Include only: ecosystem health and performance benchmarks. Skip TCO and migration analysis."
```
---
## What to Provide
### For Technology Comparison:
- Technologies to compare (2-5 recommended)
- Use case or application type (optional but helpful)
- Priorities/weights (optional, uses sensible defaults)
### For TCO Analysis:
- Technology/platform name
- Team size
- Current costs (hosting, licensing, support)
- Growth projections (user growth, scaling needs)
- Developer productivity factors (optional)
### For Migration Assessment:
- Source technology (current stack)
- Target technology (desired stack)
- Codebase statistics (lines of code, number of components)
- Team information (size, experience level)
- Constraints (downtime tolerance, timeline)
### For Security Assessment:
- Technology stack components
- Security features currently implemented
- Compliance requirements (GDPR, SOC2, HIPAA, PCI-DSS)
- Known vulnerabilities (if any)
### For Ecosystem Analysis:
- Technology name or GitHub/npm URL
- Specific metrics of interest (optional)
---
## Output Formats
The skill adapts output based on your environment:
### Claude Desktop (Rich Markdown)
- Formatted tables with visual indicators
- Expandable sections
- Color-coded scores (via markdown formatting)
- Decision matrices
### CLI/Terminal (Terminal-Friendly)
- ASCII tables
- Compact formatting
- Plain text output
- Copy-paste friendly
The skill automatically detects your environment!
---
## Advanced Usage
### Custom Weighted Criteria:
```
"Compare React vs Vue vs Svelte.
Priorities (weighted):
- Developer experience: 35%
- Performance: 30%
- Ecosystem: 20%
- Learning curve: 15%"
```
### Multiple Analysis Types:
```
"Evaluate Next.js for our enterprise SaaS platform.
Include: TCO (5-year), ecosystem health, security assessment, and performance vs Nuxt.js."
```
### Progressive Disclosure:
```
"Compare AWS vs Azure. Start with executive summary only."
(After reviewing summary)
"Show me the detailed TCO breakdown for AWS."
```
---
## Tips for Best Results
1. **Be Specific About Use Case**: "Real-time collaboration platform" is better than "web app"
2. **Provide Context**: Team size, experience level, constraints help generate better recommendations
3. **Set Clear Priorities**: If cost is more important than performance, say so with weights
4. **Request Incremental Analysis**: Start with executive summary, then drill into specific sections
5. **Include Constraints**: Zero-downtime requirement, budget limits, timeline pressure
6. **Validate Assumptions**: Review the TCO assumptions and adjust if needed
---
## Common Questions
**Q: How current is the data?**
A: The skill uses current data sources when available (GitHub, npm, CVE databases). Ecosystem metrics are point-in-time snapshots.
**Q: Can I compare more than 2 technologies?**
A: Yes! You can compare 2-5 technologies. More than 5 becomes less actionable.
**Q: What if I don't know the exact data for TCO analysis?**
A: The skill uses industry-standard defaults. Just provide what you know (team size, rough costs) and it will fill in reasonable estimates.
**Q: Can I export reports?**
A: Yes! The skill can generate markdown reports that you can save or export.
**Q: How do confidence scores work?**
A: Confidence (0-100%) is based on:
- Score gap between options (larger gap = higher confidence)
- Data completeness
- Clarity of requirements
**Q: What if technologies are very close in scores?**
A: The skill will report low confidence and highlight that it's a close call, helping you understand there's no clear winner.
---
## Need Help?
If results aren't what you expected:
1. **Clarify your use case** - Be more specific about requirements
2. **Adjust priorities** - Set custom weights for what matters most
3. **Provide more context** - Team skills, constraints, business goals
4. **Request specific sections** - Focus on what's most relevant
Example clarification:
```
"The comparison seemed to favor React, but we're a small team (3 devs) with no React experience. Can you re-evaluate with learning curve weighted at 40%?"
```
The skill will adjust the analysis based on your refined requirements!
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 468k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 468k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 468k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 194k | Updated | Claude CodeCodex | Verified | Install |