CODE QUALITY · REVIEW GATE · 2026-09-18
It missed 9 of the 28 files I would have opened myself. Useful as a first pass over a large change; not a substitute for reading the diff.
52 files from devagar, 38 from read-2-me · 6,775 lines · jev-latest · one request per file · $0.15 per 1,000 files.
The question. Show the model one source file and nothing else — no diff, no other file, no project conventions — and ask: is a concept this code needs being carried as loose parts instead of as a type? That is the one thing it judges. Naming, comments, error handling, performance, tests and file length are all explicitly excluded.
Why that question. It is the check I would actually want automated. A reviewer reading a large change cannot open everything, and "which of these files has a data structure trying to get out" is the kind of triage that is slow by hand and cheap to ask.
type Timings = {
blockStart: number[];
blockDuration: number[];
}; // same length, same order — nothing enforces it
Two arrays that must be inserted, removed and reordered together. The row is the missing type.
type Screen =
| { kind: 'choosing' }
| { kind: 'running'; session: PracticeSession }
| { kind: 'done'; summary: Summary };
Each state carries exactly its own data. Nothing is being reconstructed from loose parts.
What the answer looks like. Jev never writes text. It returns a probability that the file is worth opening, one of six shape names with a confidence, and a 0–4 score for how well the types match a plain-English description of the file. The full request and response are further down this page.
Cost is input tokens only, at the published jev-latest rate of $0.042 per million: 3,485 tokens for an average file, so 1,000 files cost $0.15. This run of 90 files cost $0.013 and took 374 ms per file at the median.
Both percentages count the same 19 files twice. 19 of the 25 files it flagged were files I had marked — that is the 76%. Those same 19 are 68% of the 28 I marked, leaving 9 it never raised.
Real code has no answer key. The other four tabs score against labels that were built into the samples. Here the samples are files I actually wrote, so there is nothing to score against — and if the model runs first, every later judgement about its flags is reasoning backwards from its answers.
So the labels went first. I read all 90 files and wrote, for each one, whether I would open it in review to argue about its data shapes, which shape I would name, and whether I would defend that in front of someone. Those labels live in review/blind.py and were committed before the first request. review/run.py refuses to start unless that file covers the corpus exactly.
Each file is judged alone. That is what the model sees and what a reviewer reading a diff sees. Duplication across files is real in both repositories — HTTP range logic exists twice, one constant is declared in two places — and none of it counts here, because neither side is shown the other file.
The labels are mine, and they are arguable. 20 of the 90 are marked unsure. Every file is listed below with its code and my reason, so you can disagree with me rather than take the precision figure on faith. On the 70 I would defend, the ranking holds up the same: AUC 0.869 against 0.875 overall.
| RULE | PROVENANCE | FLAGS / 100 | PRECISION | RECALL | FALSE ALARMS | MISSED |
|---|---|---|---|---|---|---|
| gate >= 0.70 | pre-registered | 28 | 76% | 68% | 6 | 9 |
| verdict names a shape | post-hoc | 17 | 93% | 50% | 1 | 14 |
| gate >= 0.70 OR names a shape | post-hoc | 33 | 77% | 82% | 7 | 5 |
| gate >= 0.70 AND names a shape | post-hoc | 11 | 100% | 36% | 0 | 18 |
| any evidence noul >= 0.60 | post-hoc | 42 | 45% | 61% | 21 | 11 |
Only the first row was fixed before the labels were seen. I pre-registered the yes/no gate at 0.70 as the decision rule. The shape rule beat it, and I found that by looking — which is exactly the move the pre-registration exists to expose. Treat 76% as the number that carries no selection bias, and 93% as a hypothesis worth re-testing on a repository this one was not tuned against.
The gap is informative rather than embarrassing. Every one of the 6 false alarms under the pre-registered rule is a file the model rated above 0.70 while naming no shape at all — it was uneasy and could not say why. Requiring a named shape removes all but one of them.
| CUT | FLAGS / 100 | PRECISION | RECALL | FA | MISS |
|---|---|---|---|---|---|
| 0.50 | 57 | 49% | 89% | 26 | 3 |
| 0.60 | 48 | 56% | 86% | 19 | 4 |
| 0.65 | 36 | 69% | 79% | 10 | 6 |
| 0.70 | 28 | 76% | 68% | 6 | 9 |
| 0.75 | 22 | 75% | 54% | 5 | 13 |
| 0.80 | 10 | 78% | 25% | 2 | 21 |
| 0.85 | 4 | 100% | 14% | 0 | 24 |
| 0.90 | 0 | 0% | 0% | 0 | 28 |
Nothing scores above 0.90. The gate compresses into 0.3–0.85, so the usable range of thresholds is narrow and a cut chosen on one repository may not transfer.
| KEY | NAME | WHAT IT MEANS | MINE | ITS |
|---|---|---|---|---|
| scattered_state | scattered state | One state held as several separate mutable variables, often with '' or -1 for 'none'. | 12 | 7 |
| tandem_params | tandem parameters | Two or more values always travel together, in the same order, from the same source. | 3 | 1 |
| branch_table | branch table | A conditional whose branches assign the same fields to different constants — the rows of a table. | 5 | 3 |
| parallel_collections | parallel collections | Two collections share an index or key and must be changed in lockstep. | 6 | 3 |
| stringly_encoded | stringly encoded | A record packed into a string, filename or bitfield and re-parsed by every reader. | 2 | 1 |
On the 14 files we both flagged, it named my exact shape 86% of the time. Where I recorded a second defensible shape before the run, accepting either gives 93%. The message a reviewer would read is the shape, not the score — so this is the number that decides whether the flag is actionable.
| GATE | FILE | LINES | ITS SHAPE | WHY I CALLED IT CLEAN |
|---|---|---|---|---|
| 0.83 | devagar:src/routes/api/sync/+server.ts | 17 | nothing to extract | 17 lines: parse, insert, return. |
| 0.81 | devagar:scripts/configure-berget.ts | 38 | nothing to extract | Linear setup script; the config it writes is one flat record and reads as one. |
| 0.78 | devagar:src/routes/api/notifications/+server.ts | 26 | nothing to extract | Parsed at the boundary with zod; the host allowlist is data. |
| 0.75 | read-2-me:extension/src/content.ts | 202 | nothing to extract | Long, but it is DOM walking; the data it produces is handed to a parsed type. |
| 0.75 | read-2-me:shared/src/text.ts | 59 | nothing to extract | Pure string helpers with narrow signatures. |
| 0.71 | read-2-me:web/src/lib/player/player.ts | 398 | nothing to extract | 398 lines and the longest unit, but the state it owns is one object with one transition function. |
All six named no shape. Two are 17 and 26 lines long; a gate that gets uneasy about a 17-line endpoint is telling you about its own uncertainty, not about the file. The cost of each is one file opened for nothing.
| GATE | FILE | LINES | ITS SHAPE | WHAT I WOULD HAVE SAID |
|---|---|---|---|---|
| 0.32 | read-2-me:shared/src/types.ts | 68 | nothing to extract | tandem parameters — `positionSeconds` / `positionAt` and `scrollBlock` / `scrollBlockAt` are two value-plus-timestamp pairs passed and merged together everywhere, never named as one stamped value. |
| 0.42 | read-2-me:shared/src/state-merge.ts | 45 | tandem parameters | tandem parameters — It introduces a `PositionPair` and then immediately unpacks it back into flat fields, so the concept exists in the file without being used. |
| 0.44 | devagar:src/lib/today.ts | 45 | nothing to extract | branch table — Six near-identical recommendation literals differ only in field values, selected by an if-chain. A table of recommendations written as control flow. |
| 0.56 | devagar:scripts/verify-deployment.ts | 78 | nothing to extract | tandem parameters — Targets are `[name, browserType, options]` tuples, then `name === 'desktop'` is re-tested later -- the tuple is a record with the discriminant stringly recovered. |
| 0.60 | devagar:src/routes/api/speech/+server.ts | 29 | branch table | branch table — The two provider blocks each re-derive endpoint, auth header, body shape and response decoding from the same provider string. |
| 0.63 | devagar:src/lib/components/LessonSession.svelte | 147 | nothing to extract | scattered state — `phase`, `feedback` and `checkpointOutcome` are three unions that are not independent: `checkpointOutcome` only means anything in one phase, so illegal combinations are representable. |
| 0.65 | read-2-me:shared/src/timings.ts | 51 | parallel collections | parallel collections — `Timings` is two arrays -- `blockStart` and `blockDuration` -- that must have equal length and matching indices, with nothing enforcing it. |
| 0.69 | devagar:src/lib/practice.ts | 155 | nothing to extract | branch table — `score()` carries per-kind magic constants in a branch chain; the weights are a table written as control flow. |
| 0.69 | devagar:src/routes/api/transcribe/+server.ts | 20 | branch table | branch table — Provider decides the key, the accepted content type, the request shape and which response field holds the text -- four branches on one string chosen by a ternary over an env var. |
Four of these it actually got right and under-scored: it named my exact shape on state-merge.ts, timings.ts, api/speech and api/transcribe while rating them 0.42–0.69. The shape answer knew; the confidence number did not. That is the whole case for the post-hoc rule, and also the reason to distrust it until it is tried elsewhere.
The genuine misses are shared/src/types.ts at 0.32 — two value-plus-timestamp pairs that every merge function unpacks by hand — and today.ts at 0.44, six near-identical recommendation literals selected by an if-chain. Both are the kind of thing a reviewer spots in seconds and this gate does not.
| GATE | PATH | REPO | LINES | ITS SHAPE | MY LABEL | MATCH |
|---|---|---|---|---|---|---|
| 0.88 | src/lib/player.svelte.ts | devagar | 33 | scattered state | LOOK | 1.94 |
| 0.88 | src/lib/server/reminders.ts | devagar | 32 | stringly encoded | LOOK? | 0.79 |
| 0.88 | src/lib/state.svelte.ts | devagar | 108 | scattered state | LOOK | 1.91 |
| 0.87 | src/lib/speech.ts | devagar | 78 | scattered state | LOOK | 2.26 |
| 0.84 | src/routes/sentences/+page.svelte | devagar | 117 | — | LOOK | 2.14 |
| 0.83 | src/routes/api/sync/+server.ts | devagar | 17 | — | CLEAN | 1.20 |
| 0.82 | src/routes/settings/+page.svelte | devagar | 51 | — | LOOK | 2.08 |
| 0.81 | scripts/configure-berget.ts | devagar | 38 | — | CLEAN | 1.44 |
| 0.81 | src/lib/components/AnswerInput.svelte | devagar | 80 | — | LOOK | 2.11 |
| 0.79 | src/lib/components/ListeningShelf.svelte | devagar | 34 | scattered state | LOOK | 2.16 |
| 0.78 | src/routes/api/notifications/+server.ts | devagar | 26 | — | CLEAN | 1.71 |
| 0.78 | src/routes/+page.svelte | devagar | 92 | — | LOOK? | 1.99 |
| 0.78 | src/routes/review/+page.svelte | devagar | 162 | — | LOOK? | 2.12 |
| 0.78 | extension/src/playbar/playbar.ts | read-2-me | 261 | scattered state | LOOK | 2.68 |
| 0.77 | web/src/lib/player/karaoke.ts | read-2-me | 143 | scattered state | LOOK | 2.41 |
| 0.76 | scripts/build-voice-auditions.ts | devagar | 66 | branch table | LOOK | 1.63 |
| 0.76 | src/lib/content.ts | devagar | 375 | — | LOOK | 2.80 |
| 0.76 | src/routes/palace/+page.svelte | devagar | 22 | scattered state | LOOK | 2.16 |
| 0.75 | extension/src/content.ts | read-2-me | 202 | — | CLEAN | 2.41 |
| 0.75 | shared/src/text.ts | read-2-me | 59 | — | CLEAN | 3.12 |
| 0.72 | web/src/lib/server/tts/pipeline.ts | read-2-me | 77 | parallel collections | LOOK | 1.99 |
| 0.71 | src/lib/components/PracticeSession.svelte | devagar | 138 | — | LOOK? | 2.53 |
| 0.71 | web/src/lib/player/player.ts | read-2-me | 398 | — | CLEAN | 2.92 |
| 0.70 | scripts/build-audio-samples.ts | devagar | 57 | — | LOOK? | 2.05 |
| 0.70 | scripts/build-audio.ts | devagar | 62 | — | LOOK | 1.75 |
| 0.69 | src/lib/practice.ts | devagar | 155 | — | LOOK? | 2.76 |
| 0.69 | src/routes/api/transcribe/+server.ts | devagar | 20 | branch table | LOOK | 1.77 |
| 0.68 | web/src/lib/server/tts/inworld.ts | read-2-me | 93 | parallel collections | CLEAN | 3.37 |
| 0.67 | src/service-worker.ts | devagar | 49 | — | CLEAN | 1.96 |
| 0.66 | scripts/check-voice-auditions.ts | devagar | 35 | — | CLEAN | 2.27 |
| 0.65 | shared/src/timings.ts | read-2-me | 51 | parallel collections | LOOK | 2.15 |
| 0.65 | web/src/lib/player/playback-store.ts | read-2-me | 187 | — | CLEAN | 2.61 |
| 0.64 | src/lib/server/practice-planner.ts | devagar | 31 | — | CLEAN | 1.89 |
| 0.64 | extension/src/options/options.ts | read-2-me | 27 | — | CLEAN | 2.51 |
| 0.64 | web/src/lib/components/Player.svelte | read-2-me | 54 | — | CLEAN | 2.94 |
| 0.63 | src/lib/learning.ts | devagar | 140 | — | CLEAN | 2.39 |
| 0.63 | src/lib/components/LessonSession.svelte | devagar | 147 | — | LOOK? | 2.77 |
| 0.63 | src/lib/server/db.ts | devagar | 40 | — | CLEAN | 1.50 |
| 0.63 | web/src/lib/server/jobs.ts | read-2-me | 58 | — | CLEAN | 3.10 |
| 0.62 | src/routes/practice/+page.svelte | devagar | 60 | — | CLEAN | 2.85 |
| 0.62 | web/src/lib/server/http-range.ts | read-2-me | 67 | — | CLEAN | 2.57 |
| 0.60 | src/routes/+layout.svelte | devagar | 57 | — | CLEAN | 2.22 |
| 0.60 | src/routes/api/speech/+server.ts | devagar | 29 | branch table | LOOK | 2.31 |
| 0.59 | src/routes/api/practice-plan/+server.ts | devagar | 28 | — | CLEAN | 2.36 |
| 0.58 | src/lib/components/Icon.svelte | devagar | 34 | — | CLEAN | 2.91 |
| 0.56 | scripts/verify-deployment.ts | devagar | 78 | — | LOOK? | 2.28 |
| 0.54 | src/lib/voice-auditions.ts | devagar | 80 | — | CLEAN | 3.23 |
| 0.53 | web/src/routes/doc/[id]/+page.svelte | read-2-me | 132 | — | CLEAN | 2.55 |
| 0.52 | src/lib/episode-audio.ts | devagar | 21 | — | CLEAN | 2.77 |
| 0.52 | web/src/lib/server/tts/wav.ts | read-2-me | 105 | — | CLEAN | 3.10 |
| 0.50 | src/routes/progress/+page.svelte | devagar | 20 | — | CLEAN | 1.74 |
| 0.44 | server.ts | devagar | 24 | — | CLEAN | 1.70 |
| 0.44 | src/lib/today.ts | devagar | 45 | — | LOOK | 2.40 |
| 0.43 | src/lib/portuguese-input.ts | devagar | 18 | — | CLEAN | 2.04 |
| 0.42 | shared/src/state-merge.ts | read-2-me | 45 | tandem parameters | LOOK | 3.32 |
| 0.41 | src/lib/curriculum.ts | devagar | 142 | — | CLEAN | 2.88 |
| 0.38 | src/routes/listen/voices/+page.svelte | devagar | 91 | — | CLEAN | 2.73 |
| 0.38 | web/src/lib/server/tts/cache.ts | read-2-me | 133 | — | CLEAN | 3.16 |
| 0.37 | src/routes/map/+page.svelte | devagar | 44 | — | CLEAN | 2.64 |
| 0.37 | web/src/lib/server/extract/readability.ts | read-2-me | 74 | — | CLEAN | 3.28 |
| 0.37 | web/src/routes/login/+page.server.ts | read-2-me | 25 | — | CLEAN | 2.18 |
| 0.36 | src/lib/appearance.ts | devagar | 18 | — | CLEAN | 2.65 |
| 0.36 | src/lib/components/PracticeChooser.svelte | devagar | 31 | — | CLEAN | 2.43 |
| 0.36 | web/src/lib/server/budget.ts | read-2-me | 55 | — | CLEAN | 3.16 |
| 0.35 | src/routes/learn/+page.svelte | devagar | 52 | — | CLEAN | 2.22 |
| 0.33 | web/src/routes/api/tts/+server.ts | read-2-me | 60 | — | CLEAN | 2.58 |
| 0.33 | web/src/routes/+page.svelte | read-2-me | 235 | — | CLEAN | 3.03 |
| 0.32 | shared/src/types.ts | read-2-me | 68 | — | LOOK | 2.83 |
| 0.32 | web/src/lib/server/store.ts | read-2-me | 141 | — | CLEAN | 3.29 |
| 0.31 | src/lib/components/ProgressTrack.svelte | devagar | 19 | — | CLEAN | 2.54 |
| 0.31 | src/lib/practice-session.ts | devagar | 24 | — | CLEAN | 2.98 |
| 0.31 | web/src/routes/+page.server.ts | read-2-me | 68 | — | CLEAN | 2.95 |
| 0.30 | web/src/lib/server/submit.ts | read-2-me | 61 | — | CLEAN | 3.22 |
| 0.29 | extension/src/extract-live.ts | read-2-me | 75 | — | CLEAN | 3.43 |
| 0.29 | web/src/lib/server/extract/pdf.ts | read-2-me | 41 | — | CLEAN | 2.88 |
| 0.28 | web/src/lib/server/tts/fal.ts | read-2-me | 44 | — | CLEAN | 3.06 |
| 0.27 | shared/src/parse.ts | read-2-me | 123 | — | CLEAN | 3.15 |
| 0.27 | web/src/lib/server/auth.ts | read-2-me | 31 | — | CLEAN | 2.69 |
| 0.26 | src/routes/listen/samples/+page.svelte | devagar | 54 | — | CLEAN | 2.06 |
| 0.26 | extension/build.ts | read-2-me | 46 | — | CLEAN | 2.78 |
| 0.24 | web/src/hooks.server.ts | read-2-me | 41 | — | CLEAN | 2.58 |
| 0.23 | src/lib/listening-series.ts | devagar | 16 | — | CLEAN | 2.83 |
| 0.23 | shared/src/index.ts | read-2-me | 26 | — | CLEAN | 1.94 |
| 0.21 | src/lib/components/AudioSpeed.svelte | devagar | 16 | — | CLEAN | 2.80 |
| 0.21 | web/src/lib/server/extract/url.ts | read-2-me | 45 | — | CLEAN | 3.37 |
| 0.19 | src/lib/audio-samples.ts | devagar | 44 | — | CLEAN | 3.47 |
| 0.19 | extension/src/messages.ts | read-2-me | 70 | — | CLEAN | 2.99 |
| 0.17 | web/src/routes/login/+page.svelte | read-2-me | 55 | — | CLEAN | 2.82 |
| 0.12 | src/lib/components/Illustration.svelte | devagar | 25 | — | CLEAN | 3.64 |
| 0.12 | web/src/lib/server/extract/types.ts | read-2-me | 24 | — | CLEAN | 3.59 |
Pick any row above.
Jev never writes a word. It scores criteria you supply. Everything the review gate knows about code quality is in the question text below — one instruction paragraph, then a what, a not_for and two examples per shape. The state carries the repository, the path, the language and the file. Nothing else: no diff, no other file, no project conventions.
This sample. Timings is two arrays — blockStart and blockDuration — that must stay the same length and index-aligned, with nothing enforcing it. I labelled it parallel_collections before the run; Jev names parallel_collections at 0.30 but rates worth_a_look only 0.65. It is the clearest case of the split this page is about.
{
"state": {
"repo": "read-2-me",
"path": "shared/src/timings.ts",
"language": "TypeScript",
"code": "/* Word-timing synthesis. TTS chunks contain whole blocks (or sentence runs\n * of one oversize block), so measured chunk durations give real per-block\n * start times; within a block, word starts are interpolated by character\n * share — the same estimation the essence player falls back to, but anchored\n * per chunk instead of per chapter. Output is byte-compatible with the\n * player's words.json format and must satisfy its validateTimings. */\n\nimport type { Timings } from \"./types.ts\";\nimport type { TtsChunk } from \"./text.ts\";\n\nexport function synthesizeTimings(\n blockTexts: readonly string[],\n chunks: readonly TtsChunk[],\n chunkDurationsSeconds: readonly number[],\n): Timings {\n if (chunks.length !== chunkDurationsSeconds.length) {\n throw new Error(`synthesizeTimings: ${chunks.length} chunks but ${chunkDurationsSeconds.length} durations`);\n }\n\n // walk chunks in order, spreading each chunk's duration over its spans by\n // character share → per-block start time and total duration\n const blockStart = new Array<number>(blockTexts.length).fill(NaN);\n const blockDuration = new Array<number>(blockTexts.length).fill(0);\n let clock = 0;\n chunks.forEach((chunk, i) => {\n const chunkChars = chunk.spans.reduce((sum, span) => sum + span.chars, 0);\n for (const span of chunk.spans) {\n const share = chunkChars === 0 ? 0 : (span.chars / chunkChars) * chunkDurationsSeconds[i];\n if (Number.isNaN(blockStart[span.blockIndex])) blockStart[span.blockIndex] = clock;\n blockDuration[span.blockIndex] += share;\n clock += share;\n }\n });\n\n const blockWordCounts: number[] = [];\n const starts: number[] = [];\n blockTexts.forEach((text, blockIndex) => {\n const words = text.split(/\\s+/).filter(Boolean);\n blockWordCounts.push(words.length);\n const totalChars = words.reduce((sum, w) => sum + w.length, 0);\n const start = Number.isNaN(blockStart[blockIndex]) ? clock : blockStart[blockIndex];\n let charsBefore = 0;\n for (const word of words) {\n const share = totalChars === 0 ? 0 : charsBefore / totalChars;\n starts.push(Math.round((start + share * blockDuration[blockIndex]) * 100) / 100);\n charsBefore += word.length;\n }\n });\n return { blockWordCounts, starts };\n}\n"
},
"model": "jev-latest",
"questions": {
"worth_a_look": {
"type": "noul",
"instructions": "You are triaging files in a code review. A reviewer has attention for a few files, not all of them. Say in one sentence how `code` works, then check whether every concept that sentence names exists as a type in the code. Flag the file when a concept the sentence needs is carried as loose parts instead — values that always travel together, a conditional whose branches assign the same fields, collections held in lockstep, a record packed into a string, or one state spread across separate mutable variables. Judge the shape of the data only. Naming, comments, error handling, performance, missing tests and file length are not reasons to flag. Length is not evidence: a long file whose types match its sentence is fine, and a short file can hide a missing type.",
"criteria": {
"true": "A concept this code needs is carried as loose parts. A reviewer should open this file and argue about its data shapes.",
"false": "The types already carry every concept the code's sentence names. Opening this file in review would waste the reviewer's attention."
}
},
"verdict": {
"type": "choice",
"instructions": "Which shape does the missing data structure take in `code`? Pick `no_structure` when the types already carry every concept the code's one-sentence description names. Judge the shape of the data only; ignore naming, error handling, performance and missing tests.",
"criteria": {
"no_structure": {
"what": "The types in the code already match the sentence: every concept the sentence names exists as a type, and no group of values is being carried as loose parts.",
"not_for": "Code that is merely short or tidy; check each value that travels with another."
},
"scattered_state": {
"what": "One state is held as several separate mutable variables — module-level lets, component state, closure variables — that are written and cleared together, often with a sentinel such as '' or -1 for 'none'.",
"not_for": "Variables that hold genuinely independent facts and are written at different times for different reasons.",
"examples": [
"let currentAudio, currentUrl, generation at module scope, all reset by one stop()",
"isEditing: boolean beside editId = '' where '' means nothing is being edited"
]
},
"tandem_params": {
"what": "Two or more values always travel together as separate parameters or separate fields, in the same order, from the same source.",
"not_for": "Parameters that genuinely vary independently between call sites.",
"examples": [
"A constructor taking x, y, width, height instead of a point and a size",
"Fields repeated with a prefix: shipCity, shipPostcode / billCity, billPostcode"
]
},
"branch_table": {
"what": "A conditional whose branches each assign the same set of fields to different constants. The branches are rows of a table and the tuple of constants is the missing type.",
"not_for": "A conditional whose branches do genuinely different work rather than assigning the same fields.",
"examples": [
"if plan === 'free' set three limits, else if 'team' set the same three limits",
"A switch on provider choosing endpoint, auth header and response field"
]
},
"parallel_collections": {
"what": "Two or more collections share an index or a key and must be inserted, removed and reordered in lockstep. The row is the missing type.",
"not_for": "A single collection of records, or two collections that are genuinely unrelated.",
"examples": [
"names[], emails[] and scores[] spliced together at the same index",
"displayTexts[] beside spokenTexts[] that must stay index-aligned"
]
},
"stringly_encoded": {
"what": "A record is packed into a string, a filename, a delimited column or a bitfield and taken apart again by every reader with its own parsing.",
"not_for": "A string that really is one opaque value, such as free text or an id.",
"examples": [
"status = 'paid|2026-01-03|card' read with split('|') in three functions",
"A state machine whose current state is held as the English sentence shown to the user"
]
}
}
},
"scattered_state": {
"type": "noul",
"instructions": "About the data in `code`: Is a single state spread across separate mutable variables that are written and cleared together?",
"criteria": {
"true": "Yes, clearly: one state is held as several separate mutable variables.",
"false": "No: one state is held as several separate mutable variables does not describe this code."
}
},
"tandem_params": {
"type": "noul",
"instructions": "About the data in `code`: Do two or more values always appear together, in the same order, from the same source?",
"criteria": {
"true": "Yes, clearly: values always travel together as separate parameters or fields.",
"false": "No: values always travel together as separate parameters or fields does not describe this code."
}
},
"branch_table": {
"type": "noul",
"instructions": "About the data in `code`: Does a conditional assign the same set of fields to different constants in each branch?",
"criteria": {
"true": "Yes, clearly: a conditional assigns a tuple of constants per branch.",
"false": "No: a conditional assigns a tuple of constants per branch does not describe this code."
}
},
"parallel_collections": {
"type": "noul",
"instructions": "About the data in `code`: Do two or more collections share an index or key and have to be changed together?",
"criteria": {
"true": "Yes, clearly: collections are indexed or keyed in lockstep.",
"false": "No: collections are indexed or keyed in lockstep does not describe this code."
}
},
"stringly_encoded": {
"type": "noul",
"instructions": "About the data in `code`: Is a multi-field record encoded into one string, filename or number and re-parsed by its readers?",
"criteria": {
"true": "Yes, clearly: a record is packed into a string, filename or bitfield.",
"false": "No: a record is packed into a string, filename or bitfield does not describe this code."
}
},
"plain_english_match": {
"type": "score",
"instructions": "How well do the types in `code` match a one-sentence plain-English description of how it works? Compare the concepts the sentence needs with the types the code actually has.",
"criteria": [
"The reader must rebuild every concept from loose parts: values travel in groups, records live inside strings, collections share an index.",
"One concept the sentence names exists as a type; the rest are carried as loose parts.",
"The main concept exists as a type, but several of its parts are still passed or stored separately.",
"Nearly every concept the sentence names is a type; one small group of values is still loose.",
"Every concept the sentence names is a type in the code, and every type is a concept in the sentence."
]
}
}
}{
"worth_a_look": {
"noul": 0.65
},
"verdict": {
"choice": "parallel_collections",
"confidence": 0.3,
"probabilities": {
"parallel_collections": 0.43,
"tandem_params": 0.13,
"no_structure": 0.41,
"scattered_state": 0.03,
"stringly_encoded": 0.0,
"branch_table": 0.0
}
},
"scattered_state": {
"noul": 0.41
},
"tandem_params": {
"noul": 0.39
},
"branch_table": {
"noul": 0.08
},
"parallel_collections": {
"noul": 0.87
},
"stringly_encoded": {
"noul": 0.06
},
"plain_english_match": {
"score": 2.15
}
}One labeller, and it is the author. I wrote both repositories, so I know what each file was trying to be. A second reviewer would disagree with some of the 28 — the 20 unsure ones most of all.
Two repositories, one author, one style. Both are TypeScript, both are mine, both were written with the same principles in mind. A codebase with different habits would produce different numbers.
A flag is not a fix. Jev returns a shape and a probability, never a suggestion. Turning "parallel collections" into a review comment someone can act on is still a person's job — or another model's.
Length is a weak confound, not the explanation. The gate correlates with file length at 0.26, and my own flagged files do average longer (94 lines against 67). But the largest file in the corpus, player.ts at 398 lines, is one I called clean and it scored 0.71 — while a 51-line file I flagged scored 0.65.
The files were sent to a third party. Every file below went to api.typesafe.ai/v1/systemone in the request shown above.