cargo-fuzz

cargo-fuzz is a skill for Codex from OutlineDriven/outline-driven-development. It costs 40 tokens per session (1,570 once invoked), scanned A, original, Apache-2.0.

A Rust fuzzing helper for cargo-fuzz, a tool that repeatedly tests code with generated inputs to find crashes and unexpected behavior. It can prepare fuzz targets, run them, measure coverage, and investigate crash artifacts.

In plain words
What is it for?
Use it to initialize or run a fuzz target, measure which code was exercised, apply a sanitizer, and reproduce a selected failure.
Why use it?
It helps expose inputs that break Rust code and provides a way to reproduce and inspect the resulting crashes.

Skill for Codex

Written for Codex: agents/openai.yaml present.

Good fit Use it to initialize or run a fuzz target, measure which code was exercised, apply a sanitizer, and reproduce a selected failure.

Compare 6 skills from other repositories ↓
Install with agentmods
npx agentmods add skills/outlinedriven/outline-driven-development/cargo-fuzz
Install

Getting it into your agent

One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.

Any agent
npx skills add OutlineDriven/outline-driven-development --skill cargo-fuzz
Clone the repo
git clone --depth 1 https://github.com/OutlineDriven/outline-driven-development

Made for: Codex.

Wrote this? Show the measurements

A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.

agentmods badge for cargo-fuzz

