What is investigation-analysis?

This Claude skill provides a comprehensive framework for evaluating technical proposals, feature requests, and refactoring plans. By performing deep codebase analysis and assessing technical, business, and strategic dimensions, it helps teams determine the true investment value and feasibility of software projects. It ensures data-driven decision-making by providing structured recommendations on whether to proceed, pivot, or defer based on real-world architectural impact and ROI.

When should I use investigation-analysis?

investigation-analysis is useful in the following scenarios: • Evaluating the ROI and technical complexity of adding major new features, such as real-time collaboration or third-party integrations. • Assessing the risks, potential technical debt, and performance implications of large-scale codebase refactors. • Conducting feasibility studies for technical decisions by analyzing existing dependencies, architecture, and project constraints. • Providing stakeholders with evidence-based recommendations (Keep, Modify, Pivot, Defer, or Reject) for new product ideas or feature requests. • Analyzing the strategic alignment of a proposed technical change with long-term project goals and architectural flexibility.

name	Investigation & Analysis
description	Analyze feature requests, refactor plans, or technical decisions to determine investment value and provide recommendations. Use when user mentions investigating, analyzing, or asks "should we build this".
allowed-tools	Read, Grep, Glob

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

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