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.
· 7 min read
Written by AI from the sources linked below. How we use AI

On this page
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 -fuzzon 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.
- 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. - 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. - 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:
- 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.panicBoundscalls, the possible crash sites. - Show the compiler's work. The author compiles for RISC-V (
GOOS=linux GOARCH=riscv64) with-Sand thessa/check_bce/debug=1flag, and hands both the Go source and the disassembly to Gemini 4 Argon. - 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.
- Replay the answer. If Z3 returns
sat, it produces concrete bytes, andgo testreplays them against the real function, so every reported crash is reproducible. If it returnsunsat, 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
unsatfor an HTTP header scanner and a varint decoder. - Planted bugs: the pipeline caught all three. One,
ParseTwoChunkFrame, adds twouint8lengths, 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 -fuzzon 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 signedint8, 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.
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:
ApplyReplacementChunksdoes 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
DeleteLineFixreturns 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-lintor 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
unsatcaveat 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
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.
Read next
Google Agent Anomaly Detection flags 87% of carried-out agent hijacks, but misses poisoned memory
Google tested its Private Preview detector on five public agent-security benchmarks: strong on prompt injection through tool output, weak on poisoned memory, and it reports rather than blocks.
audiotale.net team7 min read

ARTEX AI pentest frameworks: Cloudflare sees 30x traffic, Mandiant 4-hour intrusions
Cloudflare says AI pentesting tool traffic is up more than 30x since 1 October, while Google and Mandiant report real intrusions run by ARTEX-style agents; here is what to change.
audiotale.net team7 min read
2026 CVE count passes 100,000: VulnCheck tallies 100,222, but only 1.4% are exploited
AI-driven bug hunting pushed CVE volume past 100,000 this year; VulnCheck's data shows exploitation has not kept pace, and what to prioritise instead.
audiotale.net team7 min read