Skip to content
Back to search

phoenix-security

Phoenix Security skills for Claude Code: AppSec review, threat modelling, SAST rule generation, CTI research, security-first PRDs, readiness gates, and documentation automation.

Safety scan

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

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/Security-Phoenix-demo/security-skills-claude-code with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/Security-Phoenix-demo/security-skills-claude-code'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/security-phoenix-demo--security-skills-claude-code/badge.svg)](/listings/security-phoenix-demo--security-skills-claude-code)

HTML

<a href="/listings/security-phoenix-demo--security-skills-claude-code"><img src="/api/listings/security-phoenix-demo--security-skills-claude-code/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

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

Everything in this repository installs as **six Claude Code plugins** from one marketplace. Paste this into Claude Code:

/plugin marketplace add Security-Phoenix-demo/security-skills-claude-code
/plugin install phoenix-security-review@phoenix-security
/plugin install phoenix-readiness-reviews@phoenix-security
/plugin install phoenix-sast-rules@phoenix-security
/plugin install phoenix-cti-search@phoenix-security
/plugin install phoenix-prd-pipeline@phoenix-security
/plugin install phoenix-docs-research@phoenix-security

Install only the plugins you want — each one stands alone. Full detail, team-wide auto-install, and troubleshooting: **[Marketplace Installation Guide](MARKETPLACE_INSTALL.md)**.

---

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.

.claude-plugin/marketplace.json · Manifest · 94 lines

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

  1. {
  2. "$schema": "https://www.schemastore.org/claude-code-marketplace.json",
  3. "name": "phoenix-security",
  4. "description": "Phoenix Security skills for Claude Code: AppSec review, threat modelling, SAST rule generation, CTI research, security-first PRDs, readiness gates, and documentation automation.",
  5. "owner": {
  6. "name": "Phoenix Security",
  7. "email": "admin@phoenix.security",
  8. "url": "https://phoenix.security"
  9. },
  10. "metadata": {
  11. "version": "1.0.0"
  12. },
  13. "plugins": [
  14. {
  15. "name": "phoenix-security-review",
  16. "source": "./plugins/phoenix-security-review",
  17. "description": "AppSec review suite: multi-language security-reviewer (8-point check, 7 language packs, OWASP/ASVS + endpoint checklists), whole-repo security-assessment, diff-scoped 0day-scanner, STRIDE/DREAD threat-modeling, and two threat-model-driven tiers (tm-quick-security-assessment, tm-security-review). Ships 4 slash commands, a security-reviewer subagent, and 3 opt-in hooks.",
  18. "category": "security",
  19. "keywords": [
  20. "security",
  21. "appsec",
  22. "owasp",
  23. "asvs",
  24. "threat-modeling",
  25. "code-review"
  26. ]
  27. },
  28. {
  29. "name": "phoenix-readiness-reviews",
  30. "source": "./plugins/phoenix-readiness-reviews",
  31. "description": "Two adversarial review gates. plan-readiness-review asks whether a PRD, spec or RFC is implementable without inventing anything. production-readiness-review asks whether the code is actually built, wired, tested and safe to deploy, backed by a deterministic repo scanner.",
  32. "category": "code-quality",
  33. "keywords": [
  34. "review",
  35. "prd",
  36. "production-readiness",
  37. "qa",
  38. "ship-gate"
  39. ]
  40. },
  41. {
  42. "name": "phoenix-sast-rules",
  43. "source": "./plugins/phoenix-sast-rules",
  44. "description": "Generate opengrep/semgrep SAST rules for 30+ languages, including pattern and taint-mode rules. The research variant first researches a CVE or CWE with web search, then writes targeted detection rules from the findings.",
  45. "category": "security",
  46. "keywords": [
  47. "sast",
  48. "opengrep",
  49. "semgrep",
  50. "static-analysis",
  51. "cve",
  52. "cwe"
  53. ]
  54. },
  55. {
  56. "name": "phoenix-cti-search",
  57. "source": "./plugins/phoenix-cti-search",
  58. "description": "Cyber threat intelligence search across 595 curated security domains in 4 authority tiers, for CVEs, threat actors, malware families, exploits and breach reports. Ships a skill that needs no API key, a Node CLI, an MCP server, and a /cti-search command. Optional push to NotebookLM.",
  59. "category": "security",
  60. "keywords": [
  61. "cti",
  62. "threat-intelligence",
  63. "cve",
  64. "malware",
  65. "osint"
  66. ]
  67. },
  68. {
  69. "name": "phoenix-prd-pipeline",
  70. "source": "./plugins/phoenix-prd-pipeline",
  71. "description": "Security-first specification pipeline. prd-generator writes a full PRD with a threat model from a plain-language feature description. The 12 phoenix-* roles run the same pipeline stage by stage: context curation, scope, constraints, RFC 2119 requirements, ambiguity hunting, threat model, API contracts, verification matrix, delivery batches and a final ship gate.",
  72. "category": "productivity",
  73. "keywords": [
  74. "prd",
  75. "spec",
  76. "requirements",
  77. "threat-modeling",
  78. "planning"
  79. ]
  80. },
  81. {
  82. "name": "phoenix-docs-research",
  83. "source": "./plugins/phoenix-docs-research",
  84. "description": "Documentation and research tooling. project-documenter generates and self-heals a full documentation pack across 6 modes. notebooklm queries Google NotebookLM for citation-backed, source-grounded answers. phoenix-research-pipeline runs web and YouTube research and pushes sources into NotebookLM.",
  85. "category": "documentation",
  86. "keywords": [
  87. "documentation",
  88. "research",
  89. "notebooklm",
  90. "architecture-docs"
  91. ]
  92. }
  93. ]
  94. }
