Investigation & Analysis Skill

Purpose

Analyze feature requests or refactor plans to determine investment value and provide actionable recommendations.

Auto-Activation Triggers

This skill activates when the user:

Mentions investigating a feature or idea
Asks "should we build this?"
Requests feasibility analysis
Wants to evaluate ROI or cost/benefit
Asks "is this worth doing?"
Mentions analyzing a refactor plan

Analysis Process

1. Context Gathering

Automatically check:

Review relevant existing code/architecture
Search memory patterns for similar work
Identify affected components and dependencies
Review procedural memory for proven patterns

Tools to use:

Grep to search codebase for related functionality
Glob to find relevant files
Read to examine current implementation

2. Investment Assessment

Evaluate across three dimensions:

Technical Factors

Implementation Complexity (1-10 scale)
Risk Assessment (breaking changes, dependencies)
Technical Debt Impact (reduces/increases/neutral)
Performance Implications

Business Factors

User Value Delivered
Alignment with Project Goals
Time to Implement
Return on Investment

Strategic Factors

Architecture Impact
Reusability Potential
Future Flexibility

3. Recommendation Framework

Question 1: Is it worth the investment?

YES - High value, reasonable cost, low risk
NO - Low value, high cost, or high risk
CONDITIONAL - Worth it if specific conditions met

Question 2: What should we do with the request?

KEEP AS-IS - Plan is solid
MODIFY - Suggest specific improvements
PIVOT - Recommend alternative approach
DEFER - Not now, revisit when [conditions]
REJECT - Clear reasons why not

4. Response Format

markdown

## Investigation: [Feature/Refactor Name]

### Investment Analysis

**Worth the Investment:** [YES/NO/CONDITIONAL]

[Executive summary in 2-3 sentences]

**Key Metrics:**
- Complexity: [X/10]
- Implementation Time: [estimate]
- Risk Level: [Low/Medium/High]
- Value Delivered: [Low/Medium/High]
- ROI: [High/Medium/Low]

### Recommendation: [KEEP/MODIFY/PIVOT/DEFER/REJECT]

[Detailed explanation with supporting evidence]

#### Technical Analysis
[Key technical findings from codebase investigation]

#### Business Justification
[Value proposition and alignment with goals]

#### Proposed Modifications (if MODIFY)
1. [Specific change with rationale]
2. [Specific change with rationale]

#### Alternative Approach (if PIVOT)
[Description of better approach]

### Implementation Considerations

**Prerequisites:**
- [Required before starting]

**Success Criteria:**
- [Measurable outcome]

**Potential Blockers:**
- [Risk] → Mitigation: [strategy]

### Evidence & References
- Code files examined: [file paths]
- Similar patterns in memory: [references]

Best Practices

1. Be Evidence-Based

Reference actual code files examined
Cite similar attempts from memory
Include metrics where available

2. Be Pragmatic

Focus on practical impact
Consider current capacity and priorities
Balance ideal vs. practical constraints

3. Provide Actionable Guidance

Specific next steps if proceeding
Clear reasons if not proceeding
Measurable success criteria

4. Check Memory First

Always consult:

.claude/memory/active/quick-reference.md
.claude/memory/active/procedural-memory.md

5. Leverage Existing Work

Search for similar features already implemented
Identify reusable patterns and components
Check if request duplicates existing functionality

Integration

After Investigation:

If approved → Suggest /orchestrate-tasks for implementation
If complex → Suggest /plan-as-group for collaborative planning

Update Context:

Document investigation results
Add insights to procedural memory if reusable

Examples

Feature Request

User: "Should we add real-time collaboration to the editor?"

Skill:

Searches codebase for existing editor architecture
Checks memory for similar implementations
Evaluates WebSocket/polling options
Assesses complexity vs. user value
Provides recommendation with implementation path

Refactor Plan

User: "I'm thinking about refactoring to async/await"