Skip to content
audiotale.net
Sign in
NewsNews

Go 1.27.3 fuzzing misses slice overruns: Google pairs Gemini 4 Argon with Z3 to find them

A Google post shows Go's fuzzer missing two out-of-bounds bugs until the input's capacity is clipped, and a Gemini plus Z3 pipeline that found all three planted bugs.

audiotale.net team

· 7 min read

Written by AI from the sources linked below. How we use AI

The Go programming language mascot, the Gopher
Photo: Renee French, CC BY 3.0, via Wikimedia Commons
On this page
  1. Key points
  2. What to do
  3. What happened
  4. Background: why slice bugs hide from fuzzers
  5. How the pipeline works
  6. The numbers
  7. Real bugs in skill-lint
  8. What it means
  9. What we don't know yet
  10. What to watch next
  11. Sources

A Google developer-relations post published on 12 November 2026 describes a way to find out-of-bounds slice bugs in Go that the language's built-in fuzzer can miss: ask a language model to translate a function into constraints, and let the Z3 solver search for an input that crashes it. The post's author also found a practical fix for fuzzing itself. In his tests, Go's fuzzer on Go 1.27.3 missed two slice-overrun bugs until the test clipped the input slice's capacity, after which it found both in under a second.

The evidence in the post comes from the author's own test cases, mostly bugs he planted himself, so it shows a technique worth trying, not a proven product. The post does not say whether the tool it describes is publicly available.

Key points

  • Karl Weinmeister, Director of Developer Relations at Google, describes a pipeline in which Google's Gemini 4 Argon model turns compiled Go code into Z3 constraint scripts, and Z3 looks for inputs that trigger a runtime bounds-check panic.
  • On three planted bugs the pipeline found all three; on three correct functions it reported no crash (unsat, which he calls "maybe correct" and not a proof).
  • Unseeded go test -fuzz on Go 1.27.3 missed two slice-overrun bugs in one 3-second run and in three 60-second runs, because about 89% of generated inputs had spare capacity and only 0.07% had capacity equal to length.
  • Clipping capacity with data = data[:len(data):len(data)] fixed that: the fuzzer then crashed both bugs in all three runs, in median times of 0.28 s and 0.17 s.
  • Applied to the author's own tool, skill-lint, the pipeline found three real bugs in five functions.

What to do

You can use the second finding today, without any AI model: if a fuzz target takes a []byte and slices it, make the input's capacity equal to its length before calling your function.

  1. In your fuzz target, shrink the slice's capacity: data = data[:len(data):len(data)]. This is the three-index slice form, which sets the new slice's capacity limit.
  2. Re-run the fuzzer (go test -fuzz=FuzzYourTarget, see the Go fuzzing docs). Bugs that read or write past the end of the data but stay inside the underlying array no longer hide behind spare capacity.
  3. To see which bounds checks the compiler could not remove, build with -gcflags="-d=ssa/check_bce". Each line it prints is a place where a runtime bounds check remains, as the Go 101 guide to bounds-check elimination explains.

What happened

On 12 November Weinmeister published "Catch Go bugs that fuzzing misses with Gemini and a constraint solver" on the Google for Developers blog. He wrote a tool called skill-lint, a standalone Go command-line program that checks SKILL.md files (the instruction files that agent "skills" use) and applies edits suggested by a language model. It was built to keep Google's agent skills programme consistent; the post says that programme had 175 skills at the time.

While testing skill-lint, he built a verification pipeline, and the post describes both the pipeline and the surprise that fuzzing alone could miss bugs in this style of code.

Background: why slice bugs hide from fuzzers

Go checks every slice or array index at run time and panics if it is out of range. The compiler removes checks it can prove are unnecessary, a step known as bounds-check elimination. The Go 101 guide notes that Go has done this since version 1.7 and that you can see what survives by compiling with -gcflags="-d=ssa/check_bce".

Go's native fuzzer arrived in Go 1.18. The Go documentation describes it as coverage-guided: inputs that reach new code are kept and mutated further, and a failing input is minimised and saved to testdata/fuzz so that it runs as a regression test afterwards. That works well when a bug makes the program crash or fail an assertion. It works less well when the bug depends on a hidden property of the input that the engine does not mutate, and the post argues that slice capacity is one such property.

A Go slice has a length and a capacity. Reading beyond the length but within the capacity does not panic: it quietly reads whatever sits in the backing array. If fuzz-generated byte slices almost always have spare capacity, then a function that reads a few bytes too far will not crash, and the fuzzer sees nothing.

How the pipeline works

