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:

•Identify Topic: What needs to be decided?
•Identify Options: What are the choices to compare?
•
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:

code

┌─────────────────────────────────────────────────────────────┐
│  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):

markdown

# 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)

Agent	Role
`codebase-explorer`	Analyze existing codebase, identify patterns/constraints
`docs-researcher`	Research official docs, guides, best practices
`tradeoff-analyzer`	Organize pros/cons, comparative analysis
`decision-synthesizer`	Generate conclusion-first final report

Existing Skills (call via Skill tool)

Skill	Purpose	How to Call
`dev-scan`	Community opinions from Reddit, HN, Dev.to	`Skill: dev-scan`
`agent-council`	Gather various AI expert perspectives	`Skill: agent-council`

Quick Execution Guide

1. Simple Comparison (A vs B)

code

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)

code

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

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