Independent AI intelligence Two editions daily · ET
Fervor AI

Analysis · November 17, 2026 · repo

elementalsouls/Claude-BugHunterClaude Codeai-skillsagent-securityclaude-codemulti-agent

Claude-BugHunter Turns Claude Code Into a Red-Team Agent. Keep Its Scope in Code.

The top trending repo on GitHub this afternoon loads 83 attack skills into your coding agent. The safe way to use it is the way its own engine already works.

One request to the wrong host can turn a paid bug bounty into an unauthorized attack. Security testers live by scope, the written list of systems they are allowed to touch, and classic scanners enforce it for them: anything off the target list never receives a packet.

AI agents do not work that way by default. An agent skill is a folder of instructions that loads into the agent's context when a topic comes up, and from then on the model decides what to do with it. So when a skill bundle teaches a coding agent how to attack web apps, the boundary moves from a config file into the model's judgment, unless someone moves it back.

That question sits under Claude-BugHunter, which sat at #1 on Trendshift's daily board when I read it on the afternoon of November 17. It is a skill bundle that turns Claude Code into a bug bounty hunter and external red-team operator (a red team is paid to attack an organization the way a real attacker would, with permission). And it has a good answer to the scope question, but only on one of its two paths.

Here is the short version. When you drive it through its engine, a Python allowlist decides which targets an agent is ever sent to. When you drive it in plain English, staying in scope depends on the model remembering to check. Use the engine, and know that even its wall has a gap you should close yourself.

What it is

Claude-BugHunter, by security researcher Sachin Sharma, describes itself as 83 skills and 15 slash commands built from 681 patterns in publicly disclosed bug reports, 433 of them individually cited. The bulk of it is 58 hunt-* skills, one per class of web bug (SSRF, IDOR, OAuth mistakes and so on), each with detection patterns and the steps to confirm a finding. Around those sit skills for recon, for chaining small bugs into bigger ones, for writing reports in the format HackerOne or Bugcrowd expects, and for keeping evidence clean.

The README is upfront about what it leaves out: internal Active Directory attacks, command-and-control frameworks, persistence, and antivirus evasion are all out of scope "by design." It targets the external attack surface, meaning anything reachable from the internet without already being inside.

A few facts for your adoption checklist, as of November 17, 2026:

  • License: split. Code is MIT; the documentation and skill content are CC BY 4.0, which requires attribution if you redistribute the skills.
  • Version: the latest tag is v2.1, from June 5, but main keeps moving; the commit I read landed November 17.
  • Stars: roughly 8.9k on a rounded badge reading.
  • Sponsors: the README carries a sponsor block for two security companies. Not a problem, just worth knowing.
  • Works in: the skills use the standard Agent Skills format, so the install script can copy them into Claude Code, OpenCode, Codex CLI, Hermes Agent and Google AntiGravity. The slash commands and the engine stay Claude Code only.

Two ways to drive it

Plain English. You describe what you are testing, and the right skills load on their own. The README's example: tell Claude Code you are testing an in-scope HackerOne target and ask it to run recon, and it loads the recon skills and starts enumerating hosts.

This is the friendly path, and it is where the scope question bites. The bundle ships a /scope command, which its own docs call a "mandatory pre-flight" check before any request touches a host. But in plain-English mode, "mandatory" means the agent is instructed to run it. Nothing stops a request if the model skips the step. The later safety net, a 7-Question Gate in the triage-validation skill, asks whether a finding's root cause sits in an in-scope asset. That question arrives after testing, when a report is being written, not before the first request.

The engine. The repo also ships a plain Python orchestrator in engine/. You give it a small JSON scope file, and every target passes through scope.py before an agent is dispatched at it. The file's own header says it plainly: the engine "may run unattended, so scope is enforced in CODE, not by trusting an LLM."

That sentence is the design lesson. A rule the model reads is advice. A rule in code is a wall.

The wall has one door, though. Once the engine dispatches a hunt agent, that agent runs Claude Code with permission prompts bypassed and curl allowed, according to engine/agent.py. The list of in-scope hosts reaches the agent as prompt text, and the engine checks the hosts named in its findings afterward. So the code decides which target each agent gets, while what the agent's curl actually touches still rests on instructions plus an after-the-fact audit. The fix is to put a network rule under the agents, which the practice steps below cover.

How the scope check works

The allowlist follows three rules worth memorizing:

  • Default deny. Anything that does not match an in-scope pattern is out.
  • Deny wins. If a host matches both an in-scope and an out-of-scope pattern, it is out.
  • Patterns are matched against the host name. You can list a bare domain, a wildcard, an exact host, an IP range (CIDR) or a regular expression.

One detail will catch people. A bare domain like example.com matches the domain and every subdomain under it. A wildcard like *.example.com matches subdomains but not the bare domain. Bug bounty programs often say "only www and api," so a careless bare-domain entry can put a whole company's subdomains in scope. When a program lists exact hosts, list exact hosts.

The engine's defaults are cautious in other ways too. According to its README, a plain run only maps the target's surface, with no agents and no model spend, then stops and hands you a file listing each endpoint and the skill to try. Automated testing is opt-in with --hunt, and anything that changes state on the target needs a separate --allow-intrusive flag, off by default.

And here is the most honest line in the repo. The engine dispatches its own agents with the bundle's skills switched off by default, because, in the README's words, the maintainers' eval showed "~0 capability gain" while costing about 12,000 to 15,000 tokens per agent. A skill bundle whose own orchestrator mostly runs without the skills is telling you where its value really sits: in the structure, the scope wall and the reporting discipline, more than in the knowledge files.

The refusal you will hit

There is a second reason to be deliberate. The README warns that Anthropic's models apply real-time safeguards that block offensive security work by default, so even authorized, in-scope work can hit a refusal that is not the bundle's doing.

Its advice is clear and worth repeating. If you do authorized testing, apply to Anthropic's Cyber Verification Program to get the safeguards adjusted for legitimate work. In the README's words: "Do not reword an offensive engagement to look defensive to get past a classifier." Read the program's rules first: it is not available on the Free plan, individuals can apply only for the Defense tier while Red Team access is for organizations, client work needs a separate approval, and enrolled users must accept data retention. The README also notes that on Opus 5, some higher-risk cyber requests are answered by an older model instead of being refused, with a label showing which model answered, so a long session can look like it got worse when it switched models.

Put this into practice

If you have written authorization for a target (a bounty program's in-scope list, a signed engagement letter, or your own infrastructure), this is the order I would follow.

1. Install it. The plugin route copies no files into ~/.claude/ and updates when the plugin version changes:

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

If you want the engine, clone the repo instead and check out a specific commit (the one reviewed here is git checkout 5d91c81), so a push to main cannot change your tooling mid-engagement.

2. Dry-run the engine with its own example. The repo ships a mock run that uses canned output and spends nothing:

python3 engine/engine.py --scope engine/engagement.example.json --base /tmp/eng --mock --hunt

The example scope file allows only localhost and 127.0.0.1 and denies admin.localhost. Mock mode uses canned recon output instead of live requests, so nothing touches a real target.

3. Write your real scope file from the program text. Copy exact hosts and ranges, add every exclusion to out_of_scope, and avoid bare domains unless the program really covers all subdomains. Then test a few hosts by hand before anything else runs. The checker works from the command line:

python3 engine/scope.py --scope-file my-engagement.json www.example.com admin.example.com

Per its code, it prints IN-SCOPE or OUT-OF-SCOPE with a reason for each host and exits non-zero if any host is out, so you can see the wall work.

4. Start with the map, not the hunt. Run python3 engine/engine.py --scope my-engagement.json and read the endpoint list it produces. Turn on --hunt only once you know what it will touch, and leave --allow-intrusive off unless your rules of engagement allow state-changing tests (tests that create, modify or delete data on the target).

5. Put a network allowlist under the agents. Before you turn on --hunt, run it inside a container or VM whose only way out is a proxy that allows your in-scope hosts and nothing else. Two pieces make that work: point the agents at the proxy (most tools, curl included, honor the HTTPS_PROXY environment variable), and block all other outbound traffic at the container's firewall so a request straight to an IP address fails instead of slipping around the proxy. Then the agent's curl hits the same wall as everything else. If you write regex scope patterns, anchor them with ^ and $, because the checker uses a search, not a full match.

6. In plain-English sessions, say the frame first. The /hunt command states the engagement context on its first turn for exactly this reason. If you skip the engine, start every session by running /scope on the target yourself, rather than trusting the agent to remember.

7. Apply for CVP before the engagement, not during it. A refusal mid-test is a bad time to discover you needed it.

Honest limitations

Plain-English mode has no hard wall. The skills tell the agent to stay in scope. That is instruction, not enforcement.

The engine's wall stops at dispatch. It picks which target each agent gets. Inside the agent, outbound requests are governed by prompt rules and a later audit unless you add a network allowlist.

The engine is a separate path. Plugin installs get the skills and commands; the hunt scaffolder and full engine come with a clone, and the cbh runner is a separate pipx install.

A scope file is only as good as the person who wrote it. Default deny cannot save a bare-domain entry that was too broad.

Pattern libraries age. 681 disclosed-report patterns are a strong starting point and still a snapshot of what has been reported, not what is exploitable today.

Authorization is on you. The bundle can check a host name against a list. It cannot check that your list matches the paperwork.

Engagement data needs care. The /hunt command keeps client notes in a git-ignored session file per target and says never to write grey-box credentials (test-account logins a client hands you) to disk. That is a good rule to copy into your own setup, and a reminder that whatever the agent reads during a test sits in its context for the rest of the session.

The takeaway

Skill bundles are becoming the way people package expertise for coding agents, and security is where the stakes of that format show first. Claude-BugHunter gets the hard part mostly right in one place: a scope check written in Python decides which targets its agents are sent to, and no prompt can talk past that.

So use that path, and finish the job it starts. Write the scope file, run the map, read it, put a network allowlist under the agents, then decide what they may touch. And if a project ever asks you to trust the model to stay inside the lines, ask where the code that draws those lines lives.

Sources: Claude-BugHunter README, engine/scope.py, engine/README.md, commands/scope.md, engine/agent.py, engine/engagement.example.json and NOTICE, all read at commit 5d91c81 (November 17, 2026; latest tag v2.1); Trendshift daily board, read about 15:20 ET November 17; Anthropic Cyber Verification Program form and help page.