README.md
[![agentmods](https://agentmods.dev/badge/skills/outlinedriven/outline-driven-development/cargo-fuzz.svg)](https://agentmods.dev/skills/outlinedriven/outline-driven-development/cargo-fuzz)
Your own site
<a href="https://agentmods.dev/skills/outlinedriven/outline-driven-development/cargo-fuzz"><img src="https://agentmods.dev/badge/skills/outlinedriven/outline-driven-development/cargo-fuzz.svg" alt="Measured on agentmods" height="20"></a>
Per session 40 Skills are progressive disclosure: only the name and description are preloaded; the body loads when the skill is used.
When invoked 1,570 The whole file, excluding the scripts and references it only reads on demand.
Security scan A 0 findings. A grade says what 26 rules found in the file — not that it is safe. Third-party audits
  • NVIDIA SkillSpector pass 7 Sept 2026
How audits are shown
Origin original No closer match found in the catalogue.
Token cost

What it costs to keep this loaded

Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.

ModelPer sessionOnce invoked
Fable 5.1 $0.00040 $0.01570
Opus 5 $0.00020 $0.00785
Sonnet 5 $0.00008 $0.00314
Haiku 4.5 $0.00004 $0.00157

Measured yesterday against content hash 19e34f5b8112, method: parsed. Prices are Anthropic first-party input rates as of 2026-09-07, from the pricing page.

Security

Grade A, and why

cargo-fuzz scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured yesterday.

A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.

Nothing flagged

None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.

Origin

Copies of this mod

1 near-identical copy found in the catalogue:

.devin/skills/cargo-fuzz/SKILL.md · 64 lines

How it starts

The opening of the file, as written. The whole thing — 64 lines — stays where its author put it; the contents beside it link to each section on GitHub.

cargo-fuzz

Contract

Field Bound contract
Trigger User needs to initialize, run, measure, or triage a cargo-fuzz target in a Rust crate.
Authority Reversible local: writes only the fuzz/ workspace, corpus, artifact, and coverage output directories under the target crate, plus src/ edits needed to expose a library target (e.g., moving code from src/main.rs to src/lib.rs) and nightly toolchain and cargo-fuzz installation via rustup and cargo install; rollback is removing fuzz/, reverting src/ edits, and uninstalling the added toolchain or tool. No remote mutation.
Side effect Creates and mutates Rust fuzz targets, corpus files, crash artifacts, coverage reports, and src/ layout on the local filesystem. Installs nightly Rust and cargo-fuzz if absent. No remote, credential, or VCS mutation.
Done The named cargo-fuzz target runs under the intended sanitizer and reproduces any selected artifact.

Inputs

  • Target crate path (required): the Cargo crate to fuzz, containing a library target.
  • Fuzz target name (required for run/coverage/triage; generated by init): the name under fuzz/fuzz_targets/.
  • Sanitizer choice (optional, default address): one of address, thread, memory, none. Use none only for pure safe Rust with no unsafe in the dependency tree.
  • Crash artifact path (optional, for triage): a file under fuzz/artifacts/<target>/.
  • Source filter (optional, for coverage): one or more src/*.rs paths to scope the HTML report, loaded into the SRC_FILTER array.

Procedure

  1. Install the nightly toolchain and cargo-fuzz with rustup install nightly and cargo install cargo-fuzz. Confirm both are installed with cargo +nightly --version and cargo fuzz --version. cargo-fuzz requires nightly because it relies on unstable compiler features and libFuzzer integration. Done when: nightly and cargo-fuzz are installed and confirmed.
  2. Ensure the target crate exposes a library target. If the project is binary-only, move reusable code from src/main.rs into src/lib.rs so the fuzz harness can call it. Done when: the crate exposes a library target.
  3. Initialize the fuzz workspace: cargo fuzz init. This creates fuzz/Cargo.toml and fuzz/fuzz_targets/fuzz_target_1.rs. Done when: the fuzz workspace is initialized.
  4. Write the harness in the generated fuzz target file using the fuzz_target! macro with #![no_main]:
    #![no_main]
    use libfuzzer_sys::fuzz_target;
    
    fuzz_target!(|data: &[u8]| {
        your_project::target_function(data);
    });
    
    Handle Result::Err gracefully inside the harness, and keep the harness deterministic with no RNG. For structure-aware fuzzing, derive Arbitrary on a type in the library crate (#[derive(Debug, Arbitrary)]) and add arbitrary = { version = "1", features = ["derive"] } to the library Cargo.toml. Use that type as the fuzz_target! parameter instead of &[u8]. Done when: the harness is written with deterministic behavior and graceful error handling.
  5. Run the campaign: cargo +nightly fuzz run <target>. AddressSanitizer is enabled by default. To disable it for pure safe Rust, first verify no unsafe code with cargo install cargo-geiger && cargo geiger, then run cargo +nightly fuzz run --sanitizer none <target> for approximately 2x throughput. Done when: the campaign is running or completed under the chosen sanitizer.
  6. Reproduce a crash artifact: cargo +nightly fuzz run <target> fuzz/artifacts/<target>/crash-<hash>. To replay the full corpus without fuzzing: cargo +nightly fuzz run <target> fuzz/corpus/<target> -- -runs=0. Pass libFuzzer options after -- (e.g. -timeout=10, -max_len=1024, -dict=dict.dict). Done when: the artifact is reproduced or the corpus is replayed.
  7. Measure coverage: install rustup toolchain install nightly --component llvm-tools-preview, cargo install cargo-binutils, and cargo install rustfilt. Run cargo +nightly fuzz coverage <target>. Generate the HTML report:
    HOST=$(rustc -vV | sed -n 's|host: ||p')
    cargo +nightly cov -- show -Xdemangler=rustfilt \
      "target/$HOST/coverage/$HOST/release/<target>" \
      -instr-profile="fuzz/coverage/<target>/coverage.profdata" \
      -show-line-counts-or-regions -show-instantiations \
      -format=html -o fuzz_html/ ${SRC_FILTER[@]+"${SRC_FILTER[@]}"}
    
    Leave SRC_FILTER unset when no source filter is supplied. Done when: the HTML coverage report is generated under fuzz_html/.

Read the full file on GitHub · 64 lines

Files

What ships with it

1 file beside SKILL.md in the same directory: the scripts, references and assets a skill reads on demand. Not counted in the per-session cost; read them before you install if any of them is executable.

Changes

What this file has done since we first saw it

Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.

  1. yesterday Changed · -26 tokens per session 19e34f5b8112
  2. 4d ago First seen · 64 lines · 66 tokens per session scan A 25340a4dbf3f

Subscribe to this mod's changes

cargo-fuzz is a skill published in the GitHub repository OutlineDriven/outline-driven-development (52 stars, last pushed 2d ago), licensed Apache-2.0. It adds 40 tokens to every session and 1,570 once invoked, about $0.0002 per session on Opus 5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-09-03.

Related

Other skills, from other repositories

rust-formal-verification

Use when Rust code, especially unsafe or panic-critical paths, needs a Kani, Verus, or Creusot harness written, run, and its failure read. Not for choosing the proof policy: use proof-driven.

OutlineDriven/odin-claude-plugin · 51 tokens

libafl

Use when a LibAFL fuzzer needs an executor, observer, feedback, mutator, scheduler, or objective composed around a target. Not for remote, credential, publish, deploy, or irreversible changes.

OutlineDriven/odin-claude-plugin · 46 tokens

cargo-fuzz

Use when initializing, running, measuring coverage, or triaging a cargo-fuzz target in a Rust crate. Not for remote, credential, publish, deploy, or irreversible changes.

OutlineDriven/odin-claude-plugin · 40 tokens

cargo-fuzz

Sets up and runs cargo-fuzz, the standard fuzzing tool for Cargo-based Rust projects. Covers cargo fuzz init, the nightly toolchain requirement, fuzztarget! harnesses, Arbitrary-derived structured inputs, sanitizer options, cargo fuzz coverage, and reproducing a crash artifact. Use when fuzzing a Rust crate, writing a…

trailofbits/skills · 90 tokens

rust-testing-quality

Use when writing, organizing, or running Rust tests — unit, integration, doc-tests, proptest, criterion benchmarks, or cargo-mutants. Not for CI pipeline wiring (rust-tooling-cicd).

fusengine/agents · 46 tokens

rust-testing

Rust testing conventions and frameworks: built-in #[test], integration, and doctest layout plus the cargo-nextest runner and the proptest, insta, criterion, mockall, and rstest ecosystem. Invoke whenever task involves any interaction with Rust tests — writing, running, configuring, or debugging tests in .rs files and…

xobotyi/cc-foundry · 70 tokens