A live Medicare coding decision, proven not guessed
The diabetes trap — proving Medicare claims against 46,881 diagnosis codes.
A deterministic oracle parses the real, 2,069-page CDC/NCHS ICD-10-CM Tabular List and proves every claim against it: no code left unassigned, no two codes that contradict each other, no diagnosis filed without the underlying condition it requires first. The claims below aren't hand-built examples — they're real records from CMS's own official synthetic Medicare claims release (8,671 fully synthetic beneficiaries, published publicly, no patient data of any kind). Run against all 58,066 real claims in the file — the complete population, not a sample — only 2.12% came back clean.
A scripted replay of a real, measured run (recorded ) against real inpatient claims from CMS's public synthetic release — every verdict shown is the oracle's actual output, not invented for the page. Claim IDs are synthetic identifiers CMS's generator assigned, not real Medicare claim numbers; no patient data exists in this source at all.
The scale a coder works against
2,069 pages, 46,881 codes — proven in microseconds, not guessed
The FY2026 ICD-10-CM Tabular List of Diseases and Injuries is 2,069 pages. Vulcan doesn't train on a sample of it and hope the pattern generalizes — it parses the whole thing once, directly, so every one of the 46,881 parsed codes and their Excludes1 / Code-First / 7th-character rules is checked exactly, every time.
Sampled over 20,000 real prove() calls on one core (Apple M5 Max, CPython
3.14.4, no threads, no GPU) — reported worst-case first, not just the flattering number.
≈103,000 decisions/sec average. Honest scope: this is the rule-checking step alone, given
a proposed code list — it does not read a clinical note and choose the codes for you.
CMS publishes its own synthetic Medicare claims release for exactly this kind of testing — 8,671 fully synthetic beneficiaries, real inpatient-claim shapes, no patient data. The source file is sorted by beneficiary, so a partial sample skews — we ran every one of the 58,066 real claims in it through the same oracle above: 84.42% fail on a missing required 7th-character extension (one of the most common real coding errors, not a quirk of the sample), 6.92% are genuine Excludes1 conflicts (spot-checked: Epilepsy vs. Unspecified convulsions — a real, clinically sensible rule, the symptom is subsumed by the diagnosis), 6.54% are Code-First sequencing gaps, and only 2.12% pass every check. Reported as measured, not smoothed into a friendlier number.
The reveal — a real, well-known coding trap
E11.9 and E10.9 look like two reasonable codes. They can never coexist.
E11.9 (Type 2 diabetes mellitus without complications) and
E10.9 (Type 1 diabetes mellitus without complications) each pass every
check alone. Filed together, the Tabular List's own Excludes1 note on E11.9 rules
E10.9 out by name — a patient cannot carry both diagnosis types on the same claim. A
human coder has to know this or catch it by hand; the oracle reads it directly off the
spec and refuses the claim in one step.
E08.9 ("Diabetes mellitus due to underlying condition, without
complications") has a Code-First note: the underlying condition — Cushing's syndrome,
cystic fibrosis, malnutrition, and several others by name — must be coded FIRST. Filed
alone, the oracle refuses it and names exactly what's missing. Add
E24.0 (Pituitary-dependent Cushing's disease) ahead of it, in order, and
the same claim is proven clean. Sequencing is not cosmetic — it's a rule, and it's
checked.
Details
The decision set, the grounding, the scope, and how it was built
No hidden benchmark, no cherry-picked run — the grounding, the decision set, and the provenance are all here. Expand what you want to inspect.
The decision set — every verdict the oracle can reach
A claim is a list of ICD-10-CM codes. Three checks, each traced directly to the Tabular List's own instructional notes:
Grounding — the published source, and only that
Every code, description, and rule traces to the CDC/NCHS-published Tabular List of Diseases and Injuries — the maintainer of ICD-10-CM (CMS republishes it; it does not author it). No experimental drafts, no invented codes:
| Source | Coverage | Status | Used for |
|---|---|---|---|
| FY2026 Tabular List | 2025-10-01 – 2026-09-30 | In force now | 46,881 codes parsed; the rule set every claim is proved against |
| FY2027 Tabular List | 2026-10-01 – 2027-09-30 | Published, not yet in force | 47,025 codes parsed; same pipeline, cross-checked |
| CMS Synthetic Medicare Claims PUF | 8,671 beneficiaries, 2015-2023 | Publicly released | all 58,066 real claims scored; a handful replay in the live monitor |
Scope — what this oracle does NOT cover
Deliberately narrow. It does not read a clinical note and choose codes for you — that's a claim someone hands it, not a claim it invents. Excludes2 and Use-Additional- Code notes are informational only (per the real ICD-10-CM convention, both codes MAY coexist), so they never fail a claim here. It does not cover CPT/HCPCS procedure codes, medical-necessity or MEAT-criteria judgment, or National Correct Coding Initiative edits. Two different kinds of testing back this page, and they measure different things: a self-consistency measure against the parsed rule set itself (does the oracle correctly re-derive the verdict the source data already encodes, at scale — 99.93% over 1,500 self-generated claims), and the real-claims run above (all 58,066 actual CMS synthetic Medicare claims in the file, 2.12% clean). The gap between those two numbers is the point — self-consistency alone would have hidden how often real claim shapes trip the same rules. Neither is yet an external validation against an independent certified coder's judgment — that's the next step, not a claim already made.
How it was built
The Tabular List XML is parsed once into a registry: code identity, chapter, and
every Excludes1 / Excludes2 / Code-First / Use-Additional-Code note — inherited
top-down, since a note on a category applies to every code beneath it — normalized to
exact-code, category-wildcard, or range reference tokens. A claim reduces to three
boolean atoms (all codes valid, no Excludes1 conflict, Code-First order satisfied), and
the same decision procedure the other Vulcan demos use renders the verdict — never a
bare if-check. Measured against 1,500 claims sampled directly from the real FY2026
registry (300 per category, five categories): 99.93% self-consistent. Then measured
again against the complete population of CMS's public synthetic Medicare release —
every one of the 58,066 real claims in the file, not a sample of it (an early partial
sample skewed, since the file is sorted by beneficiary). Diagnosis codes there have
the decimal point stripped (E119 for E11.9), reinserted
before proving. Average 82.6µs per claim, ≈12,100 claims/sec, single core.