Every row is one calibration case: a reasoner makes a claim and states a confidence, and the output gives the honest grade — what actually happened, a one-word verdict, the named error type, and the lesson (the cue that tells you when this kind of claim tends to be wrong).

The product is a catalogue of recurring overconfidence patterns — the structural reasons a claim outruns its evidence — taught on clean, external examples.

Measured composition

metric	value	command
rows	22	`wc -l < calibration_failures.jsonl`
distinct `domain` values	22	`python3 -c "import json;print(len({json.loads(l)['domain'] for l in open('calibration_failures.jsonl')}))"`
distinct `error_type` values	21	same with `['error_type']`
rows with verdict `OVERCONFIDENT`	19	`python3 -c "import json,collections;print(collections.Counter(json.loads(l)['verdict'] for l in open('calibration_failures.jsonl')))"`
rows with verdict `WELL-CALIBRATED`	3	as above
rows with empty `input`	22	as above on `input`

domain is one distinct value per row (22 distinct across 22 rows), i.e. no domain repeats. error_type has 21 distinct values across 22 rows, so 20 error types appear on more than one row (outcome_misidentification appears twice; every other error type appears once).

Verdict values and counts

verdict	rows
`OVERCONFIDENT`	19
`WELL-CALIBRATED`	3

The set is intentionally skewed toward overconfidence — the dominant real failure mode — with 3 calibrated counter-examples so a model does not learn "always say overconfident."

Schema

{"instruction", "input", "output"} plus metadata fields domain, verdict, error_type:

field	rows containing it
`instruction`	22
`input`	22
`output`	22
`domain`	22
`verdict`	22
`error_type`	22

instruction — a domain, a claim, and the confidence a reasoner stated in it; asks for a calibration grade.
input — optional context (empty in this release).
output — Honest grade: → What actually happened: → Calibration verdict: plus the named error type → Lesson:.
verdict — OVERCONFIDENT or WELL-CALIBRATED.
error_type — a snake_case identifier for the recurring pattern.

Example row

instruction: Domain: software / build automation. … Claim: "Our nightly refactor bot has run 80+ automated cleanup passes this month, so code quality has measurably improved." Stated confidence: 0.80

output:

Honest grade: OVERCONFIDENT.

What actually happened: When a real metric was finally checked, the duplicated-code ratio had drifted slightly worse, and most of the bot's passes had touched the same few files. High activity, no movement on the outcome metric.

Calibration verdict: OVERCONFIDENT. Error type: outcome_misidentification — activity was conflated with the measured outcome.

Lesson: Volume of work is not evidence of improvement. Pick the honest outcome metric BEFORE counting activity; if you can't name the metric that should move, your confidence in 'improvement' is unsupported no matter how busy the system looks.

Error-type vocabulary

The named patterns include outcome_misidentification, planning_vs_execution, status_conflation, completion_illusion, failure_point_mislocation, self-check_mistaken_for_a_gate, synthetic_quoted_as_real, power_neglect, small_sample_overconfidence, unverified_novelty, coverage_gap, partial_case_coverage, documentation_trusted_as_verification, single_defense_generalized, unverified_dependency_trust, manual_sync_assumed, planned_mechanism_credited, artifact_undetected, plus the calibrated counter-example types pre_registered_prediction, appropriately_uncertain, and scope_correct_narrow.

Honest notes (this dataset grades itself too)

Provenance: the patterns are derived from observed, documented overconfidence cases. The surface text is rewritten into clean external domains (software, ML, statistics, security, fitness, compliance). It is not verbatim incident data and is not a factual knowledge base — treat it as calibration style/method training, not ground truth. Numbers inside the examples are illustrative.
Size: 22 rows, curated rather than bulk. Use as a seed/eval set or to bootstrap a larger synthetic expansion.
Balance: skewed toward overconfidence by design, with 3 calibrated counter-examples.
Leak-scanned: every row passes a regex leak scan (leak_scan.py, included); rows that hit a pattern are dropped, not patched.
No held-out split is shipped; make your own.

Files

calibration_failures.jsonl — 26017 B, 22 rows.
build.py — deterministic regeneration of the jsonl.
leak_scan.py — the regex gate described above.
LICENSE — CC-BY-4.0.

Reproducing

python3 build.py        # writes calibration_failures.jsonl deterministically
python3 leak_scan.py    # gate: drops any leaking row, fails if the card leaks

Licence

CC-BY-4.0. Free to use with attribution, including commercially.

Downloads last month: 11

Total file size:

77.6 kB