Skip to content
Skills Library
Management & product · Analysis

analysis

/analysis

Analyze feature requirements, dependencies, and security considerations. Use when starting feature implementation from GitHub issues to understand scope, technical feasibility, and risks.

Repository
llms ↗
Licence
MIT
Last repository change
21.05.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
4
Scripts
1
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.05.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 1 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/analyze_deps.py

What it does and when to use it

Analyze feature requirements, dependencies, and security considerations. Use when starting feature implementation from GitHub issues to understand scope, technical feasibility, and risks.

Original author description

Analyze feature requirements, dependencies, and security considerations. Use when starting feature implementation from GitHub issues to understand scope, technical feasibility, and risks.

How it works

  1. Purpose
  2. When to Use
  3. Analysis Workflow
  4. Output Format
  5. Best Practices
  6. Supporting Resources
  7. Example Usage
  8. Integration with Feature Implementation Flow
Original SKILL.md headings · 192 lines, 598 words
SKILL.md preview
---
name: analysis
description: Analyze feature requirements, dependencies, and security considerations. Use when starting feature implementation from GitHub issues to understand scope, technical feasibility, and risks.
allowed-tools:
  - Read
  - Grep
  - Glob
  - Bash
  - mcp__github-mcp__get_issue
  - mcp__github-mcp__get_issue_comments
  - mcp__github-mcp__search_issues
---

# 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
Files in this package (4)
  • SKILL.md 5 KB
  • requirements-checklist.md 6 KB
  • security-checklist.md 9 KB
  • scripts/analyze_deps.py 9 KB

Versions

RepositoryScoreLicence
This page · matteocervelli/llms100MIT
oscarks/spectionflow100MIT
cloudfieldcz/cf-powers100MIT
R-CCS-HPBD/r490Apache-2.0
clawic/skills90MIT

Identical content appears in 2 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version 7d7f6691a622 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100plan-feature
    Structured feature planning workflow. Use when the user says "plan a feature", "design this", "how should we build", "feasibility check", or any pre-implementation planning work. Covers requirements, investigation, feasibility, and implementation planning.
  • 100requirements-analysis
    Analyze product and technical requirements for the PigeonPod project with software engineering rigor. Use when users ask to evaluate a feature, enhancement, non-functional requirement, integration, or migration for value, feasibility, architecture fit, implementation impact,…
  • 100feature
    Develop requirements, dependencies and an implementation approach for new or deliberately changed behavior. Use for /haechi:feature or when those methods help an authorized product change.
  • 100req-analyze
    Requirements analysis — problem decomposition, stakeholder scan, requirement structuring. Produces 1-requirements.md (Phase 1 lifecycle doc, NOT the per-task request ticket — for those use /create-request). Use when: analyzing needs before tech spec, decomposing requirements,…
  • 85technical-feasibility-review
    Helps a PM interpret a technical brief, architecture document, or solution architect output. Translates technical complexity into delivery-relevant language, surfaces risks hidden in technical decisions, identifies the right questions to raise with the SA or tech lead, and…
  • 90product-spec
    Write a product requirements document (PRD) or feature spec. Use when the user describes a feature or product idea and asks for a spec, PRD, requirements, user stories, "scope this", or something to hand to engineers or designers.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.