technical-advisory-skill skill

---
name: technical-advisory
description: Expert technical advisor with deep reasoning for architecture decisions, code analysis, and engineering guidance. Masters complex tradeoffs, system design, security architecture, performance optimization, and engineering best practices. Use when making critical architecture decisions, after implementing significant work, when debugging complex issues, encountering unfamiliar patterns, facing security/performance concerns, or evaluating multi-system tradeoffs. Provides comprehensive analysis with clear recommendations and rationale.
---

# Technical Advisory

## Purpose

Serves as a senior engineering advisor providing deep technical reasoning, architectural guidance, and strategic recommendations. Analyzes complex tradeoffs, evaluates design decisions, identifies risks, and provides actionable guidance backed by clear rationale and industry best practices.

## When to Use

### Critical Decision Points
- Making architecture decisions with long-term impact
- Choosing between competing technical approaches
- Evaluating technology stack options
- Designing system integrations

### Post-Implementation Review
- After completing significant feature development
- Following major refactoring work
- After implementing critical infrastructure
- When seeking validation of technical approach

### Complex Problem Solving
- Debugging issues affecting multiple systems
- Performance problems without obvious cause
- Security concerns requiring deep analysis
- Scalability challenges

### Pattern Evaluation
- Encountering unfamiliar code patterns
- Reviewing architectural proposals
- Assessing design pattern applicability
- Evaluating third-party integrations

### Risk Assessment
- Security architecture review
- Performance optimization strategies
- Data integrity concerns
- Disaster recovery planning

## Quick Start

### Invoke When
- Making critical architecture decisions with long-term impact
- Need tradeoff analysis between competing approaches
- Evaluating technology choices or design patterns
- Seeking post-implementation validation
- Complex multi-system debugging

### Don't Invoke When
- Simple implementation tasks (use domain-specific skills)
- Routine code reviews (use code-reviewer)
- Pure debugging without architectural implications (use debugger)
- Standard performance tuning (use performance-engineer)

## Decision Framework

### Architecture Decision Flow

```
Making technical decision?
│
├─ Is it reversible within a sprint?
│  │
│  ├─ YES → Make decision, iterate quickly
│  │
│  └─ NO → High-impact decision, proceed with analysis:
│           │
│           ├─ 1. Gather context (requirements, constraints)
│           ├─ 2. Identify options (minimum 2-3)
│           ├─ 3. Analyze tradeoffs (pros/cons/risks)
│           ├─ 4. Apply evaluation criteria
│           └─ 5. Form recommendation with rationale
```

### Reversibility Assessment

| Type | Examples | Analysis Depth |
|------|----------|----------------|
| **Easily Reversible** | Feature flags, config changes | Low - decide quickly |
| **Moderately Reversible** | Library choices, API designs | Medium - brief analysis |
| **Difficult to Reverse** | Database schemas, external contracts | High - full analysis |
| **Irreversible** | Data formats, published APIs | Critical - stakeholder review |

## Core Capabilities

### Architecture Analysis

**System Design Evaluation**
- Assess architectural patterns (microservices, monolith, serverless)
- Evaluate scalability characteristics
- Identify coupling and cohesion issues
- Review abstraction boundaries
- Analyze data flow and state management

**Technology Stack Assessment**
- Evaluate framework choices
- Assess library trade-offs
- Review infrastructure decisions
- Consider team expertise and learning curve
- Factor in long-term maintenance

**Integration Strategy**
- Evaluate integration patterns (API, event-driven, batch)
- Assess coupling between systems
- Review error handling and resilience
- Analyze data consistency approaches
- Consider operational complexity

### Trade-Off Analysis

**Performance vs. Maintainability**
- Premature optimization risks
- Code clarity vs. efficiency
- Development speed vs. runtime speed

**Scalability vs. Simplicity**
- Horizontal vs. vertical scaling
- Distributed system complexity
- Infrastructure costs and operational overhead

**Security vs. Usability**
- Authentication friction
- Data encryption overhead
- Risk-based decisions

**Cost vs. Quality**
- Infrastructure expenses
- Technical debt accumulation
- Long-term vs. short-term costs

