Technology

Claude-BugHunter: 83 AI Security Skills That Turn Claude Code Into a Bug Hunter

By Asad Ali ·

21 min read

Claude-BugHunter AI security skills cover graphic — 83 security skills that turn Claude Code into a bug hunter

Claude-BugHunter is a free, open-source bundle of 83 security skills for Claude Code that turns the AI into a guided bug-hunting assistant — it knows the techniques, the payloads, the chain templates and the reporting hygiene, and it stays in scope. It is not an automated scanner: it finds nothing by itself. You describe what you are testing in plain English, the right skill loads, and Claude works through the target with you, step by step.

That distinction is the whole story. The repo — elementalsouls/Claude-BugHunter — passed 7,300 GitHub stars in mid-November 2026, about six months after it was created on 5 May 2026. It is MIT-licensed, it installs in minutes, and it works with Claude Code, OpenCode, Codex CLI, Hermes Agent and Google AntiGravity. What follows is what it actually does, what it cannot do, and the one gate that decides whether you should touch it at all: authorization.

Read this first — the correction that matters. Claude-BugHunter is a skill bundle: plain-text SKILL.md files that teach an AI agent how to hunt bugs. It is not an autonomous scanner, it does not crawl a target and hand you a vulnerability list, and it does not exploit anything on its own. Every finding still needs a human to aim it, validate it and report it. Anyone selling it as "AI that finds bugs for you" is overstating it.

What Claude-BugHunter actually is

Claude-BugHunter is a drop-in skill bundle for the Claude Code skills system. Skills in Claude Code are folders of instructions — a SKILL.md file plus supporting material — that load automatically when the conversation topic matches. Install the bundle once, and Claude Code stops being a general chatbot and starts behaving, in the README's words, "like a senior bug-hunting researcher or red-team operator".

The bundle's own description is precise: "A Claude Code skill bundle for bug hunting and external red-team work — 82 skills, 15 slash commands, 681 disclosed-report patterns curated across 24 core vulnerability classes, plus enterprise identity + infrastructure attack matrices." Note the small discrepancy: the repo description still says 82 skills while the README headline says 83. The README is the current document — it lists 83 skills in its catalog table — so 83 is the number this article uses, and the repo description looks one edit behind.

The numbers, checked against the GitHub API on 17 November 2026: 7,372 stars, 1,145 forks, created 5 May 2026, last pushed 16 November 2026, MIT license, written mostly in Python. The day before, on 16 November, the same API returned 6,512 stars and 975 forks — roughly 860 stars and 170 forks in about 24 hours. That is the signature of a project going viral on GitHub Trending, not slow organic growth. Treat every star count in this article as dated: these are the 17 November figures.

The big correction: skill bundle, not scanner

Most of the social posts about Claude-BugHunter get this wrong, so it is worth spelling out in plain language. An automated scanner — Burp Scanner, Nessus, Nuclei, ZAP — sends requests at a target, compares responses against known signatures, and returns findings with or without a human in the loop. Claude-BugHunter does none of that. It contains no scanner engine, no crawler and no exploit code. What it contains is knowledge: detection patterns, payloads, bypass tables, chain templates and reporting checklists, written as skills that an AI agent reads and follows.

The practical difference is who does the work. With a scanner, the tool does the work and you triage the output. With Claude-BugHunter, you do the work with Claude's help: you pick the target, you describe it, the relevant skill loads, and Claude suggests what to probe, in what order, and how to tell a real finding from a false positive. The README's worked example makes this clear — it shows Claude running subdomain enumeration and ranking the attack surface, then asking "want me to probe the GraphQL introspection + OAuth redirect_uri?" It asks. It does not act alone.

That is a strength, not a weakness, for the people it is built for. A scanner cannot reason about a business-logic flaw, chain three low-severity issues into one real exploit, or write a report a triager will accept. A guided agent can — if the human driving it knows what they are doing. It is also the reason the bundle is useless as a "press button, get bounties" machine: a beginner pointing it at a random site will get a confident-sounding tour of a target they have no right to test, and no valid report at the end of it.

What is inside: 83 skills in four layers

The 83 skills stack in four layers, and the layering is the design. Each layer answers a different question: how to think, where to hunt, how to get past the perimeter, and how to ship a report that gets paid.

