aholovko/stave-go-style

STAVE Go style dataset

STAVE Go Style contains 181,879 labelled Go code examples. Each row shows a location in the code, its surrounding context and a label for one of six style criteria. A positive label (true) flags a rule violation or a suggested improvement. An acceptable label (false) means the check found no issue at that location.

Three classes follow exact rules for else after return, error string literals and underscores in declared names. The other three use model-assisted judgements of test failure messages, documentation comments and the clarity of return values.

The dataset has 106,287 training, 35,717 validation and 39,875 held-out test examples. Each repository and its known clones stay in one split.

Load the training split

Install datasets with python -m pip install datasets, then load the training Parquet file.

from datasets import load_dataset

train = load_dataset("aholovko/stave-go-style", data_files="data/train-*.parquet", split="train")

Worked example

In version 1.0.0, train[4609] is a synthetic example made by adding an else to the Max function in dlvhdr/gh-dash. Original source (MIT)

if a > b {
    return a
} else {
    return b
}

The first branch exits Max, so return b can follow the if directly. The unnecessary else makes the P1 label true. The keyword occupies bytes 226 through 229 of the modified file, so the end offset is 230.

row = train[4609]
print(row["id"])
print(row["class"], row["label"], row["label_method"], row["candidate_text"])
print(row["candidate_start"], row["candidate_end"])

P1:v3-mutant-5fd205af7a268a45ee9f0c47c2e067a182e164de560db7da729f9cd8da131a80:0
P1 True rule-based else
226 230

Classes

An example is positive when the condition for its class holds.

Rule-based labels

• P1 (unnecessary else) — an else or else if follows an if block that ends in a direct return.
• P2 (error strings) — the string literal passed to errors.New or fmt.Errorf starts with an uppercase letter followed by a lowercase one (or nothing), or ends with ., :, ! or a line feed.
• P3 (underscores in names) — a nonblank identifier at a declaring position contains _.

Model-assisted labels for advisory criteria

• TF (test failure messages) — a t.Error, t.Errorf, t.Fatal or t.Fatalf call leaves out a fact established by the test that a reader needs to distinguish failures with different diagnoses.
• DC (documentation comments) — an existing documentation comment on an exported struct type or exported method does not start with the declared name, does not read as a sentence, or adds no descriptive information.
• RP (return value clarity) — an exported function or method returns two or more unnamed results of the same type and its name and documentation do not make their meanings and order clear.

Splits and counts

Each class row shows positive / acceptable counts. For each label, every class has at least 500 training, 100 validation and 200 test examples.

Class	Training	Validation	Test
P1	500 / 1,140	100 / 523	200 / 2,049
P2	500 / 5,408	100 / 2,635	215 / 6,805
P3	2,254 / 85,597	357 / 29,822	214 / 26,440
TF	505 / 5,713	104 / 1,078	205 / 1,463
DC	502 / 2,808	104 / 580	228 / 1,490
RP	846 / 514	185 / 129	358 / 208
Total	106,287	35,717	39,875

P3 has the most acceptable examples because it checks every identifier at a declaring position. RP has more positive than acceptable examples in every split. The test split uses targeted sampling and has an uneven mix of classes and labels. These counts reflect how examples were selected and cannot establish how common the issues are in Go code.

What an example contains

• id — unique case ID. IDs for P1, P2 and P3 start with P1:, P2: and P3:, respectively.
• class — one of P1, P2, P3, TF, DC or RP
• label — true for a positive example or false for an acceptable example
• label_method — rule-based for P1, P2 and P3, or model-assisted for TF, DC and RP
• label_model — model identifier for a model-assisted label when recorded, otherwise null
• origin — natural for examples taken directly from source code or synthetic for deliberately modified code
• synthetic_original_id — ID of the original used to create a synthetic example, otherwise null
• repository, commit, path — the GitHub repository, pinned revision and path of the original source file
• source_url — link to that file at the pinned revision
• source_sha256 — SHA-256 of that file's bytes (for a synthetic example, of the mutated file)
• license — SPDX identifier of the source repository's licence (see Licence below)
• split_group — repository group used to assign the split. A repository and its known clones share this value.
• candidate_start, candidate_end — byte offsets in the source file. The start is inclusive and the end is exclusive.
• candidate_text — text at those offsets
• context_runs — contiguous source excerpts selected for the class, each with byte offsets (start, end) and text
• context — the excerpts joined by a newline. Use context_runs to locate gaps in the original file.

The dataset excludes inputs longer than 1,023 tokens for P1–P3 or 512 tokens for TF, DC and RP.

How the labels were made

• For P1, P2 and P3, audited reference procedures apply each class's rule independently of the STAVE analyzer.
• For TF, DC and RP, the reference labels are model judgements. Each model followed fixed instructions for its class. claude-opus-5-5 assessed TF at high effort. claude-fable-5-1 assessed DC and RP at maximum effort. The model identifier returned for each run was checked against the one requested.
• label_model identifies the model for 9,062 TF, 5,341 DC and 1,927 RP examples. The records for the other 690 model-assisted examples omit the identifier, so the field is null.
• Unknown, unsure, invalid, refused and unattempted cases were excluded, never treated as acceptable.

Sources, splits and provenance

The examples come from 1,947 public GitHub repositories. Sources include GitHub searches, an earlier Go corpus and 32 repositories reserved for testing before development.

The training split includes 759 positive examples made by modifying source files. In 382 examples, the change introduced an unnecessary else (P1). In 377, it changed the capitalization of an error string (P2). For these rows, commit and path identify the original file. The byte offsets and source_sha256 refer to the modified file.

The STAVE models were trained on this split.

Known limitations

• Identical short P2 and P3 inputs occur in different splits, even across repository groups. High P3 scores alone cannot show how well a model handles unseen inputs. Some repository clones may also have gone undetected.
• P2 covers only non-test Go files. Just 11 natural P2 training positives meet the trailing-punctuation rule. TF draws on the test files retained during collection, so its coverage is incomplete.
• TF, DC and RP use model-assisted labels. No separate study measured disagreement on these labels.

Licence

Labels, metadata and this documentation are released under CC BY 4.0. Each code excerpt keeps its source repository's licence. The license field gives the licence for each example, and licenses.json lists the evidence for each repository. The repository, commit and path fields identify the original file.

Across all splits, the counts by source licence are MIT (101,975 examples), Apache-2.0 (67,391 examples), BSD-3-Clause (10,875 examples), BSD-2-Clause (1,390 examples), unknown (248 examples).

• For Jeel-Vaishnav/AegisLimiter (248 test examples) the source repository is no longer available on GitHub and no retained record states its licence; license is null for these examples.

Citation

Cite version 1.0.0 using DOI 10.57967/hf/11350.

@dataset{holovko2026stavegostyle,
  author    = {Holovko, Andrii},
  title     = {{STAVE} {Go} style dataset: labelled {Go} code examples for six code-style classes},
  year      = {2026},
  version   = {1.0.0},
  publisher = {Hugging Face},
  doi       = {10.57967/hf/11350},
  url       = {https://huggingface.co/datasets/aholovko/stave-go-style}
}

CITATION.cff carries the same metadata.