customize
Skill25 starsChanged 4 months agoApache-2.0View on GitHub
Adapt this profile-based vulnerability pipeline to a different vulnerability class, target shape, language, or detection mechanism. It ships a first-class `rust` profile plus a retained C/C++ + ASan base, resolved via a target's `profile:` field. Use when the user wants to port, migrate, retarget, customize, or fork the pipeline for a new domain — web apps, smart contracts, deserialization, ML systems, or another language. Adapting usually means ADDING a profile, not rewriting the base.
43 other projects use a version of this, 1 of them edited.
Adopted by
Most recently taken up by
- seancabalse/agentic-playbooktheir own version, first seen Nov 16, 2026
- bouob/claude-statuslinetheir own version, first seen Nov 15, 2026
- shivasaini04/nanocrewtheir own version, first seen Nov 15, 2026
- nanocoai/nanoclawtheir own version, first seen Nov 15, 2026
- HughYau/AcademicForgetheir own version, first seen Nov 8, 2026
- microsoft/frontier-ai-governance-rvastheir own version, first seen Oct 25, 2026
Used with
Projects with it also use add-atomic-chat-tool, add-dashboard and 10 more.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
MicrosoftSkilladd-atomic-chat-tool
Add Atomic Chat MCP server so the container agent can call local models served by the Atomic Chat desktop app via its OpenAI-compatible API.
Also in 8 projects that use this
MicrosoftSkilladd-dashboard
Add a monitoring dashboard to NanoClaw. Installs @nanoco/nanoclaw-dashboard and a pusher that sends periodic JSON snapshots.
Also in 8 projects that use this
- +10 more from microsoft
Other versions43 projects use a version of this.
Word for word · 0
None found.
Edited · 1
- anthropics/defending-code-reference-harness★ 7.5k88% same
Wrote their own version · 42
- gavrielc/nanoclaw★ 31ksame name
- nanocoai/nanoclaw★ 31ksame name
- qwibitai/nanoclaw★ 31ksame name
- anthropics/claude-for-legal★ 9.5ksame name
- microsoft/agent-skills★ 3.2ksame name
- microsoft/skills★ 3.2ksame name
- HughYau/AcademicForge★ 2.6ksame name
- microsoft/azure-skills★ 1.6ksame name
- xuzhougeng/wisp-science★ 1.1ksame name
- Runchuan-BU/BioClaw★ 405same name
32 more not listed
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository21 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- patchSkill
- quickstartSkill
- sast-drivenSkill
- sast-prioritiseSkill
- threat-modelSkill
- triageSkill
- variant-scanSkill
- verifySkill
- vuln-scanSkill
- customizeSkill
- patchSkill
- quickstartSkill
- sast-drivenSkill
- sast-prioritiseSkill
- threat-modelSkill
- triageSkill
- variant-scanSkill
- verifySkill
- vuln-scanSkill
The file
We split this skill into the rules it gives an agent
9 rules. 0 are common, 4 are distinctive, and 5 are very specific to this project.
0
Common
Most of the 40 edited versions we read keep these.
4
Distinctive
This author's own choices. Worth a look.
5
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 34
Use AskUserQuestion to gather requirements.
- Distinctive: line 64
Keep going until you can fill in every row of the architecture map in STEP 3.
- Distinctive: line 115
Before editing anything, summarize back to the user:
- Distinctive: line 122
Wait for explicit approval.
- Very specific: line 132
Add a canary target under targets/<domain>-canary/ with 2–3 planted bugs of the new class
- Very specific: line 133
Run: bin/vp-sandboxed run <domain>-canary --model <model-id> --runs 3 --parallel --stream --max-turns 50 (use Claude Opus unless the user …
- Very specific: line 137
Run vuln-pipeline dedup results/<domain>-canary/ and confirm signatures group correctly
- Very specific: line 138
If the profile has a find→fuzz bridge, run vuln-pipeline reattack results/<domain>-canary/<ts>/ and confirm static findings promote into …
- Very specific: line 139
Run vuln-pipeline scorecard results/<domain>-canary/<ts>/ and confirm the discipline gate passes — no clean result without a recorded …
“Common” is measured: kept by at least 6 in 10 of the 40 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Customize the vuln-pipeline
This pipeline is profile-based: a target's profile: field (resolved by harness/profiles.py) selects the language-specific prompts and detector. Three profiles ship today — a first-class rust profile (harness/rust/ + profiles/rust/), the retained C/C++ + AddressSanitizer base (harness/prompts/), and android-app (harness/android_app/ + profiles/android-app/), an application-security profile over decompiled DEX whose oracle is a reachability witness, not a crash — the worked reference for porting to a domain where bugs don't crash (see docs/profiles/android/DECISIONS.md and the general method in docs/extending.md). Its real shape is more general: an agent crafts an input, runs a target in a sandbox, a detector fires, a second agent verifies, a third agent analyses exploitability. Every noun in that sentence can be swapped. Your job is to interview the user, figure out which nouns they want to swap, and — usually — add a new profile rather than rewrite an existing one.
The rust profile is the worked reference for "how a second profile is added": harness/rust/ holds its find/grade/judge/report/patch prompts and detector, profiles/rust/ holds its scan-extras, fp-rules, and capability inventory, and harness/profiles.py registers it as a Profile entry alongside cpp. Read that pair before adapting — it shows exactly which files a profile owns and how the registry wires them in. You don't need a playbook for each domain; understand what's generic vs. profile-specific, and follow the rust pattern.
STEP 1 — Read the pipeline (do this BEFORE asking anything)
Skim these files so your questions are grounded:
README.md— pipeline overview (recon → find → grade → judge → report)harness/cli.py— orchestration; shows how stages wire together and what lands on diskharness/find.py,harness/grade.py,harness/report.py— the three container-agent loops; mostly generic plumbingharness/prompts/find_prompt.py,harness/prompts/grade_prompt.py— the C/C++-specific parts; bug taxonomy, quality tiers, grading rubricharness/prompts/report_prompt.py,harness/prompts/report_grader_prompt.py— also C/C++-specific; exploitability sections (primitive, heap layout, escalation path) and the rubric that scores themharness/prompts/judge_prompt.py— triage prompt; keys on ASAN excerpts and memory-safety crash classesharness/prompts/system_prompt.py— authorization block; hard-codes "C/C++ target" and "sanitizer output"harness/asan.py— stack-trace parser for dedup/judge signatures; ASAN-specific regexharness/artifacts.py—CrashArtifact,GraderVerdict,JudgeVerdict,ReportVerdictdata contractsharness/config.py,targets/drlibs/config.yaml— target config schemaharness/profiles.py— the extension mechanism: theProfiledataclass, thecpp/rustregistry, andprofile_for()resolution keyed on a target'sprofile:field. Adding a domain is usually adding aProfilehere.harness/rust/+profiles/rust/— the worked second-profile reference: what a profile owns (find/grade/judge/report/patch prompts + detector underharness/rust/; scan-extras, fp-rules, capability inventory underprofiles/rust/) and howcapabilities.json-style routing turns specialized checks on per target. Read this before adding a new profile.targets/README.md— how a target directory is structured (Dockerfile + config.yaml + entry wrapper);targets/rust-canary/is the rust-profile worked example
You don't need agent.py, docker_ops.py, recon.py, judge.py, or novelty.py in detail — they're generic plumbing (judge/novelty domain-specificity lives in the prompts and the asan parser, not the flow).
STEP 2 — Interview the user
Use AskUserQuestion to gather requirements. Start with broad context, then narrow to technical specifics based on what they say.
Round 1 — Context (always ask these first, together)
Two open-ended questions to understand who you're talking to and what they're after. Expect most answers to come via Other as free text — the options are there to prompt thinking, not to constrain.
Question A — Operating context
- header:
Context - question:
What's your operating environment? Who will run this pipeline and why? - options: a few archetypes as inspiration — e.g. "Pentesting firm — client engagements, need reportable findings", "Internal appsec team — scan our own services in CI", "Smart-contract auditor — pre-deployment reviews", "Security researcher — hunting novel bug classes". These tell you what output format, grading rigor, and workflow integration matter.
Question B — Goal
- header:
Goal - question:
Describe in your own words what you want this pipeline to find. What kind of target, what kind of bugs? - options: 2–3 concrete examples (e.g. "Web vulnerabilities like SQLi/XSS in HTTP services", "Reentrancy and access-control bugs in Solidity contracts", "Deserialization RCE in Java microservices").
The context answer calibrates your follow-ups: a pentesting firm probably cares about CVSS scoring and SARIF output; a researcher may want differential testing and novel detection signals; an internal team likely wants CI integration and low false-positive rates.
Round 2 — Technical follow-ups (adaptive — derive from round-1 answers)
Parse their round-1 answers against the axes of variation below. For each axis left ambiguous, ask a targeted follow-up. Batch up to 4 questions per AskUserQuestion call. Common follow-ups:
- Detection signal — "How will the pipeline know it found something?" (crash, exception, canary file appears, DNS callback, differential mismatch, invariant violation)
- PoC shape — "What does a proof-of-concept look like?" (single file, HTTP request sequence, transaction list, test-pipeline code)
- Isolation — "Where does the target run?" (Docker, VM, testnet, remote sandbox, or no execution — static-only)
- Grading criteria — "What makes a finding high-quality vs. low-quality in this domain?"
- Exploitability analysis — "What sections should a report contain?" The C/C++ report has primitive · reachability · heap layout · escalation path · constraints. A web-vuln report might want injection vector · auth bypass · data exposure · chaining potential. Ask what they need, or whether they want the report stage at all.
- Novelty/upstream check — "Should the pipeline check if a finding is already fixed upstream?" The C/C++ version shallow-clones the target's GitHub and checks
git log <commit>..HEAD -- <crash_file>. Only applies if targets have a canonical upstream and a sensible "crashing file" to key on — many domains won't. - Scope — the default is add-alongside via a new profile: the profile system already exists (
harness/profiles.py), and therustprofile is the proven pattern for it, so a new domain becomes anotherProfileentry with the base profiles untouched. Only ask whether they instead want to replace the base outright — that's the unusual case.
Keep going until you can fill in every row of the architecture map in STEP 3. If an answer is vague, ask a narrower follow-up rather than guessing.
Background — axes of variation (context for formulating follow-ups)
These are the dimensions along which customers might want to deviate from the C/C++ demo. Use this list to spot gaps in the user's description and generate follow-up questions — do not present it as a menu.
Vulnerability class: memory safety · Rust-native (unsafe/FFI memory safety, panic-DoS, deserialization-trust, Send/Sync soundness) · web/API (SQLi, XSS, SSRF, XXE, path traversal, IDOR) · deserialization RCE · logic/race (TOCTOU, privilege escalation) · crypto (weak RNG, timing, nonce reuse) · DoS (ReDoS, hash flooding) · smart contracts (reentrancy, access control, front-running) · ML/AI (prompt injection, jailbreaks, data extraction) · protocol parsing
Target shape: CLI binary + file · HTTP service · library via test harness · network daemon · smart contract · browser extension · mobile app
Detection mechanism: crash/abort · uncaught exception · sanitizer hooks (Jazzer/Atheris) · outcome-based (canary file, DNS callback, shell spawn) · differential testing · invariant violation · taint tracking
Input modality: single file · HTTP request chain · multi-file archive · stdin stream · args + env + config combo · transaction sequence
Isolation boundary: Docker container · full VM · remote sandbox · local testnet · none (static analysis)
Dedup signature: (crash_type, top_frame) · (vuln_type, endpoint, param) · (function, state_transition) · (component, precondition)
Report structure: primitive/heap/escalation (memory safety) · vector/auth/exposure (web) · invariant/path/impact (contracts) · or drop the report stage entirely if find+grade is the deliverable
Output format: result.json + poc.bin · SARIF · Nuclei template · prose report
Patch verification signal: ASAN-clean exit · uncaught-exception-free · sanitizer hook silent (Jazzer/Atheris) · canary file untouched · invariant assertion holds · differential output matches reference. This is what _t1_passes() in patch_grade.py encodes — "the bug is gone" for the new domain.
Background — architecture map (what changes vs. what stays)
| File | C/C++-specific? | What it does |
harness/prompts/find_prompt.py | Yes — rewrite | Bug taxonomy, quality tiers, ASAN output format, exit-code examples |
harness/prompts/grade_prompt.py | Yes — rewrite | 5-criterion rubric assumes ASAN traces and Unix signal exit codes |
harness/prompts/report_prompt.py | Yes — rewrite | Exploitability sections: primitive, heap layout, escalation path — memory-safety-specific |
harness/prompts/report_grader_prompt.py | Yes — rewrite | Scores the above sections; rubric is tied to the section set |
harness/prompts/judge_prompt.py | Yes — rewrite | Triage keys on ASAN excerpts and crash-class taxonomy |
harness/prompts/patch_prompt.py | Yes — rewrite | Asks for git diff -- '*.c' '*.h', assumes ASAN trace, memcpy-style root-cause guidance |
harness/prompts/system_prompt.py | Yes — rewrite | Authorization block says "C/C++ target", "sanitizer output" |
harness/asan.py | Yes — rewrite | Regex for #N 0xHEX in func /path:line frames; feeds dedup, judge, novelty |
targets/README.md + Dockerfile template | Yes — rewrite | gcc -fsanitize=address, entry.c wrapper pattern |
harness/patch_grade.py | Light edit | _t1_passes() checks AddressSanitizer: substring; rest of the verification ladder is generic |
harness/report.py | Light edit | _SECTIONS tuple and token lists need to match the new report structure; flow is generic |
harness/novelty.py | Light edit | crash_file_from_frame() is ASAN-specific; git-log logic is generic. Drop entirely if no upstream. |
harness/config.py | Light edit | May need new fields (profile, run_command instead of binary_path); attack_surface likely stays |
harness/artifacts.py | Light edit | crash_type/exit_code semantics may shift; ReportVerdict.section_scores keys must match new sections |
harness/dedup.py | Light edit | Signature function needs the new parser; grouping logic is generic |
harness/prompts/recon_prompt.py | Light edit | Mostly language-agnostic; scrub C idioms |
harness/cli.py | Unchanged | Orchestration is domain-neutral |
harness/agent.py | Unchanged | Agent runner is generic |
harness/docker_ops.py | Unchanged | Container plumbing is generic (may need changes if isolation ≠ Docker) |
harness/find.py, grade.py, recon.py, judge.py, patch.py | Unchanged | Flow is generic; only injected prompts change |
STEP 3 — Present a plan and get confirmation
Before editing anything, summarize back to the user:
- What you understood — restate their goal in one sentence
- What will change — list each file you'll edit with a one-line rationale
- What stays — reassure them the orchestration core is untouched
- Open questions — anything you're still unsure about
Wait for explicit approval. If they adjust the plan, incorporate and re-confirm.
STEP 4 — Execute
Edit the files per the approved plan. Work through them in dependency order: prompts and parser first (they're standalone), then config/artifacts, then the target template, then README. Commit incrementally if the user wants checkpoints.
STEP 5 — Validate
The rust profile's targets/rust-canary/ is the reference validation target — mirror its shape (planted bugs of the new class, a run_detectors.sh oracle, a THREAT_MODEL.md) for the new profile.
- Add a canary target under
targets/<domain>-canary/with 2–3 planted bugs of the new class - Run:
bin/vp-sandboxed run <domain>-canary --model <model-id> --runs 3 --parallel --stream --max-turns 50(use Claude Opus unless the user specifies a different model). Run./scripts/setup_sandbox.shonce first if the sandbox isn't already set up. - Confirm all planted bugs are found and graded PASS
- Confirm judge triage worked:
cat results/<domain>-canary/<ts>/reports/judge_log.jsonl— expect one NEW per distinct bug, DUP_SKIP for repeats - Confirm reports landed:
ls results/<domain>-canary/<ts>/reports/bug_*/report.jsonand spot-check section scores - Run
vuln-pipeline dedup results/<domain>-canary/and confirm signatures group correctly - If the profile has a find→fuzz bridge, run
vuln-pipeline reattack results/<domain>-canary/<ts>/and confirm static findings promote into reproducing harnesses (therustprofile turns them into cargo-fuzz/Miri harnesses) - Run
vuln-pipeline scorecard results/<domain>-canary/<ts>/and confirm the discipline gate passes — no clean result without a recorded residual reason
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

