A field guide to bug bounty reports that get triaged and fixed
curl ended its bug bounty in January 2026 and HackerOne saw report volume more than double from February. A section-by-section guide to writing reports a triager can act on: duplicate-proof titles, attack scenarios, reproduction steps a stranger can run, impact you can defend, argued severity vectors, and using AI tools without sending slop.
By The Xalgorix Team
At the end of January 2026, curl stopped paying bug bounties. Daniel Stenberg's commit message was blunt, “we stop the bug-bounty end of Jan 2026”, and The Register reported that one week of submissions had produced seven reports, some describing real bugs and none describing a vulnerability. Stenberg's stated goal was to remove the incentive to send “crap and non-well researched reports to us. AI generated or not.”
curl was an early, loud case of a wider shift. On 2026-05-29 HackerOne described a “significant (100%+) surge in report volume” that began in February as stronger AI models and tools spread. Linus Torvalds, quoted by Help Net Security, called the kernel security list “almost entirely unmanageable, with enormous duplication due to different people finding the same things with the same tools.”
So a report is now read by someone working through a queue that doubled. Finding the bug is still the hard part, but the write-up decides whether a real finding is reproduced in ten minutes or parked as “needs more info”. This guide walks through each part of a report from the reader's side: what a triager does with it, and what each section has to contain to survive that.
What a triager does with your report
Workflows differ by platform and program, but almost every queue asks the same questions in roughly the same order. Each one is a place a report can stall.
In practice nobody reads your report top to bottom for pleasure. The title is used to search for duplicates, the scope check happens before reproduction, and the engineer who finally fixes the bug may never see the triage conversation. Write each section for the person who needs it at that stage.
Write the title as a duplicate search
A triager's first move is often to compare your title with earlier reports on the same asset. “IDOR found!!” matches everything and nothing. A useful title names three things: the asset or feature, the bug class, and the impact. Hacker101 suggests asking how you would describe the vulnerability in 140 characters or less.
Weak: IDOR vulnerability
Weak: Critical security issue in API
Better: IDOR on GET /api/v2/invoices/{id} lets any customer read other tenants' invoicesThe better title also tells the reader what to try first. If it matches an existing report, you learn that quickly instead of after a week.
Put the attack scenario before the steps
Google's Bug Hunters guidance asks for an attack scenario: a short summary of who would exploit the issue, for what gain, and in what way, and it stresses that the goal is not to repeat the reproduction steps. Two or three sentences are enough, and they belong near the top because they frame everything after them.
Attack scenario An authenticated customer of tenant A changes the numeric invoice ID in the invoice download request and receives invoices belonging to tenant B. Each invoice contains the billing contact's name, postal address and the last four digits of the payment card. IDs are sequential, so an attacker can enumerate every invoice on the platform with a single low-privilege account.
Those three sentences state the attacker's starting position (any customer account), the action (change one parameter), the gain (named data fields) and the scale (sequential IDs). Each claim is something the triager can check in the steps that follow.
Reproduction steps a stranger can run
Hacker101 puts the bar well: steps should let someone “without any prior knowledge” reproduce the issue, and the HTTP request should be pasted as text, not as a screenshot. Text can be copied into a proxy; a screenshot has to be retyped, and retyping is where reproductions fail. Bugcrowd's submission guidance splits the description into an overview, a walkthrough and PoC, the evidence, and the demonstrated impact, which is a sensible skeleton on any platform.
A reproduction section that holds up usually has four parts:
- Preconditions. The accounts, roles, plan tier, feature flags and test data the steps assume. If the bug needs two tenants, say how you created them.
- Numbered steps. One action per step, with the exact URL, parameter and value that change.
- Raw request and response. The minimal request that triggers the bug, with secrets and other users' data redacted, and the part of the response that shows it worked.
- Expected versus actual. One line each. It tells the engineer what the correct behaviour is, which is half of the fix.
Here is the illustrative invoice bug written that way (hosts and data are placeholders):
Preconditions - Account A (tenant "acme-test", role: member), created by me - Account B (tenant "globex-test", role: member), created by me - Invoice 48211 belongs to tenant "globex-test" Steps 1. Log in as account A and capture the session cookie. 2. Send the request below with account A's cookie and B's invoice ID. GET /api/v2/invoices/48211/download HTTP/2 Host: app.example.com Cookie: session=<account A session> HTTP/2 200 Content-Type: application/pdf Content-Disposition: attachment; filename="INV-48211-globex-test.pdf" Expected: 403 or 404, because invoice 48211 belongs to another tenant. Actual: 200 with tenant B's invoice PDF (redacted copy attached).
Two habits make this stronger. Use accounts you own on both sides of an access-control bug, so you never touch a real customer's data, and attach a one-line curl command or a short script when the steps involve timing, encoding or many requests. If the bug only shows up through an out-of-band channel, include the callback log and explain what it does and does not show; our out-of-band testing explainer covers why a DNS hit alone means much less than an HTTP request carrying data.
Impact you can defend
HackerOne's core ineligible findings list is worth reading before you write any impact section, because it describes exactly the reports that get closed. Two of its categories are “Theoretical vulnerabilities that do not demonstrate real-world security impact” and “Optional security hardening steps / Missing best practices”, with examples such as clickjacking on pages with no sensitive actions, permissive CORS configurations without demonstrated impact, and open redirects unless you can show additional impact.
The pattern behind that list is simple: the closer your evidence is to the attacker's actual gain, the less the triager has to take on trust. An open redirect on its own is usually ineligible; the same redirect used to leak an OAuth authorization code to a host you control is an account takeover with a demonstrated path. A reflected Origin header is a configuration note; a cross-origin page that reads a logged-in victim's API response is data exposure. Write the impact section about the second version, and only if you have actually shown it.
The same list sets a limit going the other way. Its fourth category covers vulnerabilities that “may require hazardous testing” and says such testing “must never be attempted unless explicitly authorized”. Demonstrated impact means the smallest demonstration that shows the gain: one record from a test account, a file read of a harmless path, a command such as id. It never means dumping a table or pivoting further to make the report look bigger. When you stop short on purpose, say so and explain what you believe the next step would allow. Triagers treat a clearly labelled, reasoned extrapolation very differently from an unlabelled guess.
Argue the severity vector, not the number
Most programs ask for a CVSS vector or map findings to a taxonomy such as Bugcrowd's Vulnerability Rating Taxonomy. A bare “Critical” invites a downgrade; a vector with one sentence per metric invites agreement or a specific correction. For the invoice bug that might read: network attack vector because the API is internet-facing; low privileges because any customer account works; no user interaction; high confidentiality impact because billing contacts and partial card data for every tenant are readable.
Score the bug you demonstrated, in the environment you tested. If an internal-only endpoint becomes reachable only through a second bug, say that in the vector justification rather than scoring both as one. The triager may still adjust the rating, and your base score is only one input to how the program prioritises the fix, but a reasoned vector turns the discussion into a disagreement about one metric instead of about the whole report.
Using AI tools without sending slop
Platforms are not banning AI assistance; they are holding the submitter responsible for it. HackerOne's May 2026 post says it updated its Code of Conduct for AI-assisted research and that “researchers are responsible for the quality of what they submit, regardless of whether a human or a tool generated the first draft.” GitHub's product security team, quoted by Help Net Security, now requires AI-assisted findings to be validated, with a complete submission including “a working proof of concept”.
The reports maintainers describe as slop share a few traits: confident descriptions of functions or code paths that do not exist, impact copied from a generic template, steps that were never run, and length used as a substitute for evidence. Hacker101 already said it plainly: “Length of a report is not something to aim for.” Before you submit anything a model helped write, check these yourself:
- Every file, function, endpoint and parameter the report names exists in the version you tested. Paste the code reference or the request, not a paraphrase.
- You ran the reproduction steps exactly as written, from a clean session, and the response in the report is the one you got.
- The impact section describes what you demonstrated on this target, not what the bug class can do in general.
- A sanitizer-flagged crash, a scanner match or a static-analysis hit has been turned into something an attacker can actually reach, or the report says clearly that it has not.
This applies to autonomous testing tools too, Xalgorix included. In Xalgorix an independent verifier re-tests each finding with a non-destructive exploit attempt before it is reported, because a scanner match is a lead, not a result. That re-run cuts false positives; it does not decide whether a program considers the behaviour in scope, whether the impact matters to that business, or whether someone reported it last month. Those judgements still need a person who has read the policy and the output.
After you press submit
The report keeps working after submission, mostly through how you handle questions. Bugcrowd notes that a submission cannot be edited after it is reported, so corrections go in comments; that is a good habit everywhere, because an edited report can confuse a triager mid-reproduction. Answer the question asked, attach the new request or response rather than describing it, and if a triager cannot reproduce, ask which step failed before re-explaining the whole bug.
When a report is closed as informative or a duplicate, the useful response is a short, specific one: a new piece of evidence that changes the assessment, or nothing. Re-testing a fixed issue, probing beyond scope to strengthen an appeal, or publishing before the program agrees to disclosure all cost more trust than any single bounty is worth.
Ready to see it prove a bug?
Start scanning on Cloud →