⏳ This skill is pending AI review.
Scores will appear once the review pipeline completes.
bug-hunting
Bug bounty hunting and penetration testing skills for Claude, Codex, and other agentic AI tools.
Choose how to use this skill
You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.
1. Native installer
This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.
Do not guess an installer command or replace an existing version without reviewing the diff.
2. Complete package recommended
Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.
No complete ProSkills package is published for this listing yet.3. Prompt-only
Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.
Need only the instruction file?
Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.
No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.
// RATINGS
// README
Bug Hunting Skill
Bug bounty hunting & penetration testing skills for Claude, Codex, and any agentic coding tool.
A signal-driven, structured skill package that turns a general-purpose coding agent into a disciplined web/API/mobile/cloud/AI-LLM vulnerability hunter — not by dumping a wall of technique text into context, but by routing to only what's relevant, and by making the agent actually operate like a hunter (working folders, hypothesis tracking, confirm-before-report), not just recite vuln classes.
What this is
Most "hacking skill" packs for AI agents are a single giant file, or dozens of files, each 300–500+ lines, loaded all at once regardless of relevance — heavy on payout tables and named bug-bounty programs, thin on the actual decision logic a hunter needs mid-recon. That's expensive on tokens and worse, it drowns the model in procedure instead of teaching it how to think.
This skill is built the opposite way: a tiny router at the top, six domain-specific signal tables underneath, and 70+ compact technique references that only load when a signal table actually points at them. Nothing loads until it's needed.
What it consists of
bug-hunting/
SKILL.md <- entry point. Routes by target type. ~50 lines.
methodology/
workflow.md <- the operating discipline (see below) — run first
mindset.md <- map-wide / hypothesize-wide / confirm-strict loop
reporting.md <- how to write up a finding that gets paid, not closed
web/ ROUTER.md + references/ (34 vuln classes + 6 framework fingerprints)
api/ ROUTER.md + references/ (GraphQL, gRPC, WebSocket, shadow APIs, ...)
mobile/ ROUTER.md + references/ (Android, iOS, thick-client reversing)
cloud-identity/ ROUTER.md + references/ (cloud/K8s/CI-CD, SAML/Okta/Entra/LDAP/VPN)
ai-llm/ ROUTER.md + references/ (prompt injection, jailbreak, RAG poisoning, agent/tool abuse)
recon/ ROUTER.md + references/ (subdomain enum, OSINT, secrets, source leaks)
79 markdown files total. Every ROUTER.md is a signal table: observable thing about this target → plausible vuln class(es) → one-line confirmation test → which reference file to open for depth. Every references/*.md is a compact, technique-dense distillation — real payloads, real bypasses, real exploit chains — with the payout-table and named-program filler stripped out.
How it's meant to be used
- Point the agent at a target. It loads
SKILL.md(a few hundred tokens), which sends it tomethodology/workflow.mdfirst — not a vuln class. workflow.mdhas it set up a real per-target working folder (scope.md,recon/,hypothesis-log.md,findings/,session-notes.md) before a single request goes out, and gates it from jumping to exploitation before recon is actually marked done.- Based on what the target looks like (web app, API, mobile app, cloud/identity surface, AI/LLM feature),
SKILL.mdroutes to exactly one domainROUTER.md. - The router's signal table points at plausible classes; only the matching
references/*.mdfile loads for depth — not the other 78. - Every hypothesis tried, confirmed, or refuted gets logged, so a long session never re-tests the same thing twice.
- A finding only becomes a report once it clears
methodology/reporting.md's validation bar — reproduced, in scope, evidence captured.
That loop — map wide, hypothesize wide, confirm strict, track everything, report only what's proven — is the actual discipline that separates hunters who find real bugs from people who know the same techniques but don't systematize them. Most skill packs teach the techniques and skip this; this one leads with it.
Who this is for
- Bug bounty hunters and pentesters using Claude Code, Codex, or any agentic tool as a hands-on research assistant on an authorized target.
- Security tool builders who want a structured, signal-driven technique reference to encode into their own scanners, mappers, or exploit modules — the signal tables are designed to be directly translatable into rule-based or LLM-driven attack-mapping logic.
- Anyone learning offensive web/API/mobile/cloud/AI security who wants a reference organized the way a working hunter actually uses one — by observable signal, not alphabetically by CVE.
Compatibility
Not Claude-only. Every file in this skill is plain, self-contained markdown — no Claude API calls, no Anthropic-specific syntax, nothing tool-locked anywhere in the actual content. The one Claude Code–specific piece is SKILL.md's YAML frontmatter (name: / description:), which is a Claude Code auto-discovery convention — it's what lets Claude Code find and load this skill on its own, without being told to.
That means the difference between tools is auto-discovery vs. manual pointing, not compatibility:
- Claude Code — drop
bug-hunting/into your skills directory; the frontmatter makes it auto-discoverable, no manual pointing needed. - Codex, Antigravity, Cursor, or any other agentic coding tool — these don't recognize the
SKILL.mdauto-discovery convention, but that's a discovery mechanism, not a content restriction: just point the agent atbug-hunting/SKILL.mddirectly ("read this and follow it") or hand it the relevant domainROUTER.mdfor the engagement at hand, and it works identically — everything past the frontmatter is ordinary markdown any agent can read and reason over. - A standalone human reference — every file reads fine on its own in a browser or editor, frontmatter and all.
Scope and legal
This skill assumes authorized testing only — an in-scope bug-bounty program you've read the rules for, your own systems, or a lab you control. SKILL.md states this explicitly and every workflow step checks against a written scope.md before acting. Nothing here is a substitute for reading the actual program rules of whatever you're testing.
Status
Built by compressing and restructuring a larger, less organized technique-file collection into this signal-first shape. Reference content is dense but not exhaustive — if you find a gap, extend the matching domain's ROUTER.md and add a references/ file the same way the existing ones are structured (signal table entry → short technique file, no payout tables, no filler).
License
MIT — use it, fork it, adapt it, commercial or not. Just keep the copyright notice.
// HOW IT'S BUILT
// FILES
2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.
SKILL.md4.0 KBupstream ↗
--- name: bug-hunting description: Bug bounty hunting and penetration testing skills for Claude, Codex, and other agentic AI tools. --- # Bug Hunting — Router This is the entry point only. It does not contain technique detail — it decides which domain guide to load, then gets out of the way. Loading this file should never cost more than a few hundred tokens. ## The core discipline Real bug hunting is not "run the checklist for one vuln class." Nobody tells you what bug exists, or if one exists at all. The loop is: 1. **Map the surface completely** — every endpoint, param, auth state, response shape. 2. **Hypothesize widely** — for each input, ask "what could this become?" Don't commit to one guess. A URL-fetching param could be SSRF, or IDOR if that value doubles as a record key — keep both alive until evidence rules one out. 3. **Confirm, don't guess** — a finding is only real once you've proven it (differential response, out-of-band callback, reproduced twice). Report only what you proved. ## Step 0 — the operating workflow (mandatory, before any domain routing) **Before picking a domain, load `methodology/workflow.md` and follow it.** This is not optional technique reference — it's the administrative discipline that separates a systematic hunter from someone with the same knowledge who doesn't organize it: a real per-target working folder (`scope.md`, `recon/`, `hypothesis-log.md`, `findings/`, `session-notes.md`), a hard gate that blocks exploitation until recon is actually marked complete, a running log of every hypothesis tried (so nothing gets re-tested or lost across a long session), and a resume record so a paused engagement doesn't restart from zero. If resuming a target already worked on, `methodology/workflow.md` also tells you to read that target's `session-notes.md` and `hypothesis-log.md` first — before doing anything else. ## Step 1 — identify the target type Read the target's shape (URLs, app type, what you were handed) and pick the matching domain guide. Load **only** that guide's `ROUTER.md` next — not its `references/`, not another domain. | Target looks like | Load | |---|---| | A website, web app, traditional HTTP endpoints | `web/ROUTER.md` | | A documented/undocumented API — REST, GraphQL, gRPC, WebSocket | `api/ROUTER.md` | | An iOS or Android app (APK, IPA, mobile client) | `mobile/ROUTER.md` | | Cloud infra, IAM, SSO/enterprise identity (Okta, Entra, SAML, VPN) | `cloud-identity/ROUTER.md` | | An AI/LLM feature — chatbot, agent, RAG, tool-calling | `ai-llm/ROUTER.md` | | You don't know yet — need to map the attack surface first | `recon/ROUTER.md` | A single engagement often touches more than one — e.g. a web app backed by an API backed by an LLM feature. Load each relevant domain's `ROUTER.md` as you reach that part of the surface; don't front-load all of them. ## Step 2 — inside a domain guide Each domain `ROUTER.md` is a signal table: observable thing about this endpoint → plausible vuln class(es) → how to confirm. It stays small on purpose. Only when it points you at a specific class and you're going deep on that one, pull the matching file from that domain's `references/`. ## Step 3 — always applies, regardless of domain - `methodology/workflow.md` — the working-folder/hypothesis-log/resume discipline from Step 0. Referenced again here because it stays active for the whole engagement, not just at the start. - `methodology/mindset.md` — the hunter's decision loop in more depth (recon-first, hypothesize-wide, confirm-strict), read once, not per-target. - `methodology/reporting.md` — how to write up a confirmed finding so it gets paid, not closed — a finding only moves from the hypothesis log into `findings/` once it clears this bar. ## Scope discipline Only test targets you are explicitly authorized to test — an in-scope bug-bounty program, your own systems, or a lab you control. Read the program's scope and rules before sending a single request. This applies regardless of which domain guide is loaded.README.mdupstream ↗
Contents are not inlined in the catalog. Open the upstream file.
Plain-text copy, no login: /skill-bundles/m4vic-bug-hunting.md