81 security skills for Claude Code that encode the judgment professionals bring — not another wrapper around a scanner. Offense, defense, and the reverse-engineering / code-audit core both sides share. Every skill fact-checked against primary sources.

Claude already knows what nmap -sV does. What it does not reliably hold is the discipline: trace a finding to demonstrated impact before you report it, capture memory before someone reimages the box, refuse to ship a detection that was never tested against production noise, notice the honeypot before you touch it. SecSkills is that discipline, written down and routed to the moment it applies.

Three plugins in one marketplace — install only the side you work:

/plugin marketplace add trilwu/secskills

# Offensive — red team / pentest / offensive AppSec
/plugin install secskills-offense@secskills-marketplace
/plugin install secskills-core@secskills-marketplace

# Defensive — DFIR / SOC / detection
/plugin install secskills-defense@secskills-marketplace
/plugin install secskills-core@secskills-marketplace

/reload-plugins

Skills reference their siblings by name across plugins; a hand-off to a skill you did not install is an inert mention, so nothing breaks — you get the skills you have.

SecSkills is built for four working roles. Each gets a coherent toolkit, not a grab-bag.

Full attack-chain methodology with the tradecraft judgment that separates a finding from a footgun: recon and enumeration, Active Directory and Entra ID (Kerberos delegation, AD CS ESC1–16, DCSync), cloud and managed Kubernetes, container escapes, mobile, wireless, and web/API/auth exploitation. Plus the engagement discipline most collections skip — recognizing-deception (spot the honeypot/canary before you trip it), maintaining-engagement-state (credential provenance and the cleanup register that survives a context window), and reporting-security-findings.

Source-audit methodology with a four-question verification gate, PR review that reads the lines a change removed, cryptography-misuse review, supply-chain and CI/CD auditing, and AI/LLM + MCP security. Language-agnostic by default, with auditing-php-applications for PHP's specific footguns (unserialize/phar:// POP chains, type-juggling auth bypass, php:// wrappers) and hunting-web-backdoors for planted webshells. Reach into offense when you need to demonstrate the bug, not just describe it.

Preserve-first response: memory/disk/network forensics, malware and shellcode analysis, Windows endpoint DFIR, Linux persistence hunting, and cross-cloud incident investigation for AWS, Azure, GCP, and M365/Entra — each built around the audit-log defaults that decide whether a question is even answerable. Backed by the RE core (native, Go/Rust/.NET, iOS, firmware, packers).

The high-volume work, done with base-rate discipline: triaging-security-alerts (the true / benign-true / false-positive distinction that keeps a detection program alive), detection-as-code across Sigma/YARA/Suricata with real false-positive analysis, hypothesis-driven threat hunting, risk-based vulnerability management (KEV + EPSS, not raw CVSS), and finished threat intelligence with attribution discipline.

Cloud and Kubernetes are covered from both sides — exploiting-cloud-platforms / attacking-eks-gke-aks for red, hardening-cloud-posture / defending-kubernetes / investigating-*-incidents for blue — so purple-team work stays in one vocabulary.

Each skill is a methodology, not a command dump, with three things a cheat sheet does not give you:

• An explicit scope and hand-off. Every skill says when to use a different one, named in backticks. That is how 81 skills compose instead of colliding.
• A Rationalizations to Reject section — the plausible-sounding shortcuts that cause missed findings and bad calls, each with why it is wrong. This is the highest-value part of most skills; it is the judgment a command list cannot carry.
• Two tiers that stay out of your way. Domain skills carry methodology for a whole area and trigger on plain-language requests. Procedure skills cover one exact target-and-toolchain that is rare and unrecoverable from general knowledge — reversing a Flutter app with blutter, say — and load only when their identifying evidence is present. Neither costs context until it applies.

All 81 skills have been verified line-by-line against primary sources — vendor docs, RFCs, tool source — and carry a verified: date in frontmatter. This is the differentiator: it is the opposite of confidently-wrong AI output.

python3 scripts/validate.py --strict                 # "Fact-checked ...: 81/81"
grep -L "^verified:" secskills-*/skills/*/SKILL.md   # unverified skills (none)

What that pass caught is why it exists. The first sampled dozen skills held 31 factual errors — ~2.6 per skill — so the whole collection was driven through the same pass. Cross-cutting sweeps then found the high-impact ones: CrackMapExec archived since 2023 (14 dead invocations → NetExec/nxc), the retired AzureAD PowerShell module (→ Microsoft Graph), Volatility's entry point wrong in ~40 commands (vol, not volatility3), a fabricated Sigma utf8 modifier, and stale M365 audit-log retention that would read an empty 90-day window as "no activity" when six months of history existed.

Two honest caveats:

• verified: is dated, not eternal. Tool flags, CVE version bounds, retention windows, and API paths drift. Trust the methodology — the sequencing, the scope, the Rationalizations to Reject — and re-confirm any specific before it lands in a deliverable. The re-verification method is itself a skill: .claude/skills/verifying-skill-accuracy.
• CI checks form, not truth. validate.py, sync_attack.py, and run_evals.py verify structure, the ATT&CK index, and routing against self-authored cases. A green run means well-formed; the verified: dates are the accuracy signal.

analyzing-binaries is the native reverse-engineering domain skill — triage, disassembly (Ghidra/radare2/IDA), and instrumentation — that the language- and framework-specific procedures below hand back to.

Narrow by design — each triggers on the artifacts or the symptom that identifies the situation, and hands back to the domain skill when done.

Techniques are indexed in secskills-core/ttp-index.json (143 mapped, spanning all three plugins), which generates the ## ATT&CK Coverage section in each skill. CI fails if a section drifts from the index, and skills that use a different framework — ATLAS for AI, the Mobile matrix, CWE for code-level work — are declared as such rather than counted as coverage.

Hunt a hacked site (DFIR / AppSec)

"This WordPress site is redirecting to spam and grep for eval comes back empty."

Explains that an empty grep is not a clean tree — concatenation and callback sinks evade it — then diffs against a pristine copy, checks functions.php for append-infection, and decodes any obfuscation statically, never by running it.

Work an alert (SOC)

"EDR critical: a signed vendor binary opened an LSASS handle at 03:00, 47th time."

Reads it as a likely benign true positive, warns against filing it as a false positive (which weakens a working rule), and sends an authorized-context filter to detection engineering instead.

Drive a domain (Red team)

"BloodHound flags svc_backup_admin — DA, SPN set, but no logon history. Roast it?"

Flags the profile as a probable honeyuser whose Kerberoast raises a high-fidelity alert, and routes around it — recording provenance as it goes.

Investigate GCP (DFIR)

"A leaked service-account key was used. Did they read our storage buckets?"

Answers with the audit-log defaults: GCP Data Access logging is off unless enabled in advance, so it reports a visibility gap, not "no exfiltration."

Assess an AI feature (AppSec)

"Review this RAG agent for prompt injection."

Checks whether the lethal trifecta closes — private data, untrusted content, and egress in one agent — before any payload, and refuses prompt-level defenses as a control.

SecSkills is domain expertise, not a scanner. It complements first-party tooling rather than replacing it:

The scanners find what they have rules for; the skills supply the reasoning around them.

Claude Code, and the tools a given technique calls for (nmap, semgrep, vol (Volatility 3), capa, ghidra, …) installed separately. The plugin supplies knowledge and method, not binaries.

See CONTRIBUTING.md for the authoring standard. Before opening a PR:

python3 scripts/validate.py --strict     # frontmatter, sections, manifests, verified count
python3 scripts/sync_attack.py --check   # ATT&CK sections match the index
python3 scripts/run_evals.py --check     # every skill has a trigger eval

CI runs the same three checks. Every new skill ships with at least one trigger-accuracy case in evals/cases.jsonl — a realistic request labelled with the skill that should activate, plus a trap_for case where it sits near an existing skill, so routing stays correct as the collection grows. Two repo-local skills, authoring-security-skills and verifying-skill-accuracy, encode the standard and the fact-checking method. Contributions must serve authorized security work; no working malware, implants, or evasion tooling.

For authorized use only. Penetration testing with written permission, in-scope bug bounty work, research on systems you control, education and CTFs, and defensive operations.

Not for unauthorized access, illegal activity, or violating terms of service. You are responsible for obtaining authorization and complying with applicable law. Provided as-is, without warranty; the authors accept no liability for misuse.

MIT — see LICENSE.

Worth knowing about, and in several cases worth installing alongside this:

• trailofbits/skills — deep code-audit workflows, Semgrep/CodeQL rule authoring, verification, and secure contracts
• anthropics/claude-plugins-official — the security-guidance and claude-security plugins
• OWASP ASVS, MITRE ATT&CK, Sigma, Atomic Red Team