CategorySkillsWhat it covers
Hunt — web app vulnerability classes58XSS, SQLi, SSRF, IDOR, LFI, SSTI, XXE, CSRF, CORS, open redirect, SharePoint, ASP.NET/NTLM
Enterprise platform attack10M365/Entra, Okta, cloud IAM, vCenter, enterprise VPN, APK/iOS red-team pipelines, supply-chain recon
Reporting & validation6triage-validation, evidence-hygiene, report-writing, bugcrowd-reporting
Recon & OSINT5web2-recon, offensive-osint, osint-methodology, recon-scope-triage
Methodology & mindset4bb-methodology, bug-bounty, redteam-mindset, bb-local-toolkit

The four layers, in the README's own framing, are Think (bb-methodology plus redteam-mindset: a 5-phase non-linear workflow and a critical-thinking framework), Hunt webapps (the 58 hunt-* skills), Hit the perimeter (enterprise platform chains, including current 2024–2026 CVE chains and post-credential escalation), and Ship it (triage-validation, reporting and evidence-hygiene: the 7-Question Gate, VRT-aware severity, out-of-scope rebuttals, PII redaction and red-team deliverables).

Two details in the credits are worth knowing. First, the bundle is not 83 skills written from scratch: the credits file lists 43 original skills and 8 vendored from upstream, with the rest coming from the community v3 expansion that added 20-plus framework and surface skills. Second, the skills are plain Agent Skills in the standard SKILL.md format — that is exactly why they port to other agent harnesses, covered below.

The 681 disclosed reports behind the hunt skills

The most interesting number in the repo is not 83. It is 681: the number of disclosed HackerOne reports the 58 hunt-* skills are curated from. Each hunt skill carries per-class detection patterns, payloads, bypass tables and chain templates drawn from reports that real researchers wrote and real triagers paid for. Of those 681 patterns, 433 are now individually cited and auditable, according to the README — meaning you can trace a pattern back to the disclosure it came from instead of taking the skill's word for it.

Why that matters: most security checklists are abstract. The OWASP Top 10 tells you injection exists; it does not tell you the three bypasses that worked against a specific WAF in a specific report, or how two low-severity issues chained into a payout. Disclosed reports are the closest thing bug hunting has to case law, and a skill built from them teaches the move, not just the category. That is the bundle's real edge over a generic "ask Claude to find bugs" prompt.

The honest limit is the same as the strength. Disclosed reports skew toward what programs chose to publish — web application classes, well-understood chains, targets that run public programs. The README is upfront that binary exploitation, kernel work and browser internals are a different skill universe and are not covered. And the patterns age: the roadmap lists refreshing the hunt-* skills with newer disclosed reports as open work, which means today's 681 are a snapshot, not a live feed.

How it works: a 6-phase workflow, not a magic button

The bundle drives a 6-phase, non-linear workflow. The README names the chain as recon, then map and rank, then hunt, then validate, then report — with scope enforced in code and a 7-Question Gate before anything is submitted. Non-linear is the operative word: findings in the hunt phase send you back to recon, and validation failures send you back to hunting. It is a loop, not a pipeline.

The BugHunter workflow chainNon-linear — you loop back as findings demand. Scope is enforced throughout.1. Reconsubdomains, OSINT2. Map & rankrank the surface3. Hunt58 hunt skills4. Validate7-Question Gate5. ReportVRT severity7-Question Gate — scope, impact and authorization checked before any report ships

Two ways to drive it. The first is plain English: describe what you are testing and the relevant skill loads automatically — no invocation by name, no memorized command list. The second is the /hunt scaffold plus the cbh CLI, which adds engagement-folder structure, state and orchestration for longer engagements. The README also ships 15 slash commands — /hunt, /recon, /report and others — plus a deterministic engagement engine that maps a target's attack surface and routes each finding to the skill that handles it.

The README's own worked example is illustrative, not a recorded run — it says so in a note underneath — but it shows the shape of a session: you name an in-scope HackerOne target, Claude loads web2-recon, offensive-osint and bb-methodology, enumerates subdomains, filters live hosts, fingerprints the stacks, and ranks the surface with a suggested starting point. Then it asks whether to proceed. That ask-first rhythm is the design: the agent proposes, the human disposes.

Installing it: plugin or copy install

There are two install paths, and the difference matters more than it looks. Option A, the recommended path, installs the bundle as a Claude Code plugin. From inside Claude Code:

/plugin marketplace add elementalsouls/Claude-BugHunter
/plugin install claude-bughunter@elementalsouls

All 83 skills and 15 commands load namespaced under claude-bughunter:, and they update when you bump the plugin version. Nothing is copied into ~/.claude/, which keeps the install clean and the updates automatic.

Option B is the copy install, for machines without the plugin system or for anyone who wants to pin a clone:

git clone https://github.com/elementalsouls/Claude-BugHunter.git
cd Claude-BugHunter
# macOS / Linux
bash scripts/install.sh

# Windows (PowerShell)
pwsh ./scripts/install.ps1

Both the copy install paths copy the skills and commands into ~/.claude/ on macOS and Linux, or %USERPROFILE%\.claude\ on Windows, and wire the hunt engagement scaffolder. The trade-off is simple: the plugin is the fastest path to the skills, but the hunt scaffolder ships with the clone only. The terminal-native cbh runner installs standalone — pipx install git+https://github.com/elementalsouls/Claude-BugHunter — so plugin users can add it without a full clone.

Whichever path you take, the first run is the same: open Claude Code, describe what you are testing in plain English, and the right skill loads automatically. There is nothing to memorize and no skill to invoke by name. If nothing loads, the usual cause is a skills directory the harness is not reading — check the harness table in the next sections before assuming the install failed.

The cbh CLI and the /hunt engagement scaffolder

For short hunts, plain-English prompting plus the slash commands is enough. For longer engagements — a bug-bounty program you are working for days, or a red-team assessment with a scope document and a report deadline — the bundle adds structure. The cbh CLI is the terminal-native runner: it installs standalone via pipx and gives you the engagement tooling without the plugin or the clone. The /hunt scaffolder builds the engagement folder — scope, targets, findings, evidence — so a multi-day hunt does not dissolve into a pile of chat transcripts.

This is also where the deterministic engagement engine earns its keep. Instead of relying on the model's judgement alone to decide what to test next, the engine maps the target's attack surface and routes each finding to the skill that handles it. Deterministic routing plus agentic reasoning is the combination the bundle is selling: the engine keeps the hunt systematic, the skills keep it knowledgeable, and the human keeps it legal.

None of this is required to start. A first-time user should install the plugin, point Claude at a training target like OWASP Juice Shop, and run one hunt end to end before touching the CLI or the scaffolder. The bundle's own README points beginners at exactly those practice targets — DVWA, OWASP Juice Shop, Hacker101 and testphp.vulnweb.com — and that is the right order: learn the workflow where a mistake costs nothing.

One install, five agent harnesses

The skills are plain Agent Skills in the standard SKILL.md format, and that format is now shared across agent tools. One install command puts them everywhere the format is read: Claude Code, OpenCode, OpenAI Codex CLI, Hermes Agent and Google AntiGravity. The install script detects which harnesses are present and copies the skills to each one's skill directory — ~/.claude/skills/ for Claude Code, ~/.agents/skills/ for Codex CLI, ~/.hermes/skills/ for Hermes, ~/.gemini/config/skills/ for AntiGravity — with an --all flag that covers every harness it finds.

There is one asymmetry to know before you switch harnesses: the full knowledge layer ports to all five, but the slash commands and the /hunt engine stay Claude-Code-only by design. If you run OpenCode or Codex CLI, you get the 83 skills and the plain-English triggering; you do not get /hunt, /recon or /report. For most bug hunters that is a minor loss — the skills are the product, the commands are convenience. But if your workflow is built around the scaffolder, Claude Code is the harness to run it on.

The cross-harness support also explains part of the star surge. This is not a Claude-only curiosity; it is a portable knowledge base for anyone running an AI coding agent, and the install-once-run-anywhere story is exactly what gets shared. It is also a quiet bet on the Agent Skills format itself becoming the standard way security knowledge ships — a bet that, judging by the adoption across five harnesses in one README, is paying off.

What Claude-BugHunter cannot do

The README is unusually honest about its limits, and they are worth quoting because they define the tool. Binary exploitation, kernel pwn and browser internals are explicitly out — "different skill universe". Internal Active Directory work is out too: the bundle will not help with domain-takeover chains via Kerberos or lateral movement, and the handoff to internal red-team tooling — Impacket, NetExec, CrackMapExec, Rubeus, Certify, BloodHound — is intentionally outside its scope. Coverage for internal AD and post-exploit "may come in a future update", which is a roadmap line, not a promise.

That makes the bundle an external-surface tool: web applications, APIs, enterprise identity perimeters, cloud IAM, VPN appliances and the public-facing pieces of a target. If your engagement is an internal network assessment, this is the wrong bundle — you would be holding a webapp toolkit at an AD problem.