According to the post, the pipeline has four steps:

  1. Find the candidates. The function is compiled with Go's SSA "prove" pass, which removes the checks it can rule out. What remains are the runtime.panicBounds calls, the possible crash sites.
  2. Show the compiler's work. The author compiles for RISC-V (GOOS=linux GOARCH=riscv64) with -S and the ssa/check_bce/debug=1 flag, and hands both the Go source and the disassembly to Gemini 4 Argon.
  3. Translate to constraints. The model writes a Z3 script. Z3 is an open-source theorem prover from Microsoft Research under the MIT licence, according to its GitHub repository. The post says the model needs about a minute per function, while Z3 itself answers in milliseconds.
  4. Replay the answer. If Z3 returns sat, it produces concrete bytes, and go test replays them against the real function, so every reported crash is reproducible. If it returns unsat, the post reads that as "maybe correct" because the model's translation may be wrong, so it is a lead for further checking, not a proof.

The numbers

The author tested six small parsers, three safe and three with planted bugs:

  • Safe functions: the compiler alone removed every check in a TOML key parser; Z3 returned unsat for an HTTP header scanner and a varint decoder.
  • Planted bugs: the pipeline caught all three. One, ParseTwoChunkFrame, adds two uint8 lengths, so the sum wraps at 256. A 59-byte counterexample (header length 48, body length 236) triggers the panic, and at that input size 19.4% of length pairs crash.
  • Fuzzer, first attempt: unseeded go test -fuzz on Go 1.27.3 missed the overrun bugs in a 3-second run and in three 60-second runs. A third bug, ParseMagicPacket, which involves a signed int8, served as a control, and the fuzzer found it in every run.
  • Why: about 89% of fuzz inputs shared spare capacity, and only 0.07% had capacity equal to length.
Fuzz inputs by slice capacity, Go 1.27.3 test in the Google post% of inputs
Fuzz inputs by slice capacity, Go 1.27.3 test in the Google post (% of inputs)
% of inputs
Spare capacity (shared)89
Capacity equals length0.07

Source: Google for Developers, 12 November 2026

After the capacity fix, the fuzzer crashed both overrun bugs in all three runs, in median times of 0.28 and 0.17 seconds.

Real bugs in skill-lint

The pipeline then ran on five functions in skill-lint itself. Two scanners, including a CRLF line splitter with six surviving bounds checks, returned unsat. Three functions had bugs, according to the post:

  • ApplyReplacementChunks does not reject overlapping chunks, so a later chunk can panic or silently overwrite an earlier edit.
  • The local fixer can panic if a fixer returns a second chunk after a deletion. The author notes that DeleteLineFix returns only one chunk today, so the bug is latent.
  • The prompt packer reserves a flat 100 bytes, so it could exceed the 2 MB context budget when a file path is longer than about 30 bytes.

The post says that with comments stripped from the test files, so the model could not lean on documentation, the pipeline still caught all three. After the author extracted pure helper functions, a 3-second fuzz run caught all three as well, so the cheaper tool does well once code is arranged for it.

What it means

For Go developers, the capacity trick is the most immediately useful result. It costs one line, it applies to any fuzz target that accepts a byte slice, and it reflects a general point: a fuzzer explores only the input properties it can vary.

For teams using AI in testing, the post shows a sensible division of labour. The model does the translation work, which is flexible but fallible, and a solver then checks the result and produces a concrete input that an ordinary test can reproduce. A wrong model output is caught at the replay step. That makes sat answers trustworthy and unsat answers only suggestive, which is how the author frames them.

For the limits, the author is open about scale. The skill-lint binary is 28 MB with 32,321 symbols, and a 10-line parser alone links 1,559 runtime symbols, so he applied the solver only to pure functions and slice helpers. The approach does not detect data races or deadlocks; for those he recommends the race detector, testing/synctest and the goroutine leak profiles in Go 1.27.

What we don't know yet

  • Whether skill-lint or the pipeline is publicly released. The post does not say, and we did not find a release.
  • How it performs on large, real-world code. The tests are small functions, mostly with planted bugs.
  • How much of the result depends on one model. The post uses Gemini 4 Argon; it does not compare other models.
  • How often the model mistranslates. The unsat caveat shows the risk, but the post gives no error rate.
  • Whether the Go team will change the fuzzer to vary capacity itself. We found no statement on that.

What to watch next

Watch for a public release of the tool and for an issue or change in the Go project about fuzzing slices with spare capacity. The post also points to related work on formal verification, including Anthropic's post on Rocq proofs over OSS-Fuzz libraries and the theorem-labs/oss-verify project, which shows the same idea of pairing models with checkers is spreading.

Sources

Written by

audiotale.net team

The official account of the people who run audiotale.net: announcements, conversation starters and the newsroom's drafts. Posts written with AI say so. Every other account here is a real person.