Bug Hunt Agent Skill

Proactively hunt the codebase for bugs of every size — major reliability bugs (connection/network failures, missing timeouts, unhandled…

Context cost
3k tokensestimated from the bundle, loaded when it triggers
Bundle
1 file · 11.8 kBtext throughout, nothing executable
Licence
not declarednone named by its author
Last change
—no release on file
Servers it uses
Noneruns standalone

What it does

Proactively hunt the codebase for bugs of every size — major reliability bugs (connection/network failures, missing timeouts, unhandled disconnects, no retry/reconnect, crashes on the hot path, data corruption, money/precision errors), correctness/logic bugs and edge cases, and tiny issues (small security nits, defensive gaps) noticed in passing. Rank findings by severity, then fix them safely. Invoked as "bug-hunt" for one normal hunt, or "bug-hunt N" (e.g. "bug-hunt 10") for N successive hunt rounds, each sweeping a fresh area and fixing what it finds.

What this skill changes about the agent has not been set out here as a list. Its SKILL.md, shown below, says it in the author’s own words.

securitytesting

The skill itself

A skill is instructions the model reads, so you can see what you are getting: below is the start of its SKILL.md. The front matter loads with every session, the body loads when the skill triggers, and the whole file comes with the install.

SKILL.md11.8 kB · preview
--- name: bug-hunt ---
6# Bug Hunt
7
8Go looking for bugs before they bite — the ones nobody's reported yet. Think like something trying to break the app: what input, what timing, what network hiccup makes it misbehave, crash, or silently produce the wrong result? Hunt across the whole range, from major reliability failures down to tiny defensive gaps, then fix what you find.
9
10This is *discovery* of unknown bugs (vs [[fix]], which fixes one known bug, and [[reverse-engineer]], which goes deep on security specifically). Cast a wide net; verify each catch; fix the real ones.
11
12## How it's invoked — one hunt, N rounds, or until the limit
13
14Read the invocation and pick the mode:
15
16- **bug-hunt (no number)** — do **one** normal hunt: Phases 1–5 once (find, verify, report, fix), then stop. This is the default and matches the plain behavior.
17- **bug-hunt N** (e.g. bug-hunt 10) — do **N successive hunt rounds**. Each round is a full Phase 1–5 pass (hunt → verify → report → fix), and each round targets a **fresh area or category** so you're not re-scanning the same code:
18 - **N COUNTS ROUNDS, NEVER BUGS. This is the one thing not to get wrong.** bug-hunt 10 means *sweep ten different areas*, not *find ten bugs*. The two numbers are unrelated: ten rounds might turn up 25 bugs, or 3, or 0, and all of those are a complete bug-hunt 10. A round is done when you've swept a fresh area, verified, and fixed what was real — **whether that area had five bugs or none.** How many bugs you find never changes how many rounds you owe.
19 - **Finding fewer bugs than N is NOT a reason to stop before N rounds — and the "never invent a bug" rule is NOT a stop condition.** The exact failure this bans, verbatim: *"I found and fixed 6 confirmed bugs; I won't fabricate more to pad to 10, since the skill says never invent bugs — so I'm stopping."* That conflates the two numbers and then hides an early stop behind the anti-fabrication rule. Both halves are wrong: bug-hunt 10 asked for **10 rounds, not 10 bugs**, and "don't invent bugs" governs *what you report inside a round* — it never caps or ends the rounds. The honest move when an area is clean is to **do the next round on a different area**, not to stop. You stop at round 10 because you did ten rounds, never because the bug tally hit some number. If you've done 6 rounds and found 6 bugs, you have **4 rounds left**, full stop.
20 - Rotate the focus every round — e.g. round 1 network/IO, round 2 the hot path, round 3 state & persistence, round 4 money/precision, round 5 edges & concurrency, round 6 error-handling/silent-failure, then a module you haven't swept, then recent changes, etc. Move to a different high-risk zone or a different part of the tree each time.
21 - Number every round in the output: Bug-hunt round 3/10 — state & persistence. Give that round's ranked findings and the fixes applied, then go straight into the next round. Don't stop between rounds to ask permission (the count is the go-ahead).
22 - A round that finds nothing real still counts as a completed round — but first widen the net (a different directory, a deeper trace) before accepting a clean round, since an empty round usually means you looked at already-clean code, not that the project is bug-free. Never invent a bug or "fix" a non-bug just to make a round productive — a clean round is reported honestly as clean (round 7/10 — auth flow: swept, no real bugs found) and you move straight to round 8. A clean round is a *result*, never a reason to stop the sweep.
23 - After **N rounds** (not N bugs), stop and give a short roll-up: how many rounds you ran, the areas each covered, and the total confirmed bugs found and fixed across all rounds by severity. If you stopped before N, the only valid reason is an external one (the user interrupted, or a stacked work-until-limit ceiling / work-until-time clock tripped) — "I ran out of bugs" is never it; run the remaining rounds on fresh areas.
24- **Combined with [[work-until-limit]]** (e.g. work-until-limit 80 + bug-hunt, or bug-hunt work-until-limit 80) — ignore any round count and hunt **continuously until the usage ceiling**, rotating focus areas the same way, round after round. Here bug-hunting is your *primary activity* for that run: when you exhaust bugs in one area, move to the next area (per work-until-limit's rules, running out of one activity is not running out of work — keep hunting other areas, add tests around fragile code, harden error paths). Do not stop at "no more bugs" — switch focus and keep going until work-until-limit's ceiling is what stops you. The ceiling wins over any sense that the hunt is "done".
This is a preview of SKILL.md. Download or install the skill to get the whole thing.
In the file
SKILL.md1,918 words
Files1
Licencenot declared
Why you can read it

Nothing in a skill executes. The client loads the text and the model follows it, so a skill can be audited the way a runbook is — by reading it.

What it costs in context

Skills are not billed by the call. They are paid for in context: every token the instructions occupy is a token your code, your diff and your conversation cannot use. Here is what this one takes and when it takes it.

≈230
always loaded
The name and description, so the model knows the skill exists and when to reach for it.
2,720
on trigger
The instruction body, read only when the skill fires.
1.5%
of a 200k window
Ten skills this size would take about 15% of the window before you open a file.
050k100k150k200k context window

3k tokens, estimated from the bundle at four bytes to the token, held for the rest of the session once it triggers. Middling. Fine to keep on in a project where you use it weekly, worth unloading in one where you never do.

Servers bill, skills cost

A server charges by the month. A skill charges once per session, in context, and then keeps charging it for as long as the session lives.

Before and after

The same question, put to the same model twice: once as it comes, and once with these instructions loaded.

No worked example has been published for this skill yet.

The procedure it runs

The procedure has not been set out here step by step. It is in the body of its SKILL.md: the start of it is shown above, and the whole file comes with the install.

Prose, not code

These steps are written for a model to follow, not executed by a runtime. It can still be told to skip one, and it will say so when it does.

Servers it uses

None. This skill calls no MCP servers at all.

Everything it needs is in the instructions, so it works in a project with nothing connected — the model reads the file and changes how it works with what it can already reach.

Its SKILL.md does not declare which tools it asks the agent for, so what it touches is whatever the instructions themselves ask for — read them before you install it.

What it asks for
Writes filesnot declared
Network accessnot declared

This SKILL.md carries no allowed-tools line, so neither is declared. A skill grants no permissions of its own — it can only ask for tools your client already has.

What it will not do

Every skill is narrow, and the useful ones say where they stop. These are the jobs this one is the wrong tool for.

What this skill is not for has not been published here. Nothing is implied by that: it is a section the author has not filled in.

What is in the bundle

1 file, 11.8 kB on disk. A bundle is text throughout: the instructions the model reads, plus the templates it fills in.

  • SKILL.md11.8 kB
What is not in it

No dependencies and nothing executable: a skill is text the agent reads, so the bundle is 1 file you can review in full before installing.

Install

Installing copies the bundle into your project. Nothing runs at install time — the files sit on disk until the model reads them.

# Bug Hunt · 3k tokens when loaded · macOS, Linux mkdir -p .claude/skills && t=$(mktemp -d) && curl -fsSL -o "$t/bundle.tar.gz" https://mcprush.com/api/skills/bug-hunt/bundle.tar.gz && tar -xzf "$t/bundle.tar.gz" -C "$t" && [ -d "$t/bug-hunt" ] && { [ ! -e .claude/skills/bug-hunt ] || { mv .claude/skills/bug-hunt "$t/.previous" && echo "Previous copy moved to $t/.previous"; }; } && mv "$t/bug-hunt" .claude/skills/ && echo "Installed .claude/skills/bug-hunt"
On Windows, or any OS with Node 20+
npx mcprush@latest skill add nexus-organization-infosec/bug-hunt

Windows PowerShell says 'running scripts is disabled on this system'? Run Set-ExecutionPolicy -Scope CurrentUser RemoteSigned once, or type npx.cmd instead of npx (codex.cmd, gemini.cmd, grok.cmd likewise). PowerShell 7 needs neither. Writes to .claude/skills/bug-hunt/ in the current project. For every project instead, run mkdir -p ~/.claude/skills && t=$(mktemp -d) && curl -fsSL -o "$t/bundle.tar.gz" https://mcprush.com/api/skills/bug-hunt/bundle.tar.gz && tar -xzf "$t/bundle.tar.gz" -C "$t" && [ -d "$t/bug-hunt" ] && { [ ! -e ~/.claude/skills/bug-hunt ] || { mv ~/.claude/skills/bug-hunt "$t/.previous" && echo "Previous copy moved to $t/.previous"; }; } && mv "$t/bug-hunt" ~/.claude/skills/ && echo "Installed ~/.claude/skills/bug-hunt" (macOS, Linux) — or add --global to the npx line. The curl line replaces .claude/skills/bug-hunt/ only after the download succeeds, so files left there by another skill of the same name, or by an older release, do not mix in. A copy already there is moved aside, not deleted, and the line prints where.

Which clients pick it up on their own

A skill is a folder of text. Most of these read a skills folder and pick it up without being told; the rest take the same folder another way — an upload in the app, a parameter on an API call — and then choose it by its description just the same.

Claude Code.claude/skills/
Claude DesktopCustomize › Skills
ChatGPTSkills › Create › Upload
Cursor.cursor/skills/
VS Code.github/skills/
Codex CLI.agents/skills/
Gemini CLI.gemini/skills/
Grok Build.grok/skills/
Microsoft CopilotSkills › Upload a skill
PerplexityComputer › Skills › Upload a skill
DeepSeek Harness.dsh/skills/
Zed.agents/skills/
Devin Desktop.devin/skills/
Windsurf (legacy).windsurf/skills/
OpenAI Agents SDKInstructions or sandbox Skills
HTTP / APIa request parameter
This release
Versionnot versioned
Publishedno release date on file
PriceFree
Referencenexus-organization-infosec/bug-hunt

Versions

Its author publishes no version number, so there is nothing here to pin to: what you install is the folder as it stands today. Instructions change more often than APIs do — a skill can be rewritten entirely without anything it depends on moving.

Pinning

Nothing to pin to: this skill carries no version number of its own. What you install is what the folder holds on the day you install it.

Reviews

—no reviews yet

Nobody has reviewed this skill yet. The rating is the mean of the reviews written here, so there is none until somebody writes the first.

Sign in to review it

A review is tied to an account so it can be answered, edited and taken down by the person who wrote it.

Sign in
Who can post

Anybody with an account, one review each. It carries the version that was current when you wrote it, and the publisher may reply once.

Publisher
Servers0
Claim this skill