Tech Decision

Tech Decision - Deep Technical Decision Analysis

Skill for systematically analyzing technical decisions and deriving comprehensive conclusions.

Core Principle

Conclusion First: All reports present conclusion first, then provide evidence.

Use Cases

• Library/framework selection (React vs Vue, Prisma vs TypeORM)
• Architecture pattern decisions (Monolith vs Microservices, REST vs GraphQL)
• Implementation approach selection (Server-side vs Client-side, Polling vs WebSocket)
• Tech stack decisions (language, database, infrastructure, etc.)

Decision Workflow

Phase 1: Problem Definition

Clarify decision topic and context:

1. Identify Topic: What needs to be decided?
2. Identify Options: What are the choices to compare?
3. Establish Criteria: What criteria to evaluate by?
   • Performance, learning curve, ecosystem, maintainability, cost, etc.
   • Set priority based on project characteristics
   • See references/evaluation-criteria.md for detailed criteria

Phase 2: Parallel Information Gathering

Gather information from multiple sources simultaneously. Must run in parallel:

┌─────────────────────────────────────────────────────────────┐
│  Run simultaneously (parallel with Task tool)               │
├─────────────────────────────────────────────────────────────┤
│  1. codebase-explorer agent                                 │
│     → Analyze existing codebase, identify patterns/constraints│
│                                                             │
│  2. docs-researcher agent                                   │
│     → Research official docs, guides, best practices        │
│                                                             │
│  3. Skill: dev-scan                                         │
│     → Gather community opinions (Reddit, HN, Dev.to, etc.)  │
│                                                             │
│  4. Skill: agent-council                                    │
│     → Gather various AI expert perspectives                 │
│                                                             │
│  5. [Optional] Context7 MCP                                 │
│     → Query latest docs per library                         │
└─────────────────────────────────────────────────────────────┘

Phase 3: Synthesis Analysis

Run tradeoff-analyzer agent with gathered information:

• Organize pros/cons per option
• Score by evaluation criteria
• Organize conflicting opinions
• Evaluate reliability (source-based)

Phase 4: Final Report Generation

Generate conclusion-first comprehensive report with decision-synthesizer agent (detailed template: references/report-template.md):

# Technical Decision Report: [Topic]

## Conclusion (Executive Summary)
**Recommendation: [Option X]**
[1-2 sentence key reason]

## Evaluation Criteria and Weights
| Criteria | Weight | Description |
|------|--------|------|
| Performance | 30% | ... |
| Learning Curve | 20% | ... |

## Option Analysis

### Option A: [Name]
**Pros:**
- [Pro 1] (Source: official docs)
- [Pro 2] (Source: Reddit r/webdev)

**Cons:**
- [Con 1] (Source: HN discussion)

**Good fit for:** [Scenario]

## Comprehensive Comparison
| Criteria | Option A | Option B | Option C |
|------|----------|----------|----------|
| Performance | ⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐ |
| **Total** | **X pts** | **Y pts** | **Z pts** |

## Recommendation Rationale
1. [Key reason 1 with source]
2. [Key reason 2 with source]

## Risks and Considerations
- [Consideration 1]
- [Consideration 2]

Resources Used

Agents (this plugin)

Existing Skills (call via Skill tool)

Quick Execution Guide

1. Simple Comparison (A vs B)

User: "React vs Vue which is better?"

Execute:
1. Task docs-researcher + Task codebase-explorer (parallel)
2. Skill: dev-scan
3. Task tradeoff-analyzer
4. Task decision-synthesizer

2. Deep Analysis (complex decision)

User: "Thinking about which state management library to use"

Execute:
1. Task codebase-explorer (analyze current state)
2. Parallel:
   - Task docs-researcher (Redux, Zustand, Jotai, Recoil, etc.)
   - Skill: dev-scan
   - Skill: agent-council
3. Task tradeoff-analyzer
4. Task decision-synthesizer

Notes

1. Provide Context: More accurate analysis with project characteristics, team size, existing tech stack
2. Confirm Criteria: First confirm what criteria matter to user
3. Show Reliability: Mark unclear or outdated sources
4. Conclusion First: Always present conclusion first