New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

remindb Fuzz Target Author

by radimsem in radimsem/remindb

Adds a new Go fuzz target to remindb following its seed-corpus discipline: one target per logical surface, discovered automatically by its FuzzXxx function name.

MITAuto-check passedTesting & QA

Install remindb Fuzz Target Author

skills CLI
$ npx skills add radimsem/remindb --skill add-fuzz-target -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install radimsem/remindb add-fuzz-target --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/radimsem/remindb.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/add-fuzz-target .claude/skills/add-fuzz-target && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
add-fuzz-target
GitHub stars
129
Token cost
~1.7k tokens
SKILL.md length
682 words
Files
1
Skills in repo
11
Repo updated
First seen
Licence
MIT

At a glance

Adds a new Go fuzz target to remindb following its seed-corpus discipline: one target per logical surface, discovered automatically by its FuzzXxx function name.

  • Adding a new Go fuzz target to one of remindb's parsing or compiling packages
  • SKILL.md covers Where it lands, The function shape, Seed selection — the discipline and Invariant assertions, plus 4 more sections
  • Calls go
  • Extending an existing fuzz target's seed corpus with a missing input shape

What it does

The skill covers adding a FuzzXxx(f *testing.F) function to remindb's parser, query, transformer, compiler or temperature code. A project script auto-discovers any function matching the Fuzz prefix through go test -list, so naming is the only registration step, and a new target is appended to an existing fuzz_test.go file in its package rather than creating a second file when one already exists for that package. It warns against multiplexing two unrelated functions into one target, since Go's fuzzer mutates the whole input tuple as a unit and combining surfaces dilutes coverage.

Its seed-selection discipline treats each seed as a shape worth starting the mutator from rather than an attempt to enumerate valid inputs, and lists the shapes worth covering: a happy-path baseline, an empty input for bounds checks, a malformed input for the decoder's error path, a UTF-8 boundary case for multi-byte slicing, a structurally extreme case like deep nesting, and numeric extremes such as infinity, NaN or a value exactly at a parameterized limit.

When your agent uses it

  • Adding a new Go fuzz target to one of remindb's parsing or compiling packages
  • Extending an existing fuzz target's seed corpus with a missing input shape
  • Hardening a function against malformed or boundary-value input

Example prompts

  • “Add a fuzz target for the new query parser function in pkg/query.”
  • “Extend the compiler fuzz target's seeds to cover a deeply nested structural case.”
  • “Add seeds covering empty and malformed input to the transformer fuzz target.”

Requirements

  • Go with its built-in fuzzing support

What it can do on your machine

Read from SKILL.md and the folder at commit 977b31c. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • go

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

remindb Fuzz Target Author loads about 1.7k tokens when it runs. Until then it costs about 87 tokens; SKILL.md has 682 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~87
When it runs · the whole SKILL.md, loaded when a task matches
~1.7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from radimsem/remindb at commit 977b31c, republished under its MIT licence (© radimsem). 682 words, ~1,712 tokens.