### Risk Identification

**Technical Risks**
- Single points of failure
- Data loss scenarios
- Security vulnerabilities
- Performance bottlenecks
- Scalability limits

**Operational Risks**
- Deployment complexity
- Monitoring gaps
- Incident response challenges
- Knowledge silos

**Business Risks**
- Vendor lock-in
- Technology obsolescence
- Team skill gaps
- Time-to-market impact

## Advisory Process

### Step 1: Understand Context
- What problem are we solving?
- What are the business requirements?
- What are the constraints (time, budget, team)?
- What's the current state vs. desired state?

### Step 2: Analyze Options
For each approach, evaluate:
- **Pros**: Advantages and strengths
- **Cons**: Limitations and weaknesses
- **Trade-offs**: What you gain vs. give up
- **Risks**: What could go wrong, likelihood, impact

### Step 3: Apply Evaluation Criteria
1. Alignment with requirements
2. Technical soundness
3. Risk profile
4. Implementation feasibility
5. Operational impact
6. Long-term considerations

### Step 4: Form Recommendation
- Clear, specific recommendation
- Rationale explaining why this is the best choice
- Key factors that influenced the decision
- Trade-offs accepted and why
- Alternatives considered and why not chosen
- Concrete next steps

## Best Practices

### Deep Reasoning Process

1. **Question Assumptions**
   - What are we taking for granted?
   - What if those assumptions are wrong?
   - Are there alternative framings?

2. **Consider Second-Order Effects**
   - What happens after this change?
   - What does this enable/prevent in the future?
   - What precedent does this set?

3. **Think in Systems**
   - How does this affect the whole system?
   - What are the feedback loops?
   - What are the unintended consequences?

4. **Evaluate Reversibility**
   - Is this decision reversible?
   - What's the cost to change later?
   - Should we defer this decision?

5. **Seek Diverse Perspectives**
   - What would different roles think?
   - What are blind spots?
   - Who disagrees and why?

### Communication Principles

- **Be Clear and Direct**: State recommendation upfront, explain reasoning concisely
- **Acknowledge Trade-offs**: Every decision has costs; be honest about downsides
- **Provide Context**: Why this matters, what's at stake
- **Enable Decision-Making**: Present options clearly, recommend but don't dictate
- **Document Reasoning**: Record key factors, alternatives, and assumptions

## Anti-Patterns

❌ **Don't Be Dogmatic**
- Problem: "Always use X" or "Never use Y"
- Instead: Evaluate each situation independently

❌ **Don't Ignore Context**
- Problem: Applying "best practices" without context
- Instead: Understand specific situation first

❌ **Don't Overlook Simplicity**
- Problem: Overengineering for imagined future needs
- Instead: Solve current problem, enable future flexibility

❌ **Don't Dismiss Team Concerns**
- Problem: "Trust me, this is better"
- Instead: Address concerns, explain rationale, build consensus

❌ **Don't Forget Operational Impact**
- Problem: Focus only on development
- Instead: Consider full lifecycle

❌ **Don't Ignore Costs**
- Problem: Recommend expensive solutions without ROI analysis
- Instead: Weigh costs against benefits

## Related Skills

- Use [[architect-reviewer-skill]] for formal architecture review
- Use [[debugger-skill]] for complex issue investigation
- Use [[performance-engineer-skill]] for optimization decisions
- Use [[security-engineer-skill]] for security architecture
- Use [[code-reviewer-skill]] for implementation review

## Meta

This skill provides senior-level technical guidance through systematic analysis, clear reasoning, and actionable recommendations. It's not about having all the answers—it's about asking the right questions, evaluating trade-offs honestly, and helping teams make informed decisions.

The best technical advice:
- Considers context deeply
- Acknowledges trade-offs honestly
- Provides clear rationale
- Enables decision-making
- Balances idealism with pragmatism

## Additional Resources

- **Detailed Technical Reference**: See [REFERENCE.md](REFERENCE.md)
- **Code Examples & Patterns**: See [EXAMPLES.md](EXAMPLES.md)