analysis
/analysis
Analyze feature requirements, dependencies, and security considerations. Use when starting feature implementation from GitHub issues to understand scope, technical feasibility, and risks.
- Author
- matteocervelli ↗
- Repository
- llms ↗
- Licence
- MIT
- Last repository change
- 21.05.2026
Assessment and security
- Files in this package
- 4
- Scripts
- 1
- HTML comments
- 0
- URLs in SKILL.md
- 0
No signals detected. Repository changed on 21.05.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 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
- Purpose
- When to Use
- Analysis Workflow
- Output Format
- Best Practices
- Supporting Resources
- Example Usage
- Integration with Feature Implementation Flow
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
| Repository | Score | Licence |
|---|---|---|
| This page · matteocervelli/llms | 100 | MIT |
| oscarks/spectionflow | 100 | MIT |
| cloudfieldcz/cf-powers | 100 | MIT |
| R-CCS-HPBD/r4 | 90 | Apache-2.0 |
| clawic/skills | 90 | MIT |
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.