Skip to content
Back to search

awesome-skills-security

Security testing toolkit for AI Agent: curated SecLists wordlists, injection payloads, and expert agents for authorized pentesting, CTFs, and bug bounties

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/eyadkelleh--awesome-skills-security/badge.svg)](/listings/eyadkelleh--awesome-skills-security)

HTML

<a href="/listings/eyadkelleh--awesome-skills-security"><img src="/api/listings/eyadkelleh--awesome-skills-security/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Install from skills.sh (Recommended)

The easiest way to get started is to install from the [skills.sh](https://skills.sh/) directory using the open agent skills CLI:

# List all available skills in this repository
npx skills add Eyadkelleh/awesome-skills-security --list

# Install all 7 security skills
npx skills add Eyadkelleh/awesome-skills-security --skill '*' -y

# Install specific skills
npx skills add Eyadkelleh/awesome-skills-security --skill security-fuzzing --skill llm-testing -y

# Install to a specific agent (e.g. Cursor or Claude Code)
npx skills add Eyadkelleh/awesome-skills-security -a cursor -y
npx skills add Eyadkelleh/awesome-skills-security -a claude-code -y

# Install globally (available across all projects)
npx skills add Eyadkelleh/awesome-skills-security --skill '*' -g -y

Browse and discover this collection on skills.sh: [skills.sh/Eyadkelleh/awesome-skills-security](https://skills.sh/Eyadkelleh/awesome-skills-security)

Verify Installation

After installing, verify the skills are available:

# List installed skills
npx skills list

# Or ask your agent to use a skill
"Use the security-fuzzing skill to show me SQL injection payloads"

What You Get

Once installed, you'll have access to: - **7 Security Skill Categories**: Fuzzing, Passwords, Patterns, Payloads, Usernames, Web-shells, LLM Testing - **Curated SecLists Content**: Essential wordlists and payloads for security testing - **LLM Security Testing**: Comprehensive AI/ML security testing prompts and methodologies

Troubleshooting

**"No skills found"** - Ensure you're using the correct repo: `Eyadkelleh/awesome-skills-security` - Run `npx skills add Eyadkelleh/awesome-skills-security --list` to verify discovery - Each `SKILL.md` must have valid YAML frontmatter with `name` (lowercase, hyphens) and `description`

**"Skill not loading in agent"** - Verify the skill was installed to the correct agent directory (e.g. `.cursor/skills/`) - Try reinstalling: `npx skills add Eyadkelleh/awesome-skills-security --skill <name> -y` - Check your agent's documentation for skill loading requirements

**Need help?** - Open an issue on [GitHub](https://github.com/Eyadkelleh/awesome-skills-security/issues) - Check the [skills.sh directory](https://skills.sh/) and [Agent Skills spec](https://agentskills.io)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 523 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Awesome Security Skills: Security Collection
  2. [![skills.sh](https://skills.sh/b/Eyadkelleh/awesome-skills-security)](https://skills.sh/Eyadkelleh/awesome-skills-security)
  3. A curated collection of security testing resources packaged as agent skills, available on [skills.sh](https://skills.sh/)
  4. **Repository:** [Eyadkelleh/awesome-skills-security](https://github.com/Eyadkelleh/awesome-skills-security) · **skills.sh:** [Eyadkelleh/awesome-skills-security](https://skills.sh/Eyadkelleh/awesome-skills-security)
  5. ## Overview
  6. This repository contains a curated collection of security testing resources from [SecLists](https://github.com/danielmiessler/SecLists) packaged as [Agent Skills](https://agentskills.io) for use with Claude Code, Cursor, Codex, and [60+ other supported agents](https://skills.sh/). These skills provide instant access to essential wordlists, payloads, patterns, and web shells for authorized security testing, penetration testing, CTF competitions, and security research.
  7. The goal of this project is to provide organized, immediately accessible security testing resources that integrate seamlessly with AI agent workflows for:
  8. - Authorized penetration testing and security assessments
  9. - Bug bounty program research
  10. - CTF competition problem solving
  11. - Security tool development and testing
  12. - Educational security demonstrations
  13. - Vulnerability research in controlled environments
  14. ## Quick Start
  15. ### Install from skills.sh (Recommended)
  16. The easiest way to get started is to install from the [skills.sh](https://skills.sh/) directory using the open agent skills CLI:
  17. ```bash
  18. # List all available skills in this repository
  19. npx skills add Eyadkelleh/awesome-skills-security --list
  20. # Install all 7 security skills
  21. npx skills add Eyadkelleh/awesome-skills-security --skill '*' -y
  22. # Install specific skills
  23. npx skills add Eyadkelleh/awesome-skills-security --skill security-fuzzing --skill llm-testing -y
  24. # Install to a specific agent (e.g. Cursor or Claude Code)
  25. npx skills add Eyadkelleh/awesome-skills-security -a cursor -y
  26. npx skills add Eyadkelleh/awesome-skills-security -a claude-code -y
  27. # Install globally (available across all projects)
  28. npx skills add Eyadkelleh/awesome-skills-security --skill '*' -g -y
  29. ```
  30. Browse and discover this collection on skills.sh: [skills.sh/Eyadkelleh/awesome-skills-security](https://skills.sh/Eyadkelleh/awesome-skills-security)
  31. ### Verify Installation
  32. After installing, verify the skills are available:
  33. ```bash
  34. # List installed skills
  35. npx skills list
  36. # Or ask your agent to use a skill
  37. "Use the security-fuzzing skill to show me SQL injection payloads"
  38. ```
  39. ### What You Get
  40. Once installed, you'll have access to:
  41. - **7 Security Skill Categories**: Fuzzing, Passwords, Patterns, Payloads, Usernames, Web-shells, LLM Testing
  42. - **Curated SecLists Content**: Essential wordlists and payloads for security testing
  43. - **LLM Security Testing**: Comprehensive AI/ML security testing prompts and methodologies
  44. ### Troubleshooting
  45. **"No skills found"**
  46. - Ensure you're using the correct repo: `Eyadkelleh/awesome-skills-security`
  47. - Run `npx skills add Eyadkelleh/awesome-skills-security --list` to verify discovery
  48. - Each `SKILL.md` must have valid YAML frontmatter with `name` (lowercase, hyphens) and `description`
  49. **"Skill not loading in agent"**
  50. - Verify the skill was installed to the correct agent directory (e.g. `.cursor/skills/`)
  51. - Try reinstalling: `npx skills add Eyadkelleh/awesome-skills-security --skill <name> -y`
  52. - Check your agent's documentation for skill loading requirements
  53. **Need help?**
  54. - Open an issue on [GitHub](https://github.com/Eyadkelleh/awesome-skills-security/issues)
  55. - Check the [skills.sh directory](https://skills.sh/) and [Agent Skills spec](https://agentskills.io)
  56. ## Available Skills
  57. All skills live under `skills/` and are discoverable by the [skills.sh CLI](https://skills.sh/). Each skill has a `SKILL.md` with `name` and `description` frontmatter.
  58. | Skill ID | Description | Install command |
  59. |:---------|:------------|:----------------|
  60. | `security-fuzzing` | SQL, NoSQL, command injection, and LDAP fuzzing payloads | `npx skills add Eyadkelleh/awesome-skills-security --skill security-fuzzing -y` |
  61. | `security-passwords` | Curated password wordlists for authorized credential testing | `npx skills add Eyadkelleh/awesome-skills-security --skill security-passwords -y` |
  62. | `security-patterns` | API keys, credit cards, emails, and sensitive data patterns | `npx skills add Eyadkelleh/awesome-skills-security --skill security-patterns -y` |
  63. | `security-payloads` | XSS, XXE, template injection, and file upload payloads | `npx skills add Eyadkelleh/awesome-skills-security --skill security-payloads -y` |
  64. | `security-usernames` | Common username wordlists for enumeration | `npx skills add Eyadkelleh/awesome-skills-security --skill security-usernames -y` |
  65. | `security-webshells` | Web shell samples for detection and defensive testing | `npx skills add Eyadkelleh/awesome-skills-security --skill security-webshells -y` |
  66. | `llm-testing` | LLM bias, data leakage, alignment, and adversarial testing prompts | `npx skills add Eyadkelleh/awesome-skills-security --skill llm-testing -y` |
  67. ### Fuzzing (`security-fuzzing`)
  68. **Essential fuzzing payloads for vulnerability testing**
  69. - SQL injection testing payloads
  70. - Command injection patterns
  71. - NoSQL injection vectors
  72. - LDAP injection strings
  73. - Special character fuzzing
  74. - Authentication bypass patterns
  75. ### Passwords (`security-passwords`)
  76. **Curated password lists for authorized credential testing**
  77. - 500 worst passwords
  78. - 10K most common passwords
  79. - 100K NCSC password list
  80. - Dark web breach compilations
  81. - Probable password variations
  82. ### Pattern-Matching (`security-patterns`)
  83. **Sensitive data patterns for security testing**
  84. - API key detection patterns
  85. - Credit card format validation
  86. - Email address patterns
  87. - IP address discovery
  88. - SSN format matching
  89. - Phone number patterns
  90. ### Payloads (`security-payloads`)
  91. **Specialized attack payloads for testing**
  92. - XSS injection vectors
  93. - XXE payloads
  94. - Template injection
  95. - File upload bypasses
  96. - Path traversal strings
  97. ### Usernames (`security-usernames`)
  98. **Common username wordlists**
  99. - Default usernames
  100. - Common account names
  101. - Service-specific usernames
  102. - Admin account patterns
  103. ### Web-Shells (`security-webshells`)
  104. **Web shell samples for detection and analysis**
  105. - PHP web shells
  106. - ASP/ASPX shells
  107. - JSP shells
  108. - Python shells
  109. - Perl shells
  110. ### LLM Testing (`llm-testing`)
  111. **Comprehensive AI/ML security testing prompts**
  112. - Bias detection (gender, nationality, race/ethnicity)
  113. - Data leakage and privacy testing
  114. - Memory recall testing
  115. - Alignment and divergence attacks
  116. - Adversarial prompt resistance
  117. - AI safety evaluation
  118. ## Requirements
  119. - **Node.js** (for `npx skills` — the skills.sh install CLI)
  120. - A supported AI agent (Cursor, Claude Code, Codex, OpenCode, etc.)
  121. - Git for cloning the repository
  122. - Basic understanding of security testing concepts
  123. - Authorization for security testing on target systems
  124. ## Installation
  125. ### Method 1: skills.sh CLI (Recommended)
  126. Install skills into your agent using the [skills.sh](https://skills.sh/) ecosystem:
  127. ```bash
  128. # See what's available
  129. npx skills add Eyadkelleh/awesome-skills-security --list
  130. # Install everything
  131. npx skills add Eyadkelleh/awesome-skills-security --skill '*' -y
  132. # Install to Cursor only
  133. npx skills add Eyadkelleh/awesome-skills-security -a cursor --skill '*' -y
  134. # Update installed skills later
  135. npx skills update -y
  136. ```
  137. Skills are installed to your agent's skills directory (e.g. `.cursor/skills/` for Cursor, `.claude/skills/` for Claude Code). Use `-g` for a global install available across all projects.
  138. ### Method 2: Clone Repository
  139. Clone and use directly:
  140. ```bash
  141. git clone https://github.com/Eyadkelleh/awesome-skills-security.git
  142. cd awesome-skills-security
  143. ```
  144. ## Usage
  145. ### Using Skills in Natural Language
  146. Reference skills in your conversation with any supported agent:
  147. ```
  148. "Use the security-fuzzing skill to help me test for SQL injection vulnerabilities"
  149. "Show me common passwords from the security-passwords skill"
  150. "Help me detect exposed API keys using the security-patterns skill"
  151. "I need XSS payloads from the security-payloads skill"
  152. ```
  153. ### Practical Usage Examples
  154. **Example 1: SQL Injection Testing**
  155. ```
  156. "I need to test a login form for SQL injection. Use the security-fuzzing skill to show me relevant payloads"
  157. ```
  158. **Example 2: Password Auditing**
  159. ```
  160. "Use the security-passwords skill to show me the most common weak passwords to test against our password policy"
  161. ```
  162. **Example 3: Code Review for Secrets**
  163. ```
  164. "Use the security-patterns skill to help me scan this codebase for exposed API keys and credentials"
  165. ```
  166. **Example 4: CTF Challenge**
  167. ```
  168. "I'm working on a web exploitation CTF challenge. Use the security-payloads skill to help me approach this"
  169. ```
  170. **Example 5: LLM Security Testing**
  171. ```bash
  172. # Test for AI model biases
  173. "Use the llm-testing skill to help me test this AI model for gender bias"
  174. # Check for data leakage vulnerabilities
  175. "Use the llm-testing skill to test for data leakage and privacy issues in this LLM"
  176. # Comprehensive AI safety audit
  177. "I need to perform a red team assessment on this LLM. Use the llm-testing skill to show me prompts for bias detection, alignment testing, and adversarial resistance"
  178. ```
  179. ### Direct File Access
  180. If you cloned the repository, access wordlists directly:
  181. ```python
  182. # Example: Load SQL injection payloads
  183. with open('skills/security-fuzzing/references/Fuzzing/quick-SQLi.txt', 'r') as f:
  184. sqli_payloads = f.read().splitlines()
  185. # Example: Load common passwords
  186. with open('skills/security-passwords/references/500-worst-passwords.txt', 'r') as f:
  187. passwords = f.read().splitlines()
  188. # Example: Use in security testing
  189. for payload in sqli_payloads[:10]:
  190. test_injection(target_url, payload)
  191. ```
  192. ### Example Workflows
  193. **SQL Injection Testing (Authorized)**
  194. ```
  195. 1. Ask your agent to use the security-fuzzing skill
  196. 2. Request relevant payloads for your target database
  197. 3. Test in an authorized scope
  198. 4. Document all findings
  199. ```
  200. **CTF Challenge**
  201. ```
  202. 1. Describe the challenge to your agent
  203. 2. Ask it to use security-payloads or security-fuzzing as needed
  204. 3. Access relevant wordlists from the skill references
  205. ```
  206. **Bug Bounty Hunting**
  207. ```
  208. 1. Ask your agent to use the appropriate security skills for your target
  209. 2. Review scope and methodology
  210. 3. Use payloads and wordlists from the installed skills
  211. 4. Follow responsible disclosure practices
  212. ```
  213. ## Project Structure
  214. ```
  215. awesome-skills-security/
  216. ├── README.md # This file
  217. └── skills/ # skills.sh compatible skill directories
  218. ├── security-fuzzing/
  219. │ ├── SKILL.md # Skill metadata
  220. │ └── references/ # SQL/NoSQL/Command injection
  221. ├── security-passwords/
  222. │ ├── SKILL.md
  223. │ └── references/ # Password wordlists
  224. ├── security-patterns/
  225. │ ├── SKILL.md
  226. │ └── references/ # API keys, sensitive data
  227. ├── security-payloads/
  228. │ ├── SKILL.md
  229. │ └── references/ # XSS, XXE, file upload
  230. ├── security-usernames/
  231. │ ├── SKILL.md
  232. │ └── references/ # Username wordlists
  233. ├── security-webshells/
  234. │ ├── SKILL.md
  235. │ └── references/ # Web shell samples
  236. └── llm-testing/
  237. ├── SKILL.md
  238. └── ... # LLM security test prompts
  239. ```
  240. ## Features
  241. - **7 Skill Categories** - Fuzzing, Passwords, Patterns, Payloads, Usernames, Web-shells, LLM Testing
  242. - **Curated from SecLists** - Essential security testing wordlists and payloads
  243. - **AI/ML Security Testing** - Comprehensive LLM testing prompts for bias, alignment, and safety
  244. - **Multi-Agent Support** - Install via skills.sh into Cursor, Claude Code, Codex, and 60+ agents
  245. - **Ethical Guidelines** - Built-in reminders for authorized use only
  246. ## Security & Ethics
  247. ### Authorized Use Cases
  248. - Authorized penetration testing with written permission
  249. - Bug bounty programs (within documented scope)
  250. - CTF competitions and challenges
  251. - Security research in controlled lab environments
  252. - Testing your own systems and applications
  253. - Educational demonstrations with proper safeguards
  254. - Defensive security tool development
  255. - AI/ML security research and red team operations
  256. - LLM safety evaluation and bias testing
  257. - Responsible AI development and testing
  258. ### Prohibited Use Cases
  259. - Unauthorized access attempts against any system
  260. - Testing systems without explicit permission
  261. - Malicious activities or attacks
  262. - Privacy violations or data theft
  263. - Any illegal activities
  264. - Attacks against critical infrastructure
  265. - Mass exploitation or automated attacks
  266. ### Responsible Usage Guidelines
  267. 1. **Always obtain written authorization** before conducting security tests
  268. 2. **Stay within scope** of authorized testing boundaries
  269. 3. **Document all activities** during security assessments
  270. 4. **Report vulnerabilities responsibly** through proper disclosure channels
  271. 5. **Respect rate limits** and avoid denial-of-service conditions
  272. 6. **Protect sensitive data** discovered during testing
  273. 7. **Follow applicable laws** and regulations in your jurisdiction
  274. ## Why This Project Exists
  275. SecLists is an incredible resource containing over 6,000 files and 4.5GB of security testing data. However, its size and breadth can be overwhelming. This project:
  276. - **Curates essential lists** most commonly needed for security testing
  277. - **Organizes by category** for easy discovery and access
  278. - **Integrates with AI agents** via the skills.sh ecosystem for seamless workflow integration
  279. - **Provides clear documentation** on when and how to use each resource
  280. - **Emphasizes ethical use** with clear guidelines and warnings
  281. ## Source & Attribution
  282. All security testing resources in this repository are sourced from [SecLists](https://github.com/danielmiessler/SecLists) by Daniel Miessler and contributors.
  283. - **Original Repository:** https://github.com/danielmiessler/SecLists
  284. - **License:** MIT License
  285. - **Maintainer:** Daniel Miessler
  286. - **Contributors:** Security community worldwide
  287. This project is a curated, skill-packaged subset for agent skill integration. For the complete SecLists collection (4.5GB, 6,000+ files), visit the original repository.
  288. ## Best Practices
  289. ### When Using Password Lists
  290. - Only test against systems you own or have written authorization to test
  291. - Implement rate limiting to avoid account lockouts
  292. - Monitor for defensive responses (WAF blocks, account locks)
  293. - Use appropriate delays between attempts
  294. ### When Using Fuzzing Payloads
  295. - Test in isolated environments first
  296. - Validate input sanitization and output encoding
  297. - Check for secondary effects (logs, monitoring alerts)
  298. - Document all findings systematically
  299. ### When Using Web Shells
  300. - Only use for detection system validation
  301. - Test in isolated lab environments
  302. - Never deploy on production systems
  303. - Focus on defensive detection capabilities
  304. ## Contributing
  305. Contributions are welcome! If you'd like to:
  306. - Add new curated wordlists
  307. - Improve documentation
  308. - Fix errors or update outdated information
  309. - Suggest additional skills
  310. Please open an issue or pull request.
  311. ## How to Use This on skills.sh
  312. This repository is published on the [skills.sh](https://skills.sh/) open agent skills directory — the public registry for the [Agent Skills](https://agentskills.io) ecosystem. Skills are discovered from the `skills/` directory and appear on the [skills.sh leaderboard](https://skills.sh/) as users install them.
  313. **Collection page:** [skills.sh/Eyadkelleh/awesome-skills-security](https://skills.sh/Eyadkelleh/awesome-skills-security)
  314. ### What is skills.sh?
  315. [skills.sh](https://skills.sh/) is the directory and CLI for reusable agent skills. A single install command works across Claude Code, Cursor, Codex, OpenCode, and dozens of other agents. No separate packaging or publish step is required — push valid `SKILL.md` files to a public GitHub repo and users can install immediately.
  316. ### For Users
  317. ```bash
  318. # Browse what's available
  319. npx skills add Eyadkelleh/awesome-skills-security --list
  320. # Install all skills (project scope)
  321. npx skills add Eyadkelleh/awesome-skills-security --skill '*' -y
  322. # Install one skill to Cursor
  323. npx skills add Eyadkelleh/awesome-skills-security --skill security-fuzzing -a cursor -y
  324. # Search the skills.sh directory
  325. npx skills find security
  326. ```
  327. After installing, ask your agent to use a skill naturally:
  328. ```
  329. "Use the security-fuzzing skill to show me SQL injection payloads"
  330. ```
  331. ### Supported Agents
  332. Install to any supported agent with the `-a` flag:
  333. | Agent | Install example |
  334. |:------|:----------------|
  335. | Cursor | `npx skills add Eyadkelleh/awesome-skills-security -a cursor -y` |
  336. | Claude Code | `npx skills add Eyadkelleh/awesome-skills-security -a claude-code -y` |
  337. | Codex | `npx skills add Eyadkelleh/awesome-skills-security -a codex -y` |
  338. | OpenCode | `npx skills add Eyadkelleh/awesome-skills-security -a opencode -y` |
  339. See the full list of [supported agents](https://skills.sh/).
  340. ### SKILL.md Requirements
  341. Each skill directory must contain a `SKILL.md` with YAML frontmatter:
  342. ```yaml
  343. ---
  344. name: security-fuzzing
  345. description: "Essential fuzzing payloads: SQL injection, command injection, and more."
  346. ---
  347. ```
  348. - `name` — lowercase identifier with hyphens only (e.g. `security-fuzzing`)
  349. - `description` — non-empty; quote values that contain colons
  350. ### For Contributors
  351. Want to add your own skills to this collection?
  352. 1. **Fork this repository**
  353. 2. **Add your skill** under `skills/your-skill-name/`
  354. 3. **Create a SKILL.md** with valid frontmatter (`name` must be lowercase with hyphens, plus `description`)
  355. 4. **Verify locally**: `npx skills add . --list`
  356. 5. **Submit a pull request** with a description of your contribution
  357. ### Publishing Your Own Skills
  358. To create your own skill collection for skills.sh:
  359. 1. **Create a repository** with a `skills/` directory
  360. 2. **Add SKILL.md files** in each skill directory with `name` and `description` frontmatter
  361. 3. **Push to GitHub** and make it public
  362. 4. **Verify discovery**: `npx skills add username/repo-name --list`
  363. 5. **Share your repo** — users install with `npx skills add username/repo-name`
  364. ## Related OSINT Tools
  365. | Tool | Description |
  366. |:-----|:------------|
  367. | [x-twitter-scraper](https://github.com/Xquik-dev/x-twitter-scraper) | X/Twitter OSINT skill — user lookup, follower extraction, engagement analysis, account monitoring. MCP server, REST API, 20 extraction tools. |
  368. ## Documentation and References
  369. - [skills.sh Directory](https://skills.sh/) - Browse and install agent skills
  370. - [This collection on skills.sh](https://skills.sh/Eyadkelleh/awesome-skills-security) - Install stats and skill listing
  371. - [Agent Skills Specification](https://agentskills.io) - SKILL.md format and conventions
  372. - [skills CLI (npm)](https://www.npmjs.com/package/skills) - `npx skills` install and manage skills
  373. - [Cursor Skills Documentation](https://cursor.com/docs/context/skills) - Using skills in Cursor
  374. - [Claude Code Skills Documentation](https://code.claude.com/docs/en/skills) - Using skills in Claude Code
  375. - [SecLists Official Repository](https://github.com/danielmiessler/SecLists)
  376. - [OWASP Testing Guide](https://owasp.org/www-project-web-security-testing-guide/)
  377. - [Bug Bounty Platforms](https://github.com/disclose/bug-bounty-platforms)
  378. - [Responsible Disclosure Guidelines](https://cheatsheetseries.owasp.org/cheatsheets/Vulnerability_Disclosure_Cheat_Sheet.html)
  379. ## License
  380. MIT License - Use responsibly with proper authorization.
  381. This is a curated collection and redistribution of SecLists content. The original SecLists project is maintained by Daniel Miessler under the MIT License. All credit for the original content goes to the SecLists project and its contributors.
  382. ## Disclaimer
  383. This repository is provided for educational and authorized security testing purposes only. The maintainers of this repository are not responsible for any misuse or damage caused by the resources contained herein. Users are solely responsible for ensuring they have proper authorization before conducting any security testing activities.
  384. ---
  385. **Note:** This is a curated reference repository. Always verify you have proper authorization before conducting security testing. When in doubt, ask for explicit written permission.
  386. **Awesome Security Skills** | Security Collection for [skills.sh](https://skills.sh/)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.