Download SKILL.mdSave it as .claude/skills/add-fuzz-target/SKILL.md (or your agent's skills folder).
name
add-fuzz-target
description
Use when adding a new `Fuzz*` function in remindb — symptoms include "fuzz this function", "find panics in X", "add property-based testing", "harden against malformed input", or any task that creates a `FuzzXxx(f *testing.F)` in a `*_test.go`. Also use when extending an existing fuzz target's seed corpus with new shape coverage.

Add a fuzz target

remindb fuzzes parser, query, transformer, compiler, and temperature code. The fuzz harness is whatever Go's testing.F gives you — there's no project-specific framework — but the seed-corpus discipline is project convention worth getting right. scripts/fuzz.sh auto-discovers any Fuzz* function via go test -list='^Fuzz', so naming your function FuzzXxx is the only registration needed.

Where it lands

Two files at most.

FileWhat changes
pkg/<package>/fuzz_test.goNew file or extend existing — FuzzXxx(f *testing.F)
pkg/<package>/testdata/fuzz/<FuzzXxx>/Auto-managed by Go fuzz; commit any minimization corpus crashes find here

If pkg/<package>/fuzz_test.go already exists (it does for parser, query, transformer, compiler, temperature), append; don't make a second file.

The function shape

Mirror pkg/parser/fuzz_test.go and pkg/temperature/fuzz_test.go. The shape is uniform:

go
func FuzzExample(f *testing.F) {
    // Seed corpus — see "Seed selection" below.
    f.Add(input1, input2)
    // ... more f.Add lines, each one shape ...

    f.Fuzz(func(t *testing.T, input1 T1, input2 T2) {
        result, err := YourFunc(input1, input2)

        // Invariants — see "Invariant assertions" below.
        if err != nil {
            return        // errors are fine; panics are not
        }
        if !invariantHolds(result) {
            t.Errorf("invariant violated: ...")
        }
    })
}

Two rules:

  • Function name FuzzXxx. scripts/fuzz.sh greps for ^Fuzz in go test -list output. Anything else is invisible.
  • One target per logical surface. Don't multiplex two unrelated functions into one fuzz target — Go's fuzzer mutates the input tuple as a unit, so combined targets dilute coverage.

Seed selection — the discipline

A fuzz seed says "this is a shape worth starting from." The fuzzer mutates from there. The point isn't to enumerate all valid inputs; it's to give the mutator a head start on every category of structural variation. Aim for one seed per shape:

ShapeWhy it mattersExample
Happy pathBaseline — proves the harness wires up correctlyf.Add("doc.md", []byte("# Hello"))
Empty inputOff-by-one and bounds-check guardf.Add("file.md", []byte{})
MalformedDecoder error pathf.Add("file.json", []byte("{unclosed"))
UTF-8 boundaryMid-byte slicing, multi-byte boundaryf.Add("file.md", []byte{0xe3})
Structural extremeDeep nesting, large countsf.Add("file.json", []byte("{\"a\":{\"b\":{\"c\":\"deep\"}}}"))
Numeric extreme (numeric inputs)Inf, NaN, MaxFloat, MaxInt, negativef.Add(math.MaxFloat64, 1.0)
Boundary value (parameterized)The threshold/cap/limit value itselff.Add(1, math.MaxInt) (budget exactly at limit)

pkg/temperature/fuzz_test.go is the cleanest template for numeric fuzz; pkg/parser/fuzz_test.go is the template for byte-sequence fuzz. Both spend ~10 seed lines each — that's the right density.

Invariant assertions

The default invariant is must not panic. The runtime catches panics and reports them as crashes, so you don't write that one — it's free.

Beyond no-panic, write property assertions, not example-based ones. The mutator generates novel inputs you can't predict:

  • Type-level invariants: len(out) <= len(in), result >= 0, tokensUsed <= budget.
  • Round-trip invariants: Decode(Encode(x)) == x.
  • Conditional invariants: "if input is valid UTF-8, error must be nil". pkg/parser/fuzz_test.go does this for ErrInvalidUTF8.
  • Domain invariants: "result is non-NaN when both inputs are non-NaN" (see FuzzDecayFactor and FuzzScore in pkg/temperature/fuzz_test.go).

A common pattern: when an input could be invalid, gate the assertion on input validity:

go
if budget >= 0 && tok1 >= 0 && tok2 >= 0 {
    if result.TokensUsed > budget {
        t.Errorf("TokensUsed = %d exceeds budget %d", result.TokensUsed, budget)
    }
}

This avoids spurious failures from negative-int inputs you've already documented as out-of-domain.

Show full SKILL.md (265 more words)Show less

Running it locally

bash
# Run all fuzz targets for 30 seconds each
scripts/fuzz.sh 30s

# Or one target for longer
go test -run='^$' -fuzz='^FuzzExample$' -fuzztime=2m ./pkg/<package>/

A new target should run for at least 30s without crashing before you commit. If a crash surfaces, the crashing seed is saved under pkg/<package>/testdata/fuzz/FuzzExample/<hash> — commit that file along with the fix so future runs replay the regression.

Quick reference

1. pkg/<package>/fuzz_test.go    (FuzzXxx with seed corpus + Fuzz callback)
2. scripts/fuzz.sh 30s            (must finish without crashes)
3. If a crash file appears in testdata/fuzz/: fix root cause, commit the seed

Common mistakes

  • Asserting on a specific output value. The fuzzer's input is unpredictable; specific outputs can't hold. Use property assertions: bounds, types, conditional invariants.
  • Returning early on err != nil without checking what kind of error. If the function should return a specific sentinel for a given input class (like ErrInvalidUTF8 for invalid UTF-8 in parser), assert that. Otherwise generic return on error is correct.
  • Missing the f.Add(...) seed for the empty/zero case. The Go fuzzer mutates from seeds — without an empty seed, it may take a long time to discover the empty input naturally.
  • Long-running invariant checks inside the fuzz body. Each iteration runs thousands of times per second; an O(n²) assertion will throttle the fuzzer and reduce coverage. Keep invariant checks O(n) or O(1).
  • Not committing crash seeds from testdata/fuzz/. The seed file is the regression test for the bug you just fixed. Without it, the same bug can re-emerge silently.
  • Naming the function FuzzTestXxx or FuzzCheck. scripts/fuzz.sh greps ^Fuzz so any prefix-only-Fuzz name works, but stylistic convention here is FuzzXxx matching the function-under-test.

Cross-references

  • .claude/rules/go-concise.md — error sentinel patterns, naming
  • .claude/skills/add-parser/SKILL.md — for the special case of seeding FuzzParseBytes with a new format (you don't add a new fuzz target, you extend an existing one)
  • scripts/fuzz.sh — the auto-discovery loop; read it once if you're curious how go test -list='^Fuzz' finds your target

© radimsem, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/add-fuzz-target of radimsem/remindb.

Open the folder on GitHubat commit 977b31c

Compare with similar skills

remindb Fuzz Target Author next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

remindb Fuzz Target Author compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
remindb Fuzz Target Author this skillradimsem/remindb129—~1.7kAutomated safety check: PassMIT
Golang Testingantoniopaya22/go-rest-template1729 repos~4.2kAutomated safety check: PassNone
Golang Testingunxed/f42411 repos~4.5kAutomated safety check: PassMIT
Golang Testingaffaan-m/ECC276k1 repos~4.3kAutomated safety check: PassMIT
Golang Testingcontext-labs/whip1.1k—~4.4kAutomated safety check: PassMIT
Golang Testingaffaan-m/ECC276k—~4.3kAutomated safety check: PassMIT

Similar skills

  • Golang Testing

    antoniopaya22/go-rest-template

    Go testing patterns including table-driven tests, subtests, benchmarks, fuzzing, and test coverage.

    172 GitHub starsUsed in 9 repos~4.2k tokens
    Testing & QAAuto-check passed

  • Golang Testing

    unxed/f4

    Production-ready Golang tests — table-driven tests, testify suites and mocks, parallel tests, fuzzing, fixtures, goroutine leak detection with goleak, snapshot testing, code coverage, integration…

    241 GitHub starsUsed in 1 repo~4.5k tokens
    Testing & QAAuto-check passed

  • Golang Testing

    affaan-m/ECC

    Table-driven testler, subtestler, benchmark'lar, fuzzing ve test coverage içeren Go test desenleri.

    276k GitHub starsUsed in 1 repo~4.3k tokens
    Testing & QAAuto-check passed

  • Golang Testing

    context-labs/whip

    Production-ready Golang tests — table-driven, testify suites/mocks, parallel tests, fuzzing, fixtures, goleak leak detection, snapshots, coverage, integration tests.

    1.1k GitHub stars~4.4k tokensUpdated 4 days ago
    Testing & QAAuto-check passed

  • Golang Testing

    affaan-m/ECC

    Patrones de pruebas Go incluyendo pruebas basadas en tablas, subpruebas, benchmarks, fuzzing y cobertura de código.

    276k GitHub stars~4.3k tokensUpdated 4 days ago
    Testing & QAAuto-check passed

  • Go Helper

    shepherdjerred/monorepo

    Current Go development guidance for modules, toolchains, workspaces, testing, fuzzing, concurrency, profiling, security, and Go tooling.

    112 GitHub stars~1.7k tokensUpdated today
    SecurityAuto-check passed

More from radimsem/remindb

All 11 skills in this repo

  • remindb Memory Writer

    radimsem/remindb

    Guides an agent writing to a remindb memory server: structured notes go in as files parsed into a node tree, single text facts go in through MemoryWrite.

    129 GitHub stars~2k tokensUpdated 2 mo ago
    Auto-check passed

  • remindb Read Path

    radimsem/remindb

    Covers the read-side tools of the remindb MCP server, a SQLite-backed agent memory, for orienting, searching, resyncing and tracing relations.

    129 GitHub stars~2.7k tokensUpdated 2 mo ago
    Auto-check passed

  • Add a remindb Bench Scenario

    radimsem/remindb

    Adds a new row to remindb's token-savings benchmark table by writing a scenario function that measures the naive shell-tool token cost against the remindb tool-call cost for the same task.

    129 GitHub stars~1.7k tokensUpdated 2 mo ago
    Auto-check passed

  • remindb Integration Tests

    radimsem/remindb

    Explains how to add an end-to-end test scenario to remindb, choosing between a direct API test and an MCP test and using the shared helpers and fixtures.

    129 GitHub stars~1.8k tokensUpdated 2 mo ago
    Auto-check passed

  • Add an MCP Tool to remindb

    radimsem/remindb

    Checklist for adding a new Memory-prefixed tool to remindb's Go MCP server: tool file, registration, test, skill docs, plus the locking and logging rules.

    129 GitHub stars~2.1k tokensUpdated 2 mo ago
    Auto-check passed

  • Add a remindb Parser

    radimsem/remindb

    Walks through adding a new file format to remindb's Go parser package: the parser file, the ParseBytes case, table tests and fuzz seeds.

    129 GitHub stars~1.6k tokensUpdated 2 mo ago
    Auto-check passed

Works with

Categories

Questions about remindb Fuzz Target Author

What does remindb Fuzz Target Author do?

Adds a new Go fuzz target to remindb following its seed-corpus discipline: one target per logical surface, discovered automatically by its FuzzXxx function name. F) function to remindb's parser, query, transformer, compiler or temperature code.go file in its package rather than creating a second file when one already exists for that package.

When should I use remindb Fuzz Target Author?

remindb Fuzz Target Author fits situations like: adding a new Go fuzz target to one of remindb's parsing or compiling packages; extending an existing fuzz target's seed corpus with a missing input shape; hardening a function against malformed or boundary-value input.

How do I install remindb Fuzz Target Author in Claude Code?

Run `npx skills add radimsem/remindb --skill add-fuzz-target -a claude-code`. Or copy the skill folder (.claude/skills/add-fuzz-target in radimsem/remindb) into .claude/skills/add-fuzz-target in your project. Claude Code loads it when a task matches its description.

How do I install remindb Fuzz Target Author in Codex?

Run `npx skills add radimsem/remindb --skill add-fuzz-target -a codex`. Or copy the skill folder (.claude/skills/add-fuzz-target in radimsem/remindb) into .agents/skills/add-fuzz-target in your project. Codex loads it when a task matches its description.

Can I use remindb Fuzz Target Author in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add radimsem/remindb --skill add-fuzz-target -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/add-fuzz-target, .gemini/skills/add-fuzz-target, .github/skills/add-fuzz-target and .opencode/skills/add-fuzz-target in your project.

What does remindb Fuzz Target Author need to run?

Going by SKILL.md and its folder, remindb Fuzz Target Author needs the command-line tools its instructions call (go). Our summary lists: Go with its built-in fuzzing support.

Does remindb Fuzz Target Author access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is remindb Fuzz Target Author safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does remindb Fuzz Target Author use?

remindb Fuzz Target Author is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does remindb Fuzz Target Author use?

About 1.7k tokens (SKILL.md is roughly 6.8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to remindb Fuzz Target Author?

Skills that share tags, products or a category with remindb Fuzz Target Author: Golang Testing (antoniopaya22/go-rest-template, 172 stars), Golang Testing (unxed/f4, 241 stars), Golang Testing (affaan-m/ECC, 276k stars) and Golang Testing (context-labs/whip, 1.1k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains remindb Fuzz Target Author?

radimsem (a GitHub user) maintains it in radimsem/remindb, which has 129 GitHub stars. The repository holds 11 skills in this directory. The repository was last updated on August 3, 2026.

Source: radimsem/remindb on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.