README.md · README · 1,414 lines

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

  1. # Security Skills for Claude Code — Open Source Security Automation Toolkit
  2. **The open-source security automation toolkit for [Claude Code](https://claude.ai)** — CTI research, SAST rule generation, secure PRD creation, vulnerability analysis, and AI-powered security engineering workflows. Built by [Phoenix Security](https://phoenix.security) for the global AppSec, DevSecOps, and security research community.
  3. [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
  4. [![Claude Code](https://img.shields.io/badge/Claude%20Code-Skills%20%26%20Plugins-blueviolet)](https://claude.ai)
  5. [![Contributions Welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg)](CONTRIBUTING.md)
  6. > Search 595+ threat intelligence sources, generate opengrep/semgrep SAST rules for 30+ languages, create security-focused product requirements with STRIDE threat models, review a plan or a codebase before it ships, query NotebookLM for citation-backed research, and auto-generate living project documentation — all from your terminal with Claude Code.
  7. ---
  8. ## Install in 30 seconds
  9. Everything in this repository installs as **six Claude Code plugins** from one marketplace.
  10. Paste this into Claude Code:
  11. ```
  12. /plugin marketplace add Security-Phoenix-demo/security-skills-claude-code
  13. /plugin install phoenix-security-review@phoenix-security
  14. /plugin install phoenix-readiness-reviews@phoenix-security
  15. /plugin install phoenix-sast-rules@phoenix-security
  16. /plugin install phoenix-cti-search@phoenix-security
  17. /plugin install phoenix-prd-pipeline@phoenix-security
  18. /plugin install phoenix-docs-research@phoenix-security
  19. ```
  20. Install only the plugins you want — each one stands alone. Full detail, team-wide
  21. auto-install, and troubleshooting: **[Marketplace Installation Guide](MARKETPLACE_INSTALL.md)**.
  22. ---
  23. ## New — Readiness Review Gates
  24. Two adversarial review gates that answer the two questions that actually decide whether
  25. work is ready to move: **is the plan implementable**, and **is the code actually shippable**.
  26. ![Plan readiness and production readiness — the two gates side by side, their focus areas and their verdicts](images/PRD-IMp-skill.jpeg)
  27. | Skill | Input | Question it answers | Verdict |
  28. |---|---|---|---|
  29. | `plan-readiness-review` | PRD, plan, spec, RFC, design doc | Could a different senior engineer build this without inventing requirements, schemas, API contracts or error handling? | **READY / NOT READY** |
  30. | `production-readiness-review` | Repo + branch + the plan | Is it actually built, wired, tested, and safe to deploy? | **SHIP / NO-SHIP** |
  31. Both refuse to hand you an invented number. Percentages carry counts (`68% (23/34 VERIFIED)`),
  32. results are three-state (VERIFIED / GAP / UNVERIFIABLE) so "I could not check this" stops
  33. collapsing into a pass, and every absence claim must cite the search that returned zero hits.
  34. `production-readiness-review` runs a **deterministic repo scanner** first, so its evidence is
  35. reproducible and two runs diff cleanly instead of depending on what the model happened to read.
  36. ```
  37. /plugin install phoenix-readiness-reviews@phoenix-security
  38. ```
  39. Then just ask — or type `/plan-readiness-review` / `/production-readiness-review`.
  40. Full reference: [Readiness & Review Gates](#readiness--review-gates).
  41. ---
  42. ## Table of Contents
  43. ![Overview-Repo](images/Phoenix-Skills-Overview-2.jpg)
  44. - [Install in 30 seconds](#install-in-30-seconds)
  45. - [New — Readiness Review Gates](#new--readiness-review-gates)
  46. - [Powered by Phoenix Security — Open-Source Companion to the Platform](#powered-by-phoenix-security--open-source-companion-to-the-platform)
  47. - [What Is This Repository?](#what-is-this-repository)
  48. - [What's Included](#whats-included)
  49. - [The six plugins](#the-six-plugins)
  50. - [All 27 skills](#all-27-skills)
  51. - [Feature Descriptor — Phoenix Pipeline](#feature-descriptor--phoenix-pipeline)
  52. - [Quick Start](#quick-start)
  53. - [Repository Structure](#repository-structure)
  54. - [Readiness & Review Gates](#readiness--review-gates)
  55. - [Research & Intelligence Skills](#research--intelligence-skills)
  56. - [1. CTI Domain Research](#1-cti-domain-research--automated-threat-intelligence-gathering)
  57. - [2. NotebookLM Connector](#2-notebooklm-connector--source-grounded-ai-research-with-zero-hallucinations)
  58. - [3. Global Research Pipeline](#3-global-research-pipeline--automated-intelligence-collection-and-ingestion)
  59. - [Security Generation & Remediation Skills](#security-generation--remediation-skills)
  60. - [1. Secure PRD Generator](#1-secure-prd-generator--shift-security-left-to-the-requirements-stage)
  61. - [2. OpenGrep Rule Generator](#2-opengrep-rule-generator--ai-powered-sast-rule-creation)
  62. - [3. OpenGrep Rule Generator Research](#3-opengrep-rule-generator-research--vulnerability-first-detection-engineering)
  63. - [4. Project Documentation](#4-project-documentation--turn-any-codebase-into-living-documentation)
  64. - [5. Security Assessment Suite](#5-security-assessment-suite--four-appsec-skills--active-hooks)
  65. - [Plugins Reference](#plugins-reference)
  66. - [CTI Search Plugin](#1-cti-search-plugin)
  67. - [Secure PRD Plugin](#2-secure-prd-plugin)
  68. - [Phoenix Pipeline — Feature Descriptor](#phoenix-pipeline--feature-descriptor)
  69. - [Domain Tiers](#domain-tiers)
  70. - [NotebookLM Integration](#notebooklm-integration)
  71. - [Configuration](#configuration--customization)
  72. - [Contributing](#contributing)
  73. - [Frequently Asked Questions (FAQ)](#frequently-asked-questions-faq)
  74. - [License](#license)
  75. - [Support](#support)
  76. - [Acknowledgments](#acknowledgments)
  77. ---
  78. ## Overview
  79. ---
  80. ## Powered by Phoenix Security — Open-Source Companion to the Platform
  81. This repository is the **open-source companion** to the **[Phoenix Security](https://phoenix.security)** platform. Each skill here distills a slice of what Phoenix does at platform scale into something you can run locally inside Claude Code. If a skill earns its keep in your workflow and you need it across hundreds of repos, with real reachability data, exploit chains, and team-level SLAs, the corresponding Phoenix product area is where to go next.
  82. ### Phoenix Platform — Four Unified Product Areas
  83. | Area | Tagline | What it does | Open-source slice in this repo |
  84. |---|---|---|---|
  85. | **🟠 Orange — Attribution & Prioritization** | One backlog per team | Single backlog with code→cloud reachability and business context. Normalizes 30+ scanners, dedupes, and routes to owners with SLAs. | — (platform-only) |
  86. | **🟣 [Purple — Identification & Prevention](https://phoenix.security/phoenix-purple-ai-sast-sca-ai-generated-code/)** | Stop bad code before merge | Graph-powered SAST and exploit intelligence. Traces real taint paths, composes multi-step chains, prevents issues at PR and agent time. | **[Security Assessment Suite](plugins/phoenix-security-review/)** + **[OpenGrep Rule Generator](plugins/phoenix-sast-rules/skills/opengrep-rule-generator/)** + **[Secure PRD Generator](plugins/phoenix-prd-pipeline/skills/prd-generator/)** |
  87. | **🔵 [Blue — Threat Intelligence & Supply-Chain Firewall](https://phoenix.security/phoenix-blue-ai-vulnerability-intelligence-cve-scoring/)** | Block bad packages before install | Adversarially validated intelligence fused into a single decision. Enforces at agent, install, CI, and deploy to block malicious or unsafe packages pre-execution. | **[CTI Domain Research](plugins/phoenix-cti-search/skills/cti-domain-research/)** + **[NotebookLM Connector](plugins/phoenix-docs-research/skills/notebooklm/)** + the **PreToolUse Bash package guard hook** in the Security Assessment Suite |
  88. | **🟢 Green — Agentic Remediation** | Minimal-diff fix PRs | Minimal-diff PRs, safe alternatives, negative tests, and change plans tied to proven attack paths. Closes the loop with measurable risk reduction. | — (platform-only — coming to OSS) |
  89. **When the open-source skills aren't enough:**
  90. - **Need cross-repo reachability and prioritization?** → Phoenix Orange
  91. - **Need multi-step taint analysis with real exploit chains?** → [Phoenix Purple](https://phoenix.security/phoenix-purple-ai-sast-sca-ai-generated-code/)
  92. - **Need adversarially validated CVE intel + install-time blocking?** → [Phoenix Blue](https://phoenix.security/phoenix-blue-ai-vulnerability-intelligence-cve-scoring/)
  93. - **Need agentic remediation with measurable risk reduction?** → Phoenix Green
  94. The skills in this repo are designed to be useful on day one, with no Phoenix backend required. They share Phoenix's design philosophy: short feedback loops, severity-ranked findings, no padding, no 30-page reports.
  95. ---
  96. ## What Is This Repository?
  97. This repository is a **curated collection of security skills, plugins, and automation pipelines** for [Claude Code](https://claude.ai) — Anthropic's official CLI for AI-assisted software engineering. It turns Claude Code into a comprehensive **security engineering workstation** capable of threat intelligence research, vulnerability detection rule generation, secure requirements engineering, and automated security documentation.
  98. Built and maintained by the **security engineering team at [Phoenix Security](https://phoenix.security)** and released as open source under the MIT License. Every skill is designed for real-world security workflows: incident response research, AppSec shift-left, SAST pipeline creation, compliance documentation, and security architecture review.
  99. **Built for security professionals who use AI to work faster and more accurately:**
  100. - **Security engineers and SOC analysts** — automate CTI gathering across 595+ sources with authority-ranked results and MITRE ATT&CK mapping
  101. - **DevSecOps teams** — generate security-focused PRDs with STRIDE threat models before writing a single line of code
  102. - **AppSec professionals** — create opengrep/semgrep SAST rules for 30+ languages with built-in false positive reduction and CWE/OWASP tagging
  103. - **Vulnerability researchers** — research CVEs with web search, then auto-generate detection rules grounded in real exploit data
  104. - **Penetration testers and red teamers** — gather OSINT and push findings to NotebookLM for citation-backed analysis
  105. - **Engineering managers** — auto-generate living project documentation with architecture maps, dependency views, and self-healing CI
  106. - **Anyone using Claude Code** — extend your terminal with structured, repeatable security automation workflows
  107. ---
  108. ## What's Included
  109. ![Overview-Repo-Detailed](images/Phoenix-Skills-Overview-1.jpg)
  110. ### The six plugins
  111. Everything ships as a Claude Code plugin. One `/plugin install` per plugin — no copying
  112. folders, no editing settings by hand. Each plugin holds one or more **skills**; a skill is
  113. an instruction-based workflow that also gives you a slash command of the same name.
  114. | Plugin | What it gives you | Skills | Install |
  115. |---|---|---|---|
  116. | **[phoenix-security-review](plugins/phoenix-security-review/)** | AppSec review across the whole lifecycle: multi-language reviewer, whole-repo OWASP/ASVS sweep, diff-scoped 0-day scan, STRIDE/DREAD threat model, and two threat-model-driven tiers. Plus 4 slash commands, 1 subagent, 3 opt-in hooks. | 6 | `/plugin install phoenix-security-review@phoenix-security` |
  117. | **[phoenix-readiness-reviews](plugins/phoenix-readiness-reviews/)** | The two review gates: is the plan implementable, and is the code shippable. Deterministic repo scanner included. | 2 | `/plugin install phoenix-readiness-reviews@phoenix-security` |
  118. | **[phoenix-sast-rules](plugins/phoenix-sast-rules/)** | opengrep/semgrep rule generation for 30+ languages, with an optional CVE/CWE research pass first. | 2 | `/plugin install phoenix-sast-rules@phoenix-security` |
  119. | **[phoenix-cti-search](plugins/phoenix-cti-search/)** | Threat intelligence search across 595 curated domains in 4 authority tiers. Skill needs no API key; bundled Node CLI, MCP server and `/cti-search` command. | 1 | `/plugin install phoenix-cti-search@phoenix-security` |
  120. | **[phoenix-prd-pipeline](plugins/phoenix-prd-pipeline/)** | Security-first specifications: a one-shot PRD generator plus the 12 Phoenix Pipeline roles, stage by stage. | 13 | `/plugin install phoenix-prd-pipeline@phoenix-security` |
  121. | **[phoenix-docs-research](plugins/phoenix-docs-research/)** | A 6-mode self-healing project documenter, a NotebookLM connector for citation-backed answers, and a web + YouTube research pipeline. | 3 | `/plugin install phoenix-docs-research@phoenix-security` |
  122. ### All 27 skills
  123. Each one is also a slash command named after it.
  124. | Skill | Plugin | Description |
  125. |---|---|---|
  126. | `plan-readiness-review` | readiness-reviews | Adversarial review of a PRD, plan, spec or RFC. Verdict: READY / NOT READY |
  127. | `production-readiness-review` | readiness-reviews | Adversarial review of a real codebase against its plan. Verdict: SHIP / NO-SHIP |
  128. | `security-reviewer` | security-review | Multi-language 8-point pre-merge review (Python, JS/TS, Go, Java/Kotlin, Rust, Ruby, .NET) |
  129. | `security-assessment` | security-review | Whole-repo OWASP Top 10 2025 + ASVS Level 1 sweep |
  130. | `0day-scanner` | security-review | Diff-scoped zero-day analysis of a commit, PR, file or branch |
  131. | `threat-modeling` | security-review | STRIDE + DREAD threat model extracted from the code |
  132. | `tm-quick-security-assessment` | security-review | Quick tier — threat-model-aware pre-merge pass on what changed |
  133. | `tm-security-review` | security-review | Comprehensive tier — full threat model, then triple-pass exploit review with a runnable PoC |
  134. | `opengrep-rule-generator` | sast-rules | Write opengrep/semgrep pattern and taint rules for 30+ languages |
  135. | `opengrep-rule-generator-research` | sast-rules | Research a CVE or CWE with web search first, then write the detection rules |
  136. | `cti-domain-research` | cti-search | Tiered threat-intelligence search across 595 security domains. No API key needed |
  137. | `prd-generator` | prd-pipeline | Full security-focused PRD with a threat model, from a plain-language description |
  138. | `phoenix-pipeline-navigator` | prd-pipeline | Interactive guide and launcher for the 10-role pipeline |
  139. | `phoenix-orchestrator` | prd-pipeline | Runs roles 01–10 end to end |
  140. | `phoenix-context-curator` | prd-pipeline | Role 01 — cleans raw notes, tickets and threads into CLEAN_CONTEXT |
  141. | `phoenix-scope-cutter` | prd-pipeline | Role 02 — explicit in-scope / out-of-scope |
  142. | `phoenix-constraint-distiller` | prd-pipeline | Role 03 — constraints and acceptance criteria |
  143. | `phoenix-requirements-engineer` | prd-pipeline | Role 04 — RFC 2119 requirements with stable IDs |
  144. | `phoenix-ambiguity-hunter` | prd-pipeline | Role 05 — red-teams the requirements for ambiguity |
  145. | `phoenix-security-engineer` | prd-pipeline | Role 06 — threat model and abuse cases |
  146. | `phoenix-contract-architect` | prd-pipeline | Role 07 — API design, events, error taxonomy |
  147. | `phoenix-verification-matrix` | prd-pipeline | Role 08 — a proof path for every MUST |
  148. | `phoenix-batch-planner` | prd-pipeline | Role 09 — incremental, verifiable delivery slices |
  149. | `phoenix-final-gate` | prd-pipeline | Role 10 — SHIP / NO_SHIP with a blocker list |
  150. | `project-documenter` | docs-research | Generates and self-heals a full documentation pack across 6 modes |
  151. | `notebooklm` | docs-research | Queries Google NotebookLM for citation-backed, source-grounded answers |
  152. | `phoenix-research-pipeline` | docs-research | Web + YouTube research, then pushes sources into NotebookLM |
  153. ### Feature Descriptor — Phoenix Pipeline
  154. ![Shift Security Left at the PRD Stage](images/prd-pipeline.jpg)
  155. The **Phoenix Pipeline** is a 12-role specification system for producing rigorous, security-aware product requirements. Each role is a dedicated skill file.
  156. | Role | Skill | Purpose |
  157. |------|-------|---------|
  158. | Pipeline Navigator | `phoenix-pipeline-navigator` | Orchestrates the full pipeline |
  159. | Context Curator | `phoenix-context-curator` | Extracts and cleanses input context |
  160. | Scope Cutter | `phoenix-scope-cutter` | Defines in/out scope and goals |
  161. | Constraint Distiller | `phoenix-constraint-distiller` | Identifies constraints and acceptance criteria |
  162. | Requirements Engineer | `phoenix-requirements-engineer` | Creates RFC 2119 requirements with IDs |
  163. | Ambiguity Hunter | `phoenix-ambiguity-hunter` | Flags and resolves ambiguities |
  164. | Security Engineer | `phoenix-security-engineer` | Develops threat models and abuse cases |
  165. | Contract Architect | `phoenix-contract-architect` | Designs APIs, events, and error taxonomy |
  166. | Verification Matrix | `phoenix-verification-matrix` | Creates proof paths for every requirement |
  167. | Batch Planner | `phoenix-batch-planner` | Plans incremental, verifiable delivery |
  168. | Final Gate | `phoenix-final-gate` | Go/no-go decision with blocker list |
  169. | Orchestrator | `phoenix-orchestrator` | Coordinates all roles and manages flow |
  170. > All 12 roles ship inside the `phoenix-prd-pipeline` plugin:
  171. > [`plugins/phoenix-prd-pipeline/skills/`](plugins/phoenix-prd-pipeline/skills/).
  172. > Install it once and every role is available as a skill and a slash command.
  173. ---
  174. ## Quick Start
  175. ### Prerequisites
  176. - [Claude Code](https://claude.ai) installed
  177. - Node.js 18+ (for plugins)
  178. - A search API key — [Brave Search](https://api.search.brave.com/app/keys) (recommended, 2,000 free requests/month) or [SerpAPI](https://serpapi.com) (100 free/month)
  179. ### Installation
  180. #### Method 1 — plugin marketplace (recommended)
  181. One marketplace, six plugins. Type these in Claude Code:
  182. ```
  183. /plugin marketplace add Security-Phoenix-demo/security-skills-claude-code
  184. /plugin install phoenix-security-review@phoenix-security
  185. /plugin install phoenix-readiness-reviews@phoenix-security
  186. /plugin install phoenix-sast-rules@phoenix-security
  187. /plugin install phoenix-cti-search@phoenix-security
  188. /plugin install phoenix-prd-pipeline@phoenix-security
  189. /plugin install phoenix-docs-research@phoenix-security
  190. ```
  191. Install only what you need. `/plugin` opens the browser UI if you would rather click.
  192. Prefer the terminal? The same thing works outside a session:
  193. ```bash
  194. claude plugin marketplace add Security-Phoenix-demo/security-skills-claude-code
  195. claude plugin install phoenix-readiness-reviews@phoenix-security
  196. claude plugin list
  197. ```
  198. **Team-wide auto-install** — commit this to your repo's `.claude/settings.json` and every
  199. teammate gets the plugins on their next session:
  200. ```json
  201. {
  202. "extraKnownMarketplaces": {
  203. "phoenix-security": {
  204. "source": {
  205. "source": "github",
  206. "repo": "Security-Phoenix-demo/security-skills-claude-code"
  207. }
  208. }
  209. },
  210. "enabledPlugins": {
  211. "phoenix-security-review@phoenix-security": true,
  212. "phoenix-readiness-reviews@phoenix-security": true
  213. }
  214. }
  215. ```
  216. Updating later: `/plugin update phoenix-security-review@phoenix-security`, or
  217. `/plugin marketplace update phoenix-security` to refresh the catalogue.
  218. See the **[Marketplace Installation Guide](MARKETPLACE_INSTALL.md)** for troubleshooting,
  219. scopes, and how to test a local checkout before you push.
  220. #### Method 2 — local checkout (for development)
  221. Point the marketplace at a directory instead of a repo. Edits land immediately, so this is
  222. the loop to use while writing or changing a skill:
  223. ```bash
  224. git clone https://github.com/Security-Phoenix-demo/security-skills-claude-code.git
  225. cd security-skills-claude-code
  226. claude plugin marketplace add "$(pwd)"
  227. claude plugin install phoenix-readiness-reviews@phoenix-security
  228. ```
  229. Validate before you commit:
  230. ```bash
  231. claude plugin validate . # the marketplace manifest
  232. claude plugin validate plugins/phoenix-security-review # one plugin manifest
  233. claude plugin validate --strict plugins/phoenix-security-review # its skills, commands, agents
  234. python3 scripts/validate-marketplace.py # does everything fit together?
  235. ```
  236. #### Method 3 — copy a single skill
  237. A skill directory is self-contained. Copy one in and it becomes a slash command named after
  238. the directory, with no manifest needed:
  239. ```bash
  240. # personal — available in every project on this machine
  241. cp -r plugins/phoenix-readiness-reviews/skills/* ~/.claude/skills/
  242. # or project-scoped, committed so the team gets it
  243. cp -r plugins/phoenix-readiness-reviews/skills/* .claude/skills/
  244. ```
  245. Claude Code watches these directories, so an edit lands in the running session without a
  246. restart. Note that `~/.claude/skills/` is **not** read by Cowork or cloud sessions — use the
  247. plugin route for those.
  248. #### After installing — Node and API keys
  249. Only `phoenix-cti-search` needs either. Its `cti-domain-research` skill works with no setup;
  250. the bundled CLI and MCP server need Node 18+ and a search key:
  251. ```bash
  252. CTI=~/.claude/plugins/marketplaces/phoenix-security/plugins/phoenix-cti-search
  253. cd "$CTI" && npm install --omit=dev
  254. cp .env.example .env # then set BRAVE_SEARCH_API_KEY
  255. ```
  256. ---
  257. ## Repository Structure
  258. ```
  259. security-skills-claude-code/
  260. │
  261. ├── .claude-plugin/
  262. │ └── marketplace.json # the marketplace manifest — this is what
  263. │ # /plugin marketplace add reads
  264. │
  265. ├── README.md # this file — start here
  266. ├── MARKETPLACE_INSTALL.md # installation guide + troubleshooting
  267. ├── CONTRIBUTING.md # how to add a skill or a plugin
  268. ├── LICENSE # MIT
  269. │
  270. └── plugins/ # one directory per plugin
  271. │
  272. ├── phoenix-security-review/ # 6 skills, 4 commands, 1 agent, 3 hooks
  273. │ ├── .claude-plugin/plugin.json
  274. │ ├── skills/
  275. │ │ ├── security-reviewer/ # canonical multi-language reviewer
  276. │ │ │ ├── languages/ # 7 per-language reference packs
  277. │ │ │ ├── checklists/ # OWASP/ASVS + endpoint
  278. │ │ │ └── playbooks/triage.md
  279. │ │ ├── security-assessment/ # whole-repo OWASP + ASVS L1
  280. │ │ ├── 0day-scanner/ # diff-scoped exploit analysis
  281. │ │ ├── threat-modeling/ # STRIDE + DREAD
  282. │ │ ├── tm-quick-security-assessment/
  283. │ │ └── tm-security-review/
  284. │ ├── commands/ # /security-review /security-0day
  285. │ │ # /security-audit /threatmodel
  286. │ ├── agents/security-reviewer.md # the review subagent
  287. │ ├── hooks/ # SessionStart / PreToolUse / PostToolUse
  288. │ ├── install/ # opt-in hook wiring, Windsurf, Codex
  289. │ └── references/ # tester templates, suite notes
  290. │
  291. ├── phoenix-readiness-reviews/ # 2 skills
  292. │ ├── .claude-plugin/plugin.json
  293. │ └── skills/
  294. │ ├── plan-readiness-review/
  295. │ │ └── references/ # ambiguity patterns, output template
  296. │ └── production-readiness-review/
  297. │ ├── references/ # verification checklists, output template
  298. │ └── scripts/scan_repo.sh # deterministic evidence collector
  299. │
  300. ├── phoenix-sast-rules/ # 2 skills
  301. │ └── skills/
  302. │ ├── opengrep-rule-generator/
  303. │ └── opengrep-rule-generator-research/
  304. │
  305. ├── phoenix-cti-search/ # 2 skills + CLI + MCP server
  306. │ ├── skills/cti-domain-research/
  307. │ ├── commands/cti-search.md
  308. │ ├── index.js # CLI entry point
  309. │ ├── mcp-server.js # MCP tool server
  310. │ ├── data/domains.txt # 595 curated security domains
  311. │ └── data/tier-map.json # tier + authority scores
  312. │
  313. ├── phoenix-prd-pipeline/ # 13 skills
  314. │ ├── skills/prd-generator/ # one-shot PRD + threat model
  315. │ ├── skills/phoenix-*/ # the 12 pipeline roles
  316. │ └── dist/claude-ai-web/ # the Claude.ai web UI variant
  317. │
  318. └── phoenix-docs-research/ # 3 skills
  319. ├── skills/project-documenter/ # 6 modes, incl. self-heal
  320. ├── skills/notebooklm/ # browser automation + scripts
  321. ├── skills/phoenix-research-pipeline/
  322. └── docs/ # per-skill long-form docs
  323. ```
  324. Every `dist/` directory holds the packaged `.skill` bundles for uploading to claude.ai —
  325. they are distribution artefacts, not something Claude Code loads.
  326. ---
  327. ## Readiness & Review Gates
  328. **Plugin:** [`plugins/phoenix-readiness-reviews/`](plugins/phoenix-readiness-reviews/) ·
  329. `/plugin install phoenix-readiness-reviews@phoenix-security`
  330. Two gates, split by what is under review. Run the plan gate before build. Run the production
  331. gate before merge or release. The production gate assumes the plan exists but never trusts it.
  332. ![Plan readiness review and production readiness review — inputs, checks, evidence model and verdicts](images/PRD-Imp_skill-review.jpeg)
  333. Left: every input the plan gate accepts, the gaps it hunts for, and the READY / NOT READY
  334. decision. Right: what the production gate proves against the real repository, and the
  335. SHIP / NO-SHIP decision. Bottom: where each gate sits in the workflow, and the three-state
  336. evidence model both share.
  337. | Skill | Input | Question | Verdict |
  338. |---|---|---|---|
  339. | `plan-readiness-review` | PRD / plan / spec / RFC / design | Could another senior engineer build this without inventing anything? | READY / NOT READY |
  340. | `production-readiness-review` | Repo + branch + plan | Is it actually built, wired, tested, and safe to deploy? | SHIP / NO-SHIP |
  341. ### 1. Plan Readiness Review — Catch the Gap Before Anyone Writes Code
  342. One question decides everything: **could a competent senior engineer who was not in any of
  343. the meetings implement this correctly, without inventing anything?** Anything an implementer
  344. would have to decide for themselves is a gap in the plan, not a detail for later — a guess is
  345. an unreviewed product decision made by whoever happened to pick up the ticket.
  346. **What it produces:**
  347. - A requirement inventory with stable IDs, so a re-run reports a delta and not a fresh list.
  348. - A per-requirement verdict backed by a document anchor you can go and read.
  349. - An unresolved-assumption register — the decisions nobody has actually made yet.
  350. - A counted READY / NOT READY, and the precise change that would flip it.
  351. It reads a bundled ambiguity-pattern reference during the review: the specific phrasings that
  352. reliably survive plan review and then produce two engineers building two different things.
  353. Undefined magnitude, undefined actor, undefined scope of "all", verbs that hide a design
  354. decision, error-handling non-statements.
  355. **Example prompts:**
  356. ```
  357. /plan-readiness-review docs/payments-prd.md
  358. review this spec before we build it
  359. is this ready to implement?
  360. poke holes in this plan
  361. will an engineer know what to build from this?
  362. ```
  363. ### 2. Production Readiness Review — Try to Disprove That the Work Is Done
  364. The plan is a claim. The commit history is a claim. A passing test suite is a weaker claim
  365. than it looks. Only the code, its wiring, its configuration and its behaviour under failure
  366. are evidence. This skill tries to **disprove that the work is finished** and reports what
  367. survived the attempt.
  368. **Phase 1 is a deterministic scan.** `scripts/scan_repo.sh` emits `path:line` for every hit,
  369. under seven sections: incompleteness markers, silent failure and swallowed errors, debug and
  370. dev leftovers, security surface (secret-shaped literals, routes counted against auth markers,
  371. injection-prone patterns, disabled TLS checks), config/flags/migrations/deploy including which
  372. artefacts are missing, test surface, and the change surface vs a base ref. It skips test paths
  373. and vendor directories, needs only bash and grep, and uses ripgrep when present. Output is deterministic, so two
  374. runs diff cleanly and the review's evidence is reproducible rather than dependent on what the
  375. model happened to read.
  376. The scanner is useful on its own:
  377. ```bash
  378. SKILL=~/.claude/plugins/marketplaces/phoenix-security/plugins/phoenix-readiness-reviews/skills/production-readiness-review
  379. bash "$SKILL/scripts/scan_repo.sh" /path/to/repo --base origin/main > scan.md
  380. bash "$SKILL/scripts/scan_repo.sh" . --base main --exclude 'generated/'
  381. ```
  382. **What the review then does with those leads:**
  383. - Traces every requirement end to end — UI, API, service, persistence, jobs, config,
  384. migrations, deploy. Wiring gets its own pass, with a named list of the "exists but is dead"
  385. traps.
  386. - Checks **test integrity by breaking the code** and confirming a test fails, instead of
  387. trusting test counts and coverage percentages.
  388. - Runs per-domain security checks with required evidence for each, not one bullet labelled
  389. "security".
  390. - Separates audit from remediation with a hard gate. Fixing while auditing destroys the
  391. record of what actually shipped. Remediation runs only when you authorise it, and only up
  392. to the severity you name.
  393. - Ranks issues by a severity rubric rather than intuition, with stable IDs.
  394. **Example prompts:**
  395. ```
  396. /production-readiness-review
  397. is this actually implemented?
  398. verify the implementation against the PRD
  399. pre-merge review of this branch vs origin/main
  400. ship or no-ship?
  401. ```
  402. **What comes back** — a counted Verdict block first, then the blocking issues:
  403. ```markdown
  404. ## Verdict
  405. **PRODUCTION READY: NO**
  406. - Plan completeness: **91%** (31 READY / 34 requirements)
  407. - Implementation completeness: **74%** (25 VERIFIED / 34; 7 GAP, 2 UNVERIFIABLE)
  408. - Open issues: 1 Critical, 3 High, 5 Medium, 2 Low
  409. - Scope: repo `.` @ `a1b2c3d` vs base `origin/main`; plan `payments-prd.md v1.4`
  410. - Verdict rule applied: NO-SHIP while any Critical or High is open
  411. ## Blocking issues
  412. - P-001 [Critical] `GET /v1/findings/{id}` has no tenant check — findings/api.py:212
  413. - P-004 [High] refund handler catches and drops every exception — billing/refund.py:88
  414. ```
  415. Then the per-requirement inventory, the remaining work with owners, and an evidence log of
  416. what was actually executed — so the review's limits are visible rather than implied.
  417. ### Why the verdicts are trustworthy
  418. | Rule | Why |
  419. |---|---|
  420. | Percentages carry counts — `68% (23/34 VERIFIED)` | A bare percentage from a language model is an invented number |
  421. | Three states: VERIFIED / GAP / UNVERIFIABLE | "I could not check this" must not collapse into a pass or a fail |
  422. | Absence claims cite the search that returned zero hits | Makes the review falsifiable instead of merely confident |
  423. | Audit and remediation split by a hard gate | Fixing while auditing destroys the record of what shipped |
  424. | Stable issue IDs | A re-run reports a delta, not a fresh list |
  425. ---
  426. ## Research & Intelligence Skills
  427. Skills that gather, organize, and verify external knowledge — threat intel, vendor docs, vulnerability research — and feed it into your workflow with citation-backed accuracy.
  428. ### 1. CTI Domain Research — Automated Threat Intelligence Gathering
  429. **Folder:** [`plugins/phoenix-cti-search/skills/cti-domain-research/`](plugins/phoenix-cti-search/skills/cti-domain-research/)
  430. ![Research, Verify, Detect: Structured Threat Intelligence for Claude Code](images/cti-skills.jpg)
  431. Stop manually searching BleepingComputer, Krebs on Security, and vendor blogs one tab at a time. The **CTI Domain Research** skill transforms Claude Code into a structured threat intelligence platform that searches **595+ curated security domains** in seconds — covering government advisories, vendor research labs, security news, and OSINT sources in a single query.
  432. The skill uses a **four-tier authority ranking system** to ensure the most trustworthy sources surface first. When you search for a CVE, it automatically prioritizes CISA, NVD, and MSRC (Tier 1) before checking Unit42, Talos, and Securelist (Tier 2). Threat actor queries route to vendor research blogs first. Exploit searches hit GreyNoise, VulnCheck, and AttackerKB. Every result is deduplicated, scored by source authority and recency, and returned as a structured CTI brief with extracted CVE IDs, MITRE ATT&CK technique mappings, and observed IOCs.
  433. The optional `--notebooklm` flag pushes all discovered source URLs directly into a Google NotebookLM notebook, creating a permanent, citation-backed research archive that you can query later with zero hallucination risk. This turns a one-off search into a reusable knowledge base.
  434. **Example prompts:**
  435. ```
  436. Search for threat intelligence on CVE-2024-21762
  437. Find recent LockBit ransomware reports across vendor blogs
  438. What are security vendors saying about ALPHV BlackCat?
  439. Research MITRE T1190 exploitation techniques and push to NotebookLM
  440. Collect CTI on supply chain attacks targeting npm packages
  441. ```
  442. **How it works:**
  443. 1. **Query classification** — automatically detects whether you're searching for a CVE, threat actor, malware family, exploit, or general topic
  444. 2. **Intelligent tier routing** — selects the most relevant domain tiers based on query type
  445. 3. **Batched site-scoped search** — constructs `site:` queries across domain batches using Brave Search or SerpAPI
  446. 4. **Authority-ranked deduplication** — removes duplicates, scores results by source tier and recency
  447. 5. **IOC and TTP extraction** — pulls CVE IDs, MITRE ATT&CK T-IDs, and IP indicators from result snippets
  448. 6. **Structured output** — returns a CTI brief with key findings, source table, observed tags, and next steps
  449. ---
  450. ### 2. NotebookLM Connector — Source-Grounded AI Research with Zero Hallucinations
  451. **Folder:** [`plugins/phoenix-docs-research/skills/notebooklm/`](plugins/phoenix-docs-research/skills/notebooklm/)
  452. LLM-based security research has a fundamental problem: hallucinations. When Claude can't find something in your uploaded documents, it fills the gap with plausible-sounding but potentially incorrect information — a dangerous failure mode when you're writing detection logic, threat models, or security requirements. The **NotebookLM Connector** solves this by routing questions through [Google NotebookLM](https://notebooklm.google.com/), which answers exclusively from your uploaded documents with strict citation backing.
  453. Every response from NotebookLM is grounded in the specific documents you've uploaded — PDFs, Google Docs, websites, GitHub repos, YouTube videos. If the information isn't in your sources, NotebookLM says so instead of inventing an answer. This makes it the ideal research backend for security work where accuracy is non-negotiable: vulnerability analysis, compliance documentation, API specification lookups, and threat model validation.
  454. The skill manages a **notebook library** so Claude automatically selects the right notebook for your question. Ask about authentication best practices and it routes to your security-docs notebook. Ask about API endpoints and it hits your architecture notebook. Each question runs in a fresh browser session with persistent authentication, and the built-in follow-up mechanism ensures Claude asks comprehensive questions until the research is complete.
  455. **Capabilities:**
  456. - Query any NotebookLM notebook by ID or URL with citation-backed responses
  457. - Smart notebook library management — add, remove, list, search, activate/deactivate notebooks
  458. - Automatic content discovery — query a notebook to auto-populate its metadata before saving
  459. - Browser automation with persistent Google authentication
  460. - Iterative follow-up queries to build comprehensive understanding
  461. - Coverage analysis to ensure all parts of your question are fully answered
  462. **Example prompts:**
  463. ```
  464. Query my security-docs notebook about authentication best practices
  465. Add this NotebookLM URL to my library: https://notebooklm.google.com/notebook/abc123
  466. What does my threat-model notebook say about SSRF risks?
  467. Check my API docs for rate limiting implementation details
  468. Search my notebooks for information about OAuth2 token rotation
  469. ```
  470. **Key files:**
  471. - `SKILL.md` — skill specification with decision flow and follow-up mechanism
  472. - `README.md` — comprehensive setup guide with architecture diagram and examples
  473. - `AUTHENTICATION.md` — step-by-step Google authentication setup
  474. - `scripts/` — Python automation scripts (ask_question.py, notebook_manager.py, auth_manager.py)
  475. - `references/` — API reference, troubleshooting guide, usage patterns
  476. ---
  477. ### 3. Global Research Pipeline — Automated Intelligence Collection and Ingestion
  478. **Folder:** [`plugins/phoenix-docs-research/skills/phoenix-research-pipeline/`](plugins/phoenix-docs-research/skills/phoenix-research-pipeline/)
  479. Individual searches give you snapshots. The **Global Research Pipeline** gives you systematic coverage. This skill orchestrates a multi-module research automation pipeline that collects intelligence from web searches and YouTube video transcripts, deduplicates and organizes findings, and pushes everything into Google NotebookLM for permanent, source-grounded querying.
  480. The pipeline is designed for deep-dive research scenarios where you need to gather comprehensive intelligence on an emerging threat, a new vulnerability class, or a complex security topic. Instead of running individual searches and manually copying results, the pipeline handles the entire workflow: systematic data collection across web and video sources, automated deduplication, structured formatting, and batch ingestion into your NotebookLM research archive.
  481. This creates a **repeatable research-to-analysis pipeline**: search → collect → deduplicate → ingest → query. Once findings are in NotebookLM, you can ask follow-up questions with full citation backing, cross-reference information across sources, and build on previous research without re-running searches.
  482. **Pipeline stages:**
  483. 1. **Web research** — structured searches across relevant domains with finding extraction
  484. 2. **YouTube research** — locate and transcribe relevant video content (conference talks, vendor webinars, researcher presentations)
  485. 3. **Deduplication and organization** — remove duplicates, structure results for ingestion
  486. 4. **NotebookLM push** — batch-add all collected sources to your target notebook
  487. 5. **Downstream querying** — use the NotebookLM Connector skill to query your research with zero hallucination
  488. **Example prompts:**
  489. ```
  490. Research the latest ransomware trends and push findings to NotebookLM
  491. Collect comprehensive intelligence on supply chain attacks targeting Python packages
  492. Research cloud security misconfigurations across AWS, GCP, and Azure
  493. ```
  494. ---
  495. ## Security Generation & Remediation Skills
  496. ![Phoenix Security Skill Detailed Overview — security generation and remediation skills for Claude Code](images/PHOENIX%20SECURITY%20SKILL%20DETAILED%20OVERVIEW.jpg)
  497. A focused set of skills that **generate, audit, or remediate security issues across the SDLC** — shifting security left into requirements, generating SAST detection rules from CVE/CWE research, documenting security-relevant architecture, and running diff-time / pre-merge / pre-release / design-time AppSec workflows on the codebase. Together they cover the full lifecycle from spec to ship.
  498. ### 1. Secure PRD Generator — Shift Security Left to the Requirements Stage
  499. **Folder:** [`plugins/phoenix-prd-pipeline/skills/prd-generator/`](plugins/phoenix-prd-pipeline/skills/prd-generator/)
  500. ![Shift Security Left at the PRD Stage](images/prd-pipeline.jpg)
  501. Traditional PRDs focus exclusively on features and leave security as an afterthought — discovered too late in testing, patched as a hotfix, or never addressed at all. The **Secure PRD Generator** integrates security into the requirements phase itself, running every feature description through a **10-role specification pipeline** that produces RFC 2119-compliant requirements with STRIDE threat models, abuse cases, and verification proof paths built in from the start.
  502. Each role in the pipeline handles a specialized aspect of specification: the **Context Curator** cleanses and structures the input; the **Ambiguity Hunter** flags vague instructions that cause downstream design flaws; the **Requirements Engineer** formalizes requirements with MUST/SHOULD/MAY levels and structured IDs (R-FUNC-001, R-SEC-001); the **Security Engineer** develops comprehensive threat models and abuse cases alongside the functional requirements; and the **Verification Matrix** creates concrete proof paths for every MUST-level requirement to ensure full testability.
  503. The skill integrates directly with your team's existing tools. It publishes the PRD to **Atlassian Confluence** via MCP, converts requirements into **Linear or Asana** tasks automatically, sends **Slack** notifications to stakeholders, mirrors documents to **Notion**, and drafts summary emails via **Gmail**. Every output follows a consistent security-first template with priority tags (P0/P1/P2) and traceable requirement chains.
  504. **What it produces:**
  505. - Security-first PRD in structured markdown with RFC 2119 requirement levels
  506. - STRIDE threat model with identified assets, actors, entry points, and trust boundaries
  507. - Cursor-compatible implementation plan for `.cursor/plans/`
  508. - Confluence page published to your configured space
  509. - Automated task distribution to Linear or Asana from the batch plan
  510. - Stakeholder notifications via Slack and Gmail
  511. **Example prompts:**
  512. ```
  513. Write a PRD for a user authentication system with OAuth2 and MFA
  514. Create a security-focused spec for a payment processing API
  515. Plan this feature: real-time webhook delivery system. Owner: @jane. Space: ENG.
  516. Generate requirements for a file upload service with virus scanning
  517. ```
  518. ---
  519. ### 2. OpenGrep Rule Generator — AI-Powered SAST Rule Creation
  520. **Folder:** [`plugins/phoenix-sast-rules/skills/opengrep-rule-generator/`](plugins/phoenix-sast-rules/skills/opengrep-rule-generator/)
  521. ![Generate Automatically Opengrep Rules](images/OpenGrep-Rule-Auto-Generaiton.jpg)
  522. Writing effective SAST rules is slow, error-prone, and requires deep knowledge of both the vulnerability class and the rule engine's syntax. The **OpenGrep Rule Generator** automates the entire process — from vulnerability description to validated, production-ready opengrep/semgrep YAML rules with test cases, CWE metadata, and false positive reduction patterns.
  523. The skill supports **30+ programming languages** including Python, JavaScript, TypeScript, Java, Go, Ruby, PHP, C#, Rust, Kotlin, Swift, Terraform/HCL, and Solidity. It generates two types of rules: **Search rules** for structural pattern matching (finding dangerous function calls, insecure configurations, hardcoded secrets) and **Taint rules** for data flow analysis (tracing untrusted input from sources through propagators to dangerous sinks, with sanitizer awareness).
  524. Every generated rule includes built-in false positive reduction using `pattern-not`, `pattern-not-inside`, and `metavariable-regex` patterns. The skill also generates companion test files with clearly marked true positive and true negative cases so you can validate detection accuracy before deploying to your CI pipeline.
  525. **Two workflows:**
  526. - **Guided Discovery** — interactive Q&A where Claude asks about your codebase, frameworks, and threat model before generating targeted rules
  527. - **Vulnerability-Driven** — provide a CVE, CWE, or OWASP category and get rules generated automatically with appropriate detection patterns
  528. **Example prompts:**
  529. ```
  530. Create an opengrep rule to detect SQL injection in Python Flask apps
  531. Generate a taint analysis rule for XSS in React components
  532. Write semgrep rules for OWASP Top 10 in Java Spring Boot
  533. Detect hardcoded AWS credentials in any language
  534. Build a rule to catch insecure deserialization in Python pickle usage
  535. Generate Terraform rules to detect publicly exposed S3 buckets
  536. ```
  537. **Key files:**
  538. - `SKILL.md` — full skill specification with guided and vulnerability-driven workflows
  539. - `RULES_SYNTAX.md` — comprehensive opengrep/semgrep syntax reference (patterns, operators, metavariables, taint mode)
  540. - `OPENGREP_RULE_GENERATOR_PROMPT.md` — optimized system prompt for high-quality rule generation
  541. ---
  542. ### 3. OpenGrep Rule Generator Research — Vulnerability-First Detection Engineering
  543. **Folder:** [`plugins/phoenix-sast-rules/skills/opengrep-rule-generator-research/`](plugins/phoenix-sast-rules/skills/opengrep-rule-generator-research/)
  544. ![Generate Automatically Opengrep Rules and research vulnerabilities](images/Opengrep-Rules-Research.jpg)
  545. The standard OpenGrep Rule Generator works great when you already know the pattern you want to detect. But what if you're starting from a CVE advisory, a vulnerability class, or a vague report about a new attack technique? The **Research** variant adds a **4-phase vulnerability research pipeline** that uses web search and web fetch to study the vulnerability in depth before generating detection rules — producing significantly better, more targeted rules that are grounded in real-world exploit data.
  546. This is the difference between writing a rule from a description and writing a rule from understanding. The research phase studies official advisories, analyzes proof-of-concept exploits, maps language-specific attack surfaces (sources, sinks, sanitizers, propagators), and reviews existing semgrep/opengrep rules to identify coverage gaps. The resulting rules are inherently linked to real exploit behavior, not abstract patterns.
  547. **Research pipeline (4 phases):**
  548. 1. **Vulnerability deep dive** — search CVE/CWE databases, fetch CISA/NVD/MSRC advisories, study proof-of-concept exploits to understand the actual attack mechanics
  549. 2. **Attack surface mapping** — identify specific sources, sinks, and certifiers for the target programming language based on the researched exploit behavior
  550. 3. **Existing detection gap analysis** — search for existing semgrep/opengrep rules, analyze what they catch and miss, identify coverage blind spots
  551. 4. **Grounded rule generation** — generate SAST rules that are directly linked to the researched exploit patterns, with a research summary embedded in each rule file
  552. **Example prompts:**
  553. ```
  554. Research CVE-2024-21762 and create detection rules for it
  555. Generate opengrep rules for CWE-89 (SQL Injection) in Python with full research
  556. Investigate Log4Shell and build comprehensive detection coverage for Java
  557. Research SSRF vulnerabilities in Node.js and create taint analysis rules
  558. Study the MOVEit Transfer vulnerability and write detection rules
  559. ```
  560. **When to use this vs. the standard OpenGrep Rule Generator:**
  561. - Use **OpenGrep Rule Generator** when you already know the exact code pattern you want to detect
  562. - Use **OpenGrep Rule Generator Research** when you're starting from a CVE ID, CWE class, or vulnerability description and need to understand the attack before building detection
  563. ---
  564. ### 4. Project Documentation — Turn Any Codebase into Living Documentation
  565. **Folder:** [`plugins/phoenix-docs-research/skills/project-documenter/`](plugins/phoenix-docs-research/skills/project-documenter/)
  566. ![Project Documentation: Turning Codebases into Living Documentation](images/project-documentation.jpg)
  567. Documentation drift is the silent killer of engineering velocity. Code evolves daily while docs go stale within weeks, creating security blind spots, tribal knowledge silos, and painful onboarding experiences. The **Project Documenter** skill reverse-engineers your entire codebase and produces a **three-layer hierarchical documentation system** that stays accurate because it's generated from the code itself.
  568. The skill produces a compressed **DOC_INDEX.md** routing layer (~1-2k tokens, perfect for AI assistants), an engineering **CLAUDE.md** navigation map (150-300 lines for human developers), and a complete set of **/docs/** sub-documents containing all authoritative detail — architecture diagrams, dependency maps, API references, module guides, runtime flow descriptions, and onboarding walkthroughs. Nothing is duplicated across layers.
  569. Available in **six modes** to match your needs: Express (full pack, zero questions), General (developer-facing docs), AI/LLM (prompt inventories, model architecture, agent safety), Architecture (system maps, data contracts, dependency graphs), Full (everything plus audit of existing docs), and Self-Heal (generates GitHub Actions CI, Cursor rules, and Python drift-detection scripts to keep docs permanently in sync with code changes).
  570. **Output artifacts:**
  571. - **Project Summary** — high-level overview of system purpose and function
  572. - **Architecture Diagram** — visual mapping of system components and data flow
  573. - **Dependency View** — comprehensive list and map of third-party libraries and internal links
  574. - **Service/Component Map** — structural breakdown of project organization
  575. - **Onboarding Document** — guided walkthrough for new developers and auditors
  576. - **Self-Heal CI** (Mode 5) — GitHub Actions workflow + Python scripts that detect documentation drift automatically
  577. **Example prompts:**
  578. ```
  579. Document this project (Express mode — full pack, zero questions)
  580. Generate architecture documentation for this codebase
  581. Create AI/LLM documentation including prompt inventory and model guardrails
  582. Set up self-healing documentation with GitHub Actions CI
  583. ```
  584. **Key files:**
  585. - `project-documenter.skill` — full skill definition (install in Claude.ai or Claude Code)
  586. - `project-documenter-simpler.skill` — lightweight variant for quick documentation
  587. - `HOW_IT_WORKS.md` — complete technical reference
  588. - `MODES_REFERENCE.md` — detailed guide to every mode and its outputs
  589. - `INSTALL.md` — step-by-step installation and first-run guide
  590. - `TROUBLESHOOTING.md` — common issues and fixes
  591. ---
  592. ### 5. Security Assessment Suite — Four AppSec Skills + Active Hooks
  593. ![Security Assessment Suite — four AppSec skills and active hooks for Claude Code](images/Security-automation-agents.jpg)
  594. **Folder:** [`plugins/phoenix-security-review/`](plugins/phoenix-security-review/) — see the [suite README](plugins/phoenix-security-review/README.md) for the full reference.
  595. A self-contained AppSec automation kit: four slash commands covering the security lifecycle from **diff-time** to **design-time**, a multi-language pre-merge reviewer with subagent dispatch, four hooks (SessionStart, PreToolUse, PostToolUse, SessionEnd) that feed live security context to every agent, and a one-command installer that wires it all into Claude Code, Windsurf, or Codex.
  596. **The four commands (when to use each):**
  597. | Command | Use when | Cost | Skill it runs |
  598. |---|---|---|---|
  599. | `/security-0day [base-ref]` | End of a coding cycle, before opening a PR. Diff-only LLM scan. | Low (~$0.05–$0.20) | `0day-scanner` — with the language packs as on-disk fallback |
  600. | `/security-review [scope]` | Endpoint, auth/RBAC, render, dependency, or config change. Pre-merge gate. | Low–Medium | `security-reviewer` — Python, JS/TS, Go, Java/Kotlin, Rust, Ruby, .NET |
  601. | `/security-audit [scope]` | Pre-release, compliance audit, post-incident. Full OWASP Top 10 (2025) + ASVS Level 1 sweep. | High (~$8–$10) | `security-assessment` — with the OWASP/ASVS checklists as fallback |
  602. | `/threatmodel [scope]` | Architecture review, new-feature design, compliance docs. | Medium | `threat-modeling` — STRIDE + DREAD with attack trees and a mitigation matrix |
  603. Two more skills come with the plugin and have no command of their own — ask for them by name,
  604. or let Claude pick them up from the request: `tm-quick-security-assessment` (quick tier — a
  605. threat-model-aware pass over only what changed vs a base ref) and `tm-security-review`
  606. (comprehensive tier — build the full STRIDE model, then a triple-pass HUNT → JUDGE → VERIFY
  607. exploit review that proves a runnable PoC per confirmed finding).
  608. **Active hooks (full preset only — opt out for the lite preset):**
  609. - **`SessionStart`** fingerprints the project, runs a fast dependency audit (osv-scanner if installed, else npm/pip/cargo/go/bundle audits per ecosystem), and injects a `## SECURITY CONTEXT` block every agent reads before its first turn.
  610. - **`PreToolUse` on `Bash`** gates `npm/yarn/pnpm/pip/uv/poetry/cargo/go get/gem/bundle/composer/dotnet add` invocations. Blocks known-malicious packages, asks on typosquats and brand-new packages.
  611. - **`PostToolUse` on `Edit|Write|MultiEdit`** runs a fast pattern scan on every file write (SQL string formatting, `innerHTML`, hardcoded secrets, etc.) and feeds findings back via `additionalContext`.
  612. - **`SessionEnd`** prints a one-line reminder to run `/security-0day` if your branch has unscanned changes vs `main`. Zero LLM cost.
  613. **The hooks are opt-in.** Installing the plugin gives you the six skills, the four slash
  614. commands and the subagent immediately. The three active hooks are *not* wired automatically,
  615. because a `PreToolUse` gate on every Bash call and a scan on every file write should be your
  616. decision, not a side effect of installing a plugin.
  617. To wire them, run the bundled installer from your project root:
  618. ```bash
  619. PLUGIN=~/.claude/plugins/marketplaces/phoenix-security/plugins/phoenix-security-review
  620. bash "$PLUGIN/install/install.sh" --full
  621. ```
  622. The installer:
  623. 1. Copies the four slash commands into `.claude/commands/`.
  624. 2. Merges the chosen hook preset into `.claude/settings.json` (uses `jq` if available; backs up your existing settings first; tracks installer-created files so `--uninstall` is clean).
  625. 3. Copies the security-reviewer subagent into `.claude/agents/` (full preset only).
  626. 4. Chmods all hook scripts.
  627. **Variants:**
  628. - `install.sh` *(default)* or `install.sh --lite` — slash commands + SessionEnd reminder hook only. Zero LLM cost.
  629. - `install.sh --full` — everything in lite **plus** the three active hooks **plus** the subagent.
  630. - `install.sh --dry-run [--lite|--full]` — preview without writing.
  631. - `install.sh --uninstall` — remove commands + subagent, restore `.claude/settings.json` from the backup.
  632. **Other tools:**
  633. - **Windsurf** — `cp` a rule into `.windsurf/rules/` (auto-fires on endpoint/auth/render/dep changes) and two workflows (`/security-assessment`, `/threatmodel`) into `.windsurf/workflows/`. One-line install in the suite README.
  634. - **Codex CLI** — `cat` the `AGENTS.md.snippet` onto your project's `AGENTS.md`. Codex has no hook system, so this is enforced as a behavioral instruction.
  635. **Optional dependencies:**
  636. - `jq` — recommended for clean settings.json merge (installer falls back to copy-paste instructions if absent).
  637. - `ripgrep` — required by the post-edit-quickscan hook (already required by Claude Code itself).
  638. - `osv-scanner` — optional; richer dependency audit at SessionStart. `brew install osv-scanner` or `go install github.com/google/osv-scanner/cmd/osv-scanner@latest`.
  639. **Example prompts:**
  640. ```
  641. /security-0day # scan diff vs main with the LLM 0-day scanner
  642. /security-0day origin/release-1.4 # scan diff vs a different base ref
  643. /security-review auth # 8-point check focused on auth surfaces
  644. /security-audit backend # full OWASP/ASVS sweep, backend only
  645. /threatmodel src/payments/ # STRIDE + DREAD threat model for the payments component
  646. ```
  647. **When the four skills overlap (and how to pick):**
  648. ```
  649. Are you reviewing a specific diff/PR/commit?
  650. ├── Yes → /security-0day
  651. └── No → Did the change touch endpoints/auth/render/deps/config?
  652. ├── Yes → /security-review
  653. └── No → Pre-release / quarterly audit?
  654. ├── Yes → /security-audit
  655. └── No → New feature / architecture design?
  656. ├── Yes → /threatmodel
  657. └── No → You probably don't need this suite right now.
  658. ```
  659. **Key files** (all paths relative to `plugins/phoenix-security-review/`):
  660. - `README.md` — suite overview, decision tree, hook reference, subagent details, cross-skill integration diagram, troubleshooting.
  661. - `skills/security-reviewer/` — the canonical multi-language reviewer: the 8-point check, 7 per-language reference packs in `languages/`, OWASP/ASVS + endpoint checklists in `checklists/`, and a triage playbook in `playbooks/`. Also the on-disk fallback for `security-assessment` and `0day-scanner` when their MCP tools are unreachable.
  662. - `commands/` — the four slash command definitions (each a thin wrapper over a skill).
  663. - `agents/security-reviewer.md` — the review subagent.
  664. - `hooks/` — the three hook scripts plus `lib/common.sh`.
  665. - `install/install.sh` — the opt-in hook installer.
  666. - `install/hooks/settings.{lite,full}.example.json` — ready-to-merge `.claude/settings.json` blocks.
  667. - `install/windsurf/` — Windsurf rule + workflows.
  668. - `install/codex/AGENTS.md.snippet` — Codex behavioural instruction.
  669. - `references/security-analysis-agent/` — parameterised backend/frontend tester templates with `{{PLACEHOLDERS}}` (hydrate before use).
  670. ---
  671. ## Plugins Reference
  672. ### 1. CTI Search Plugin
  673. **Folder:** [`plugins/phoenix-cti-search/`](plugins/phoenix-cti-search/)
  674. The execution engine behind CTI searches. Available as a **CLI tool**, **MCP server**, or **slash command**.
  675. #### Usage Modes
  676. **Slash command:**
  677. ```
  678. /cti-search CVE-2024-21762
  679. /cti-search LockBit ransomware --full --since 30
  680. /cti-search ALPHV --notebooklm --tier 2
  681. ```
  682. **CLI:**
  683. ```bash
  684. node index.js --query "CVE-2024-21762" --full
  685. node index.js --query "LockBit" --tier 2 --since 30 --notebooklm
  686. node index.js --query "supply chain attack npm" --json
  687. ```
  688. **MCP tool (conversational):**
  689. ```
  690. Use the CTI search tool to find recent ransomware reports
  691. ```
  692. #### Flags
  693. | Flag | Description | Default |
  694. |------|-------------|---------|
  695. | `--query <q>` | Search subject (required) | — |
  696. | `--count <n>` | Results per tier | 10 |
  697. | `--tier <1-4>` | Restrict to specific tier | All |
  698. | `--since <days>` | Recency filter | 90 |
  699. | `--full` | Long-form brief with MITRE mapping | Brief |
  700. | `--json` | Raw JSON output | Formatted |
  701. | `--notebooklm` | Push sources to NotebookLM | Disabled |
  702. | `--notebook-id <id>` | Override NotebookLM notebook | From env |
  703. ---
  704. ### 2. Secure PRD Plugin
  705. **Folder:** [`plugins/phoenix-prd-pipeline/dist/claude-ai-web/`](plugins/phoenix-prd-pipeline/dist/claude-ai-web/)
  706. Generates security-focused Product Requirements Documents and integrates with external project management tools:
  707. - **Atlassian Confluence** — publishes PRD as a page
  708. - **Linear / Asana** — creates tasks from requirements
  709. - **Slack** — sends notifications on PRD completion
  710. - **Notion** — mirrors the PRD
  711. - **Gmail** — drafts stakeholder emails
  712. ---
  713. ## Phoenix Pipeline — Feature Descriptor
  714. **Folder:** [`plugins/phoenix-prd-pipeline/skills/`](plugins/phoenix-prd-pipeline/skills/)
  715. The Phoenix Pipeline is a **12-role specification system** that breaks down feature requirements into discrete, expert-reviewed stages. Each role is a standalone `.skill` file that can be used independently or orchestrated together.
  716. ### How It Works
  717. ```
  718. Input (feature request / brief)
  719. │
  720. ├─→ Context Curator — extract and cleanse context
  721. ├─→ Scope Cutter — define in/out scope
  722. ├─→ Constraint Distiller — identify constraints + acceptance criteria
  723. ├─→ Requirements Engineer — RFC 2119 requirements with IDs
  724. ├─→ Ambiguity Hunter — flag and resolve ambiguities
  725. ├─→ Security Engineer — threat models + abuse cases
  726. ├─→ Contract Architect — API design, events, errors
  727. ├─→ Verification Matrix — proof paths for every requirement
  728. ├─→ Batch Planner — incremental delivery plan
  729. ├─→ Final Gate — go/no-go with blocker list
  730. │
  731. └─→ Output: production-ready PRD with security built in
  732. ```
  733. The **Pipeline Navigator** orchestrates the flow, and the **Orchestrator** coordinates handoffs between roles.
  734. ---
  735. ## Domain Tiers
  736. The CTI search uses a four-tier domain system for intelligent query routing:
  737. | Tier | Category | Use Case | Example Sources |
  738. |------|----------|----------|-----------------|
  739. | **T1** | Authoritative / Government | CVEs, advisories, official alerts | CISA, NVD, MSRC, NCSC, Red Hat |
  740. | **T2** | Vendor Research | Deep technical analysis | Unit42, Talos, Securelist, DFIR Report, Mandiant |
  741. | **T3** | News / Community | Situational awareness | BleepingComputer, Krebs on Security, The Record, Hacker News |
  742. | **T4** | OSINT / PoC | Malware samples, exploits, indicators | any.run, VulnCheck, AttackerKB, GreyNoise |
  743. ### Routing Logic
  744. | Query Type | Primary Tier | Secondary Tier |
  745. |------------|-------------|----------------|
  746. | CVE lookups | T1 (authoritative) | T2 (vendor analysis) |
  747. | Threat actors / malware | T2 (research) | T4 (OSINT) |
  748. | News / situational | T3 (news) | T2 (context) |
  749. | PoC / exploits | T4 (technical) | T2 (details) |
  750. | General queries | All tiers | Ranked by authority |
  751. ---
  752. ## NotebookLM Integration
  753. Push CTI research findings directly into [Google NotebookLM](https://notebooklm.google.com/) for citation-backed analysis powered by Gemini.
  754. ### Setup
  755. 1. Install the [notebooklm-connector plugin](https://github.com/Security-Phoenix-demo/security-skills-claude-code/tree/main/skills/notebooklm)
  756. 2. Get your notebook ID from the URL: `https://notebooklm.google.com/notebook/<YOUR-ID>`
  757. 3. Set environment variable: `export NOTEBOOKLM_NOTEBOOK_ID=your_id`
  758. ### Usage
  759. ```bash
  760. /cti-search CVE-2024-21762 --notebooklm
  761. ```
  762. The plugin searches, collects result URLs, pushes them as sources to your notebook, and reports the count.
  763. ---
  764. ## Configuration & Customization
  765. All skills and plugins are designed to be customized for your organization. No internal identifiers, names, or workspace details are hardcoded — you provide your own on first use.
  766. ### Skill Customization
  767. #### CTI Search — Customization
  768. | Setting | How to Set | Notes |
  769. |---------|-----------|-------|
  770. | Search API key | `.env` file or environment variable | Brave Search recommended (free tier) |
  771. | NotebookLM notebook ID | `.env` or `--notebook-id` flag | Optional — for research ingestion |
  772. | Custom domains | Edit `data/domains.txt` + `data/tier-map.json` | Add your own security sources |
  773. | Default result count | `--count N` flag | Per-query override |
  774. #### Secure PRD — Customization
  775. On first use, Claude will prompt you for:
  776. | Setting | How to Set | Notes |
  777. |---------|-----------|-------|
  778. | Owner name(s) | Prompt, env var `PRD_OWNER`, or in-message | Shown on all PRD outputs |
  779. | Stakeholders | Prompt, env var `PRD_STAKEHOLDERS`, or in-message | Interested parties list |
  780. | Confluence space key | Prompt, env var `PRD_CONFLUENCE_SPACE`, or in-message | Where PRD pages are created |
  781. | Confluence template | Prompt, env var `PRD_CONFLUENCE_TEMPLATE`, or in-message | Parent page for nesting |
  782. | Slack channel | In-message or prompt | Optional notifications |
  783. | Email recipients | In-message or prompt | Optional Gmail drafts |
  784. You can set these persistently via environment variables:
  785. ```bash
  786. export PRD_OWNER="@your-name"
  787. export PRD_STAKEHOLDERS="@lead1, @lead2"
  788. export PRD_CONFLUENCE_SPACE="ENG"
  789. export PRD_CONFLUENCE_TEMPLATE="PRD Templates"
  790. ```
  791. Or override per request: `Write a PRD for X. Owner: @jane. Space: PRODUCT.`
  792. ---
  793. ### Required: Search API Key
  794. | Provider | Free Tier | Get Key |
  795. |----------|-----------|---------|
  796. | **Brave Search** (recommended) | 2,000 requests/month | [api.search.brave.com](https://api.search.brave.com/app/keys) |
  797. | SerpAPI | 100 requests/month | [serpapi.com](https://serpapi.com) |
  798. ### Environment Variables
  799. Create a `.env` file in the plugin directory or export system-wide:
  800. ```bash
  801. # Required
  802. BRAVE_SEARCH_API_KEY=your_brave_api_key_here
  803. SEARCH_PROVIDER=brave
  804. # Optional — NotebookLM
  805. NOTEBOOKLM_NOTEBOOK_ID=your_notebook_id_here
  806. ```
  807. ### Verify Installation
  808. ```bash
  809. # What is installed, and from which marketplace
  810. claude plugin list
  811. # What a plugin actually exposes — skills, agents, hooks, projected token cost
  812. claude plugin details phoenix-cti-search
  813. # Test the CTI CLI (dry run, no API call)
  814. CTI=~/.claude/plugins/marketplaces/phoenix-security/plugins/phoenix-cti-search
  815. node "$CTI/index.js" --query "CVE-2024-21762" --dry-run
  816. ```
  817. ---
  818. ## Contributing
  819. We welcome contributions from the global security community. Whether you're adding a new skill, improving an existing plugin, curating domains, or fixing docs — every contribution matters.
  820. See the **[Contributing Guide](CONTRIBUTING.md)** for:
  821. - Step-by-step instructions to add new skills and plugins
  822. - Templates for `SKILL.md`, `README.md`, `install.sh`, and MCP servers
  823. - Documentation standards and testing checklists
  824. - Pull request process and code review expectations
  825. **Quick start:**
  826. ```bash
  827. # 1. Fork this repository
  828. # 2. Clone your fork
  829. git clone https://github.com/Security-Phoenix-demo/security-skills-claude-code.git
  830. cd security-skills-claude-code
  831. # 3. Create a feature branch
  832. git checkout -b feature/your-new-skill
  833. # 4. Follow the Contributing Guide
  834. # 5. Submit a pull request
  835. ```
  836. ---
  837. ## Frequently Asked Questions (FAQ)
  838. ### General
  839. <details>
  840. <summary><strong>What is Claude Code and why do I need it?</strong></summary>
  841. Claude Code is Anthropic's official CLI for AI-assisted software engineering. It lets you interact with Claude directly from your terminal. These skills and plugins extend Claude Code with security-specific capabilities — like searching 300+ threat intelligence sources or generating security-focused product requirements.
  842. </details>
  843. <details>
  844. <summary><strong>Is this free to use?</strong></summary>
  845. Yes. This repository is open source under the MIT License. You need a Claude Code subscription from Anthropic and a free API key from Brave Search (2,000 requests/month) or SerpAPI (100 requests/month).
  846. </details>
  847. <details>
  848. <summary><strong>What is the difference between a skill and a plugin?</strong></summary>
  849. **Skills** are instruction-based — they define *how* Claude should approach a task (workflow, reasoning, output format) but don't execute code. **Plugins** are executable — they run as MCP servers or CLI tools, make API calls, and return structured data. Skills often reference plugins for execution.
  850. </details>
  851. <details>
  852. <summary><strong>Can I use these skills with Cursor or other Claude-compatible editors?</strong></summary>
  853. Yes. Skills can be copied to `~/.cursor/skills/` for Cursor. Plugins that run as MCP servers work with any MCP-compatible client. Check your editor's documentation for MCP server configuration.
  854. </details>
  855. ### Installation & Setup
  856. <details>
  857. <summary><strong>Which search API provider should I choose?</strong></summary>
  858. **Brave Search** is recommended — it offers 2,000 free requests per month and has excellent coverage of security sources. SerpAPI works but is limited to 100 free requests per month.
  859. </details>
  860. <details>
  861. <summary><strong>How do I install only specific skills or plugins?</strong></summary>
  862. Each plugin is independent — install only the ones you want:
  863. ```
  864. /plugin marketplace add Security-Phoenix-demo/security-skills-claude-code
  865. /plugin install phoenix-readiness-reviews@phoenix-security
  866. ```
  867. Want a single skill rather than a whole plugin? A skill directory is self-contained, so copy
  868. just that one in:
  869. ```bash
  870. git clone https://github.com/Security-Phoenix-demo/security-skills-claude-code.git
  871. cp -r security-skills-claude-code/plugins/phoenix-cti-search/skills/cti-domain-research ~/.claude/skills/
  872. ```
  873. </details>
  874. <details>
  875. <summary><strong>Do I need Node.js?</strong></summary>
  876. Only for `phoenix-cti-search`, and only for its bundled CLI and MCP server. Every skill in
  877. this repository is pure instructions with no runtime dependency — including
  878. `cti-domain-research`, which does the same tiered search using Claude's own web-search tools
  879. and needs neither Node nor an API key. Two exceptions worth knowing: the `notebooklm` skill
  880. needs Python and a Chrome browser, and `production-readiness-review` ships a bash scanner
  881. (bash and grep only; it uses ripgrep when present).
  882. </details>
  883. <details>
  884. <summary><strong>The skill doesn't activate when I ask a question. What's wrong?</strong></summary>
  885. 1. Verify it is loaded: run `claude plugin list`, then `claude plugin details <plugin-name>`
  886. and look for the skill in the component inventory
  887. 2. Run `/plugin` and check the plugin is *enabled*, not only installed
  888. 3. Try explicit trigger phrases: *"Use the CTI domain research skill to search for..."*
  889. 4. See the [Marketplace Install Troubleshooting](MARKETPLACE_INSTALL.md#troubleshooting) for more solutions
  890. </details>
  891. ### CTI Search
  892. <details>
  893. <summary><strong>How many security domains are included?</strong></summary>
  894. The curated domain list includes **595+ security sources** across four tiers: government/authoritative sources (CISA, NVD, MSRC), vendor research labs (Unit42, Talos, Mandiant), security news (BleepingComputer, Krebs), and OSINT/PoC sources (GreyNoise, VulnCheck).
  895. </details>
  896. <details>
  897. <summary><strong>Can I add my own domains to the search?</strong></summary>
  898. Yes. Edit `plugins/phoenix-cti-search/data/domains.txt` (one domain per line) and update `data/tier-map.json` with the tier and authority score. See the [Contributing Guide](CONTRIBUTING.md) for details.
  899. </details>
  900. <details>
  901. <summary><strong>What is the NotebookLM integration?</strong></summary>
  902. When you use the `--notebooklm` flag, the plugin pushes all result URLs as sources into a Google NotebookLM notebook. NotebookLM then provides citation-backed answers grounded only in those sources — dramatically reducing hallucination when analyzing CTI findings.
  903. </details>
  904. <details>
  905. <summary><strong>How does tier-based routing work?</strong></summary>
  906. The system classifies your query type (CVE, threat actor, malware, news, PoC) and routes it to the most relevant domain tier first. CVE queries hit authoritative government sources (T1) before vendor analysis (T2). Threat actor queries start with vendor research labs (T2). This ensures the most authoritative results surface first.
  907. </details>
  908. ### OpenGrep / SAST Rules
  909. <details>
  910. <summary><strong>What is opengrep and how does it relate to semgrep?</strong></summary>
  911. OpenGrep is an open-source fork of semgrep focused on static application security testing (SAST). The rule syntax is fully compatible — rules generated by this skill work with both opengrep and semgrep. The skill generates YAML rule files that can be run with either tool to detect vulnerabilities in your codebase.
  912. </details>
  913. <details>
  914. <summary><strong>What languages does the OpenGrep Rule Generator support?</strong></summary>
  915. Over 30 languages including: Python, JavaScript, TypeScript, Java, Go, Ruby, PHP, C#, Rust, Kotlin, Swift, Scala, Terraform/HCL, Solidity, Bash, C, C++, Lua, OCaml, R, and more. Both search-mode (structural pattern matching) and taint-mode (data flow analysis) rules are supported for most languages.
  916. </details>
  917. <details>
  918. <summary><strong>What is the difference between the standard and research versions of OpenGrep Rule Generator?</strong></summary>
  919. The **standard** version (`opengrep-rule-generator`) generates rules from your description — use it when you know what pattern to detect. The **research** version (`opengrep-rule-generator-research`) adds a 4-phase vulnerability research pipeline that uses web search to study CVEs/CWEs, map attack surfaces, and find existing detection gaps before generating rules. Use the research version when you're starting from a CVE ID or vulnerability class rather than a known code pattern.
  920. </details>
  921. <details>
  922. <summary><strong>Can I generate rules for OWASP Top 10 in batch?</strong></summary>
  923. Yes. Ask Claude to "generate opengrep rules for OWASP Top 10 in [language]" and it will produce rules covering injection, broken auth, XSS, insecure deserialization, and other categories with appropriate CWE/OWASP metadata tags.
  924. </details>
  925. ### NotebookLM
  926. <details>
  927. <summary><strong>What is the NotebookLM Connector skill?</strong></summary>
  928. It lets you query your Google NotebookLM notebooks directly from Claude Code. NotebookLM provides source-grounded, citation-backed answers from Gemini — meaning responses are based only on documents you've uploaded, with drastically reduced hallucination. This is especially powerful for security research where accuracy matters.
  929. </details>
  930. <details>
  931. <summary><strong>What do I need to use the NotebookLM skill?</strong></summary>
  932. You need: (1) Chrome or Edge browser running, (2) the "Claude in Chrome" extension installed and connected, (3) a Google account logged in to NotebookLM. Authentication is a one-time setup — see `plugins/phoenix-docs-research/skills/notebooklm/AUTHENTICATION.md` for the step-by-step guide.
  933. </details>
  934. <details>
  935. <summary><strong>How does NotebookLM integration work with CTI Search?</strong></summary>
  936. Two complementary workflows: The **CTI Search** plugin can push result URLs into a NotebookLM notebook using the `--notebooklm` flag. The **NotebookLM Connector** skill can then query that same notebook for citation-backed analysis of the findings. Together, they create a research-to-analysis pipeline: search → ingest → query.
  937. </details>
  938. ### Phoenix Pipeline & PRD
  939. <details>
  940. <summary><strong>What is the Phoenix Pipeline?</strong></summary>
  941. It's a 12-role specification system that breaks feature requirements into expert-reviewed stages — from context extraction through scope definition, constraint analysis, security threat modeling, API design, verification matrices, and delivery planning. Each role is a standalone skill file in the `plugins/phoenix-prd-pipeline/skills/` folder.
  942. </details>
  943. <details>
  944. <summary><strong>Can I use individual Phoenix Pipeline roles without the full pipeline?</strong></summary>
  945. Yes. Each of the 12 roles is a standalone skill inside `phoenix-prd-pipeline`. You can use just the Security Engineer role for threat modeling, or just the Ambiguity Hunter to review existing requirements.
  946. </details>
  947. <details>
  948. <summary><strong>Does the Secure PRD Generator integrate with project management tools?</strong></summary>
  949. Yes. Through MCP integrations, the PRD generator can publish to Atlassian Confluence, create tasks in Linear or Asana, send Slack notifications, mirror pages in Notion, and draft emails via Gmail. Configuration depends on which MCP servers you have connected.
  950. </details>
  951. ### Contributing
  952. <details>
  953. <summary><strong>How can I contribute a new skill?</strong></summary>
  954. Fork the repo, create a skill directory under the right plugin's `skills/` folder, add a `SKILL.md` (with frontmatter), `README.md`, and `install.sh`, then submit a pull request. Full templates and standards are in the [Contributing Guide](CONTRIBUTING.md).
  955. </details>
  956. <details>
  957. <summary><strong>I found a bug or want to request a feature. Where do I go?</strong></summary>
  958. Open a [GitHub Issue](https://github.com/Security-Phoenix-demo/security-skills-claude-code/issues) for bugs or feature requests. For questions and ideas, use [GitHub Discussions](https://github.com/Security-Phoenix-demo/security-skills-claude-code/discussions).
  959. </details>
  960. <details>
  961. <summary><strong>Can I use these skills in a commercial product?</strong></summary>
  962. Yes. The MIT License allows commercial use, modification, and distribution. See the [LICENSE](LICENSE) file.
  963. </details>
  964. ### Security & Privacy
  965. <details>
  966. <summary><strong>Does this tool store or transmit my data?</strong></summary>
  967. No. All searches are executed through your configured search API (Brave or SerpAPI) with your own API key. No data is sent to Phoenix Security or any third party beyond your chosen search provider. NotebookLM integration is optional and uses your own Google account.
  968. </details>
  969. <details>
  970. <summary><strong>Is this safe to use for legitimate security research?</strong></summary>
  971. Yes. This toolkit is designed for defensive security, threat intelligence, and security engineering workflows. It queries public security sources and does not perform active scanning, exploitation, or any offensive operations.
  972. </details>
  973. ---
  974. ## Detailed Documentation
  975. | Document | Description |
  976. |----------|-------------|
  977. | **[README.md](README.md)** | This file — overview, quick start, FAQ |
  978. | **[MARKETPLACE_INSTALL.md](MARKETPLACE_INSTALL.md)** | Step-by-step marketplace installation with troubleshooting |
  979. | **[CONTRIBUTING.md](CONTRIBUTING.md)** | How to add skills, plugins, and domains |
  980. | **[LICENSE](LICENSE)** | MIT License |
  981. | **[Readiness Reviews](plugins/phoenix-readiness-reviews/)** | The two review gates + the deterministic repo scanner |
  982. | **[Security Review Suite](plugins/phoenix-security-review/)** | 6 AppSec skills, 4 commands, subagent, hooks, Windsurf and Codex install |
  983. | **[CTI Skill Docs](plugins/phoenix-cti-search/skills/cti-domain-research/)** | CTI domain research skill specification |
  984. | **[CTI Plugin Docs](plugins/phoenix-cti-search/)** | Plugin architecture, MCP server, CLI reference |
  985. | **[Secure PRD Docs](plugins/phoenix-prd-pipeline/skills/prd-generator/)** | PRD generation skill specification |
  986. | **[OpenGrep Rule Generator](plugins/phoenix-sast-rules/skills/opengrep-rule-generator/)** | SAST rule generation skill + syntax reference |
  987. | **[OpenGrep Research](plugins/phoenix-sast-rules/skills/opengrep-rule-generator-research/)** | Vulnerability research + rule generation |
  988. | **[NotebookLM Connector](plugins/phoenix-docs-research/skills/notebooklm/)** | NotebookLM querying skill + authentication guide |
  989. | **[Research Pipeline](plugins/phoenix-docs-research/skills/phoenix-research-pipeline/)** | Global research pipeline documentation |
  990. | **[Project Docs Skill](plugins/phoenix-docs-research/skills/project-documenter/)** | Project documentation skill |
  991. | **[Phoenix Pipeline](plugins/phoenix-prd-pipeline/skills/)** | 12-role feature specification pipeline |
  992. ---
  993. ## License
  994. MIT License — see [LICENSE](LICENSE) for details.
  995. ---
  996. ## Support
  997. - **Issues:** [GitHub Issues](https://github.com/Security-Phoenix-demo/security-skills-claude-code/issues) — bugs and feature requests
  998. - **Discussions:** [GitHub Discussions](https://github.com/Security-Phoenix-demo/security-skills-claude-code/discussions) — questions and ideas
  999. - **Documentation:** See the [detailed docs table](#detailed-documentation) above
  1000. ---
  1001. ## Security Note
  1002. This toolkit is designed for **legitimate security research and threat intelligence gathering**. Always:
  1003. - Respect rate limits and terms of service for search APIs
  1004. - Use responsibly and ethically
  1005. - Follow responsible disclosure practices
  1006. - Comply with applicable laws and regulations in your jurisdiction
  1007. ---
  1008. ## Acknowledgments
  1009. Built and maintained by the **engineering and security engineering teams at [Phoenix Security](https://phoenix.security)** for the global security community.
  1010. - Open sourced for everyone to use, improve, and extend
  1011. - Curated domain list includes 595+ trusted security sources
  1012. - Designed for the Claude Code ecosystem and Claude Marketplace
  1013. - Inspired by the need for efficient, structured, and repeatable CTI research workflows
  1014. **Contributors are welcome from anywhere in the world.** See [CONTRIBUTING.md](CONTRIBUTING.md) to get started.
  1015. ---
  1016. <p align="center">
  1017. <strong>Made with purpose by <a href="https://phoenix.security">Phoenix Security</a></strong><br>
  1018. Security skills for the AI-native developer
  1019. </p>

Ratings and comments

Sign in to rate this skill.

Sign in

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