Feature Analysis Skill

Purpose

This skill provides systematic analysis of feature requirements from GitHub issues, evaluating technical feasibility, dependencies, security implications, and implementation scope.

When to Use

•Starting feature implementation from a GitHub issue
•Need to understand requirements and acceptance criteria
•Evaluating technical approach and dependencies
•Identifying security considerations early
•Scoping effort and potential risks

Analysis Workflow

1. Requirements Extraction

From GitHub Issue:

•Parse issue title, description, and acceptance criteria
•Extract functional and non-functional requirements
•Identify user stories and use cases
•Review issue comments for clarifications
•Check linked issues and dependencies

Deliverable: Structured requirements list with priorities

2. Technical Stack Evaluation

Assess Technology Fit:

•Review project's TECH-STACK.md for current technologies
•Identify required libraries/frameworks
•Check version compatibility
•Evaluate performance implications
•Consider maintenance burden

Tools to Use:

•Read TECH-STACK.md and relevant documentation
•Use scripts/analyze_deps.py for dependency analysis
•Grep codebase for similar patterns

Deliverable: Technology recommendations with rationale

3. Dependency Analysis

Identify Dependencies:

•External libraries (pip/npm/cargo packages)
•Internal modules and services
•Database schema changes
•API contracts
•Configuration requirements

Check for Conflicts:

bash

# Use the analyze_deps script
python scripts/analyze_deps.py --feature <feature-name>

Deliverable: Dependency map with conflict analysis

4. Security Assessment

Review Security Implications:

•Authentication/authorization requirements
•Input validation needs
•Data sensitivity (PII, credentials, etc.)
•API security (rate limiting, CORS, etc.)
•Dependency vulnerabilities

Use Checklist: Refer to security-checklist.md for systematic review

Deliverable: Security risk assessment and mitigation plan

5. Scope Definition

Define Boundaries:

•Core functionality (must-have)
•Extended functionality (should-have)
•Future enhancements (could-have)
•Out of scope (won't-have)

Estimate Complexity:

•Lines of code (rough estimate)
•Number of modules/files
•Test coverage requirements
•Documentation needs

Deliverable: Scope statement with effort estimate

Output Format

Create an analysis report with:

markdown

# Feature Analysis: [Feature Name]

## Requirements Summary
- [ ] Requirement 1
- [ ] Requirement 2
...

## Technical Approach
**Recommended Stack:** Python 3.9+, pytest, pydantic
**Key Libraries:** [list]
**Architecture Pattern:** [pattern]

## Dependencies
**External:**
- package-name==version (reason)

**Internal:**
- module.submodule (reason)

## Security Considerations
**Risk Level:** Low/Medium/High
**Key Concerns:**
- [concern 1]: [mitigation]

## Scope
**In Scope:**
- [feature 1]

**Out of Scope:**
- [deferred item]

**Effort Estimate:** [hours/days]

## Recommendations
1. [Recommendation 1]
2. [Recommendation 2]

Best Practices

Requirements Analysis:

•Always check requirements-checklist.md for completeness
•Clarify ambiguous requirements before proceeding
•Document assumptions explicitly
•Consider edge cases and error scenarios

Technical Evaluation:

•Prefer existing project patterns over new approaches
•Consider maintainability over cleverness
•Check for similar existing implementations
•Evaluate performance implications early

Security First:

•Run security-checklist.md for all features
•Flag high-risk items for review
•Never skip input validation planning
•Consider data privacy implications

Scope Management:

•Be conservative with estimates
•Identify MVP vs. enhanced features
•Call out dependencies that block progress
•Document what's explicitly out of scope

Supporting Resources

•requirements-checklist.md: Systematic requirements validation
•security-checklist.md: Security considerations framework
•scripts/analyze_deps.py: Automated dependency analysis

Example Usage

bash

# 1. Fetch issue details
Use mcp__github-mcp__get_issue to retrieve issue #<number>

# 2. Review requirements
Work through requirements-checklist.md systematically

# 3. Analyze dependencies
python scripts/analyze_deps.py --feature feature-name

# 4. Security review
Complete security-checklist.md

# 5. Generate analysis report
Create report in docs/implementation/feature-name-analysis.md

Integration with Feature Implementation Flow

Input: GitHub issue number Process: Systematic analysis using checklists and scripts Output: Analysis report + recommendations Next Step: Design skill for architecture planning