There are softer limits too. The skills cannot see what you cannot show them: they reason about what Claude can read — responses, headers, code you paste, tool output you feed in. They do not run a scanner, so they will not find the vulnerability that only shows up at request 10,000 of a fuzzing run. They depend on the model's judgement, which means they can be confidently wrong about a finding, a severity, or a scope boundary. And the 681 patterns are a snapshot: the roadmap openly lists refreshing the hunt skills with newer disclosed reports as unfinished work.

The authorization gate: only test what you are allowed to test

Every serious security tool has a line between use and abuse, and Claude-BugHunter draws it in its authorization section. The skills are intended for assets you own or have written authorization to assess: bug-bounty assets that are in scope, penetration-test engagement letters, CTF challenges, and your own infrastructure. That is the whole list. Everything else is out.

The bundle enforces the line rather than just stating it. The triage-validation skill runs a 7-Question Gate that auto-triggers when you point Claude at an unverified third-party target, explicitly asking whether the asset is in scope and whether the finding is on the program's accepted-impact list. The bugcrowd-reporting skill adds researcher-side hygiene — alias handling, account-state restoration, a friendly-tester posture — that signals legitimate authorized testing to a target's fraud team. And the SECURITY.md posture explicitly excludes weaponizing 0-days against unauthorized targets, post-exploitation tooling, malware development and mass-targeting infrastructure.

None of this makes unauthorized testing safe or legal. A gate that asks "is this in scope?" is only as good as the human answering it, and a skill bundle cannot stop someone from lying to it. But the design choice matters: the authors built the guardrails into the workflow instead of burying them in a disclaimer, and for a tool in this category that is the responsible way to ship it. If you are new to bug bounty, the rule is simple and absolute: if you do not own it and no program says you can test it, do not test it.

Anthropic's own guardrails: refusals, model switches, and the Cyber Verification Program

Even authorized work can hit a wall that has nothing to do with this bundle. Anthropic's models apply real-time cyber safeguards that block "vulnerability exploitation or offensive security tooling development" by default — so even an in-scope, authorized hunt can meet a refusal that is not the bundle's doing. The README flags this prominently, and it is the single most common surprise for new users: the skills load, the plan looks right, and then the model refuses a step.

For legitimate dual-use work — penetration testing, bug bounty, red teaming — Anthropic runs a free, application-based Cyber Verification Program (CVP) that adjusts the safeguards for verified practitioners. Two things do not adjust, ever: mass data exfiltration and ransomware development stay prohibited and are not adjustable under the program. The details are in Anthropic's support article on real-time cyber safeguards.

There is a second, subtler behaviour. On Opus 5, a narrow set of higher-risk cyber requests — Anthropic names exploit generation, binary-based vulnerability scanning and penetration testing — fall back to Opus 4.8 rather than being refused. You get a notice and the response is labelled with the model that answered, but in a long agentic run that is easy to scroll past, so it can look like Opus 5 answered when it did not. If your hunt's output quality changes mid-session, check which model actually answered before blaming the skills.

Claude-BugHunter vs an automated scanner

The comparison that clears up the most confusion is a side-by-side. The two tools are complements, not competitors — most serious hunters run both — but they fail in opposite ways, and knowing which failure you are buying matters.

Claude-BugHunterAutomated scanner
What it isSkill bundle: knowledge + workflow for an AI agentEngine: sends requests, matches signatures, reports findings
Finds bugs by itself?No — guides a human-driven huntYes — runs unattended and returns findings
Business-logic flawsYes — reasoning about chains and context is the pointMostly no — needs a signature or a rule
ScaleOne target at a time, carefullyThousands of requests, whole sites at once
Scope enforcement7-Question Gate, built into the workflowConfiguration — easy to mis-scope
CostFree (MIT); you pay for the Claude usageFree to expensive, depending on the tool
Best forLearning the craft, chaining findings, writing reportsCoverage, known-vulnerability sweeps, CI pipelines

The practical takeaway: if you want coverage, run a scanner first. If you want depth — the chained, contextual finding that scanners miss and triagers pay for — run the skills after. And if you want to learn bug hunting rather than just collect findings, the skills teach while the scanner only reports.

Who should install it — and who should skip it

Install it if you are a bug-bounty hunter who already works HackerOne or Bugcrowd programs and wants the disclosed-report patterns at your fingertips instead of in a bookmarks folder. Install it if you are a penetration tester doing external assessments and wants a systematic workflow with reporting hygiene built in. Install it if you are learning security and want to practise on DVWA or OWASP Juice Shop with a guide that explains the technique, not just the payload.

Skip it — for now — if you want an autonomous scanner, because that is not what this is and you will be disappointed on day one. Skip it if you have no authorized target to test: without scope, the bundle is a textbook with no exam. Skip it if your work is internal Active Directory assessment, binary exploitation or kernel research; the README says plainly that those are out of scope. And skip the enterprise platform skills until you have the webapp fundamentals down — the perimeter chains assume you already understand the basics they build on.

One more group should pause: anyone who has not enrolled in Anthropic's Cyber Verification Program and plans to do real offensive-security work in Claude. The refusals will waste your time and teach you the wrong lesson — that the bundle is broken — when the safeguard is the thing in the way. Enroll first, hunt second.

Verdict

Claude-BugHunter is the most useful kind of trending repo: one whose popularity is mostly deserved and whose limits are printed on the box. Eighty-three skills, 681 disclosed-report patterns, a real workflow with a scope gate, and honest documentation about what it cannot do — that is a serious piece of work, and the 860 stars it gained in a single day in November 2026 say the security community agrees.

Its value is not that it finds bugs for you. It is that it makes a capable hunter faster and a learning hunter better, by putting the patterns from 681 paid reports into the agent's hands at the moment they are needed. Its risk is the same as any powerful security knowledge: in the wrong hands, or pointed at the wrong target, it is a liability. The 7-Question Gate helps, but the real gate is the human. Use it on targets you are allowed to test, learn the workflow on Juice Shop first, and let the scanner handle the coverage while the skills handle the thinking.

Related reading: Herdr: tmux built for AI agents · Claude Fable 5.2: Anthropic's new model · uv: the Python package manager · Asad Webs free tools (no bug-hunting or vulnerability-scanning tool exists there yet — the closest are a password generator and a hash generator, neither of which is relevant to this bundle).

Building something that needs to survive contact with real attackers? Asad Webs builds fast, search-ready websites and web apps — talk to us: asadwebs.com/#contact.

Frequently asked questions

What is Claude-BugHunter?

A free, open-source bundle of 83 security skills for Claude Code (and four other agent harnesses) that guides bug hunting and external red-team work. It is built from 681 disclosed HackerOne reports across 24 vulnerability classes, plus enterprise identity and infrastructure attack matrices. It is MIT-licensed and lives at github.com/elementalsouls/Claude-BugHunter.

Does Claude-BugHunter find bugs automatically?

No. It is a skill bundle, not a scanner. It contains knowledge — detection patterns, payloads, bypass tables, chain templates and reporting checklists — that an AI agent follows while you drive the hunt. It sends no requests on its own, runs no crawler, and produces no findings without a human aiming it at an authorized target.

How do I install Claude-BugHunter?

As a Claude Code plugin with /plugin marketplace add elementalsouls/Claude-BugHunter followed by /plugin install claude-bughunter@elementalsouls, or by cloning the repo and running the install script (bash scripts/install.sh on macOS/Linux, pwsh ./scripts/install.ps1 on Windows). The plugin is fastest; the clone also gives you the hunt scaffolder.

Using it on assets you own or have written authorization to test — bug-bounty programs, penetration-test engagements, CTF challenges, your own infrastructure — is legitimate security work. Pointing it at targets you have no authorization for is not, and the bundle's own 7-Question Gate asks you to confirm scope before anything is submitted. The tool does not make unauthorized testing legal.

Why does Claude refuse some BugHunter steps?

Anthropic's models apply real-time cyber safeguards that block vulnerability exploitation and offensive-security tooling development by default, even for authorized work. Legitimate practitioners can apply for the free Cyber Verification Program to have the safeguards adjusted. Mass data exfiltration and ransomware development stay prohibited and are not adjustable.

Does it work with anything besides Claude Code?

Yes. The skills are plain Agent Skills, so they also load in OpenCode, OpenAI Codex CLI, Hermes Agent and Google AntiGravity. The slash commands and the /hunt engagement engine stay Claude-Code-only; on the other harnesses you get the skills and the plain-English triggering without the commands.

Sources

Category: Technology

Tags: technology

About Asad Ali

Asad Ali is a graphics designer with over 20 years of experience — designing since 2003 — and the founder of Asad Webs, based in Pakistan. He builds the free online tools on this site and writes the guides published here.

LinkedIn Facebook Website
KEEP READING

Next guide

Best Webcam and Microphone for Remote Developers in 2026: Look and Sound Like a Pro on Every Call →

Related articles

Join the conversation

No account needed. Comments appear only after approval. Your email address will not be published.

Be the first to share a useful question or thought.

You won’t be subscribed to any mailing list.
WELCOME BACK

Sign in

Access your orders, saved products and account.