SOFTWARE DESIGN · JEV

CODE QUALITY · REVIEW GATE · 2026-09-18

Can a model triage a code review? On 90 files of mine, 76% of what it flagged was worth opening.

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.

WHAT I CHECKEDONE FILE AT A TIME

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.

A FILE IT FLAGGED · shared/src/timings.tsparallel_collections
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.

A FILE IT LEFT ALONE · routes/practice/+page.sveltenothing to extract
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.

THE WHOLE RUN, LEFT TO RIGHT ONE PASS · jev-latest
FILES CHECKED
90FILES
52 FROM DEVAGAR · 38 FROM READ-2-ME
I WOULD OPEN
28OF 90
MARKED BEFORE THE RUN
IT FLAGS
25OF 90
CUT AT GATE ≥ 0.70
WORTH OPENING
76%
19 OF ITS 25 FLAGS
OF MINE, FOUND
68%
19 OF MY 28 · 9 MISSED
COST
0.15USD
PER 1,000 FILES · 3,485 TOKENS EACH

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.

HOW THIS WAS MADE HONESTPRE-REGISTERED

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.

WHICH RULE TO SHIP90 FILES · 28 WORTH A LOOK · BASE RATE 31%
RULEPROVENANCEFLAGS / 100PRECISIONRECALLFALSE ALARMSMISSED
gate >= 0.70pre-registered28
76%
68%
69
verdict names a shapepost-hoc17
93%
50%
114
gate >= 0.70 OR names a shapepost-hoc33
77%
82%
75
gate >= 0.70 AND names a shapepost-hoc11
100%
36%
018
any evidence noul >= 0.60post-hoc42
45%
61%
2111

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.

WHERE TO PUT THE THRESHOLDworth_a_look
CUTFLAGS / 100PRECISIONRECALLFAMISS
0.5057
49%
89%
263
0.6048
56%
86%
194
0.6536
69%
79%
106
0.7028
76%
68%
69
0.7522
75%
54%
513
0.8010
78%
25%
221
0.854
100%
14%
024
0.900
0%
0%
028

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.

SHAPES IT NAMESEXACT 86% · ACCEPTED 93%
KEYNAMEWHAT IT MEANSMINEITS
scattered_statescattered stateOne state held as several separate mutable variables, often with '' or -1 for 'none'.127
tandem_paramstandem parametersTwo or more values always travel together, in the same order, from the same source.31
branch_tablebranch tableA conditional whose branches assign the same fields to different constants — the rows of a table.53
parallel_collectionsparallel collectionsTwo collections share an index or key and must be changed in lockstep.63
stringly_encodedstringly encodedA record packed into a string, filename or bitfield and re-parsed by every reader.21

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.

THE 6 FALSE ALARMSGATE ≥ 0.70 · I SAID CLEAN
GATEFILELINESITS SHAPEWHY I CALLED IT CLEAN
0.83devagar:src/routes/api/sync/+server.ts17nothing to extract17 lines: parse, insert, return.
0.81devagar:scripts/configure-berget.ts38nothing to extractLinear setup script; the config it writes is one flat record and reads as one.
0.78devagar:src/routes/api/notifications/+server.ts26nothing to extractParsed at the boundary with zod; the host allowlist is data.
0.75read-2-me:extension/src/content.ts202nothing to extractLong, but it is DOM walking; the data it produces is handed to a parsed type.
0.75read-2-me:shared/src/text.ts59nothing to extractPure string helpers with narrow signatures.
0.71read-2-me:web/src/lib/player/player.ts398nothing to extract398 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.

THE 9 IT MISSEDI SAID LOOK · GATE < 0.70
GATEFILELINESITS SHAPEWHAT I WOULD HAVE SAID
0.32read-2-me:shared/src/types.ts68nothing to extracttandem parameters — `positionSeconds` / `positionAt` and `scrollBlock` / `scrollBlockAt` are two value-plus-timestamp pairs passed and merged together everywhere, never named as one stamped value.
0.42read-2-me:shared/src/state-merge.ts45tandem parameterstandem 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.44devagar:src/lib/today.ts45nothing to extractbranch 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.56devagar:scripts/verify-deployment.ts78nothing to extracttandem 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.60devagar:src/routes/api/speech/+server.ts29branch tablebranch table — The two provider blocks each re-derive endpoint, auth header, body shape and response decoding from the same provider string.
0.63devagar:src/lib/components/LessonSession.svelte147nothing to extractscattered 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.65read-2-me:shared/src/timings.ts51parallel collectionsparallel collections — `Timings` is two arrays -- `blockStart` and `blockDuration` -- that must have equal length and matching indices, with nothing enforcing it.
0.69devagar:src/lib/practice.ts155nothing to extractbranch table — `score()` carries per-kind magic constants in a branch chain; the weights are a table written as control flow.
0.69devagar:src/routes/api/transcribe/+server.ts20branch tablebranch 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.

EVERY FILE, RANKEDCLICK A ROW FOR THE CODE AND BOTH JUDGEMENTS
GATEPATHREPOLINESITS SHAPEMY LABELMATCH
0.88src/lib/player.svelte.tsdevagar33scattered stateLOOK1.94
0.88src/lib/server/reminders.tsdevagar32stringly encodedLOOK?0.79
0.88src/lib/state.svelte.tsdevagar108scattered stateLOOK1.91
0.87src/lib/speech.tsdevagar78scattered stateLOOK2.26
0.84src/routes/sentences/+page.sveltedevagar117—LOOK2.14
0.83src/routes/api/sync/+server.tsdevagar17—CLEAN1.20
0.82src/routes/settings/+page.sveltedevagar51—LOOK2.08
0.81scripts/configure-berget.tsdevagar38—CLEAN1.44
0.81src/lib/components/AnswerInput.sveltedevagar80—LOOK2.11
0.79src/lib/components/ListeningShelf.sveltedevagar34scattered stateLOOK2.16
0.78src/routes/api/notifications/+server.tsdevagar26—CLEAN1.71
0.78src/routes/+page.sveltedevagar92—LOOK?1.99
0.78src/routes/review/+page.sveltedevagar162—LOOK?2.12
0.78extension/src/playbar/playbar.tsread-2-me261scattered stateLOOK2.68
0.77web/src/lib/player/karaoke.tsread-2-me143scattered stateLOOK2.41
0.76scripts/build-voice-auditions.tsdevagar66branch tableLOOK1.63
0.76src/lib/content.tsdevagar375—LOOK2.80
0.76src/routes/palace/+page.sveltedevagar22scattered stateLOOK2.16
0.75extension/src/content.tsread-2-me202—CLEAN2.41
0.75shared/src/text.tsread-2-me59—CLEAN3.12
0.72web/src/lib/server/tts/pipeline.tsread-2-me77parallel collectionsLOOK1.99
0.71src/lib/components/PracticeSession.sveltedevagar138—LOOK?2.53
0.71web/src/lib/player/player.tsread-2-me398—CLEAN2.92
0.70scripts/build-audio-samples.tsdevagar57—LOOK?2.05
0.70scripts/build-audio.tsdevagar62—LOOK1.75
0.69src/lib/practice.tsdevagar155—LOOK?2.76
0.69src/routes/api/transcribe/+server.tsdevagar20branch tableLOOK1.77
0.68web/src/lib/server/tts/inworld.tsread-2-me93parallel collectionsCLEAN3.37
0.67src/service-worker.tsdevagar49—CLEAN1.96
0.66scripts/check-voice-auditions.tsdevagar35—CLEAN2.27
0.65shared/src/timings.tsread-2-me51parallel collectionsLOOK2.15
0.65web/src/lib/player/playback-store.tsread-2-me187—CLEAN2.61
0.64src/lib/server/practice-planner.tsdevagar31—CLEAN1.89
0.64extension/src/options/options.tsread-2-me27—CLEAN2.51
0.64web/src/lib/components/Player.svelteread-2-me54—CLEAN2.94
0.63src/lib/learning.tsdevagar140—CLEAN2.39
0.63src/lib/components/LessonSession.sveltedevagar147—LOOK?2.77
0.63src/lib/server/db.tsdevagar40—CLEAN1.50
0.63web/src/lib/server/jobs.tsread-2-me58—CLEAN3.10
0.62src/routes/practice/+page.sveltedevagar60—CLEAN2.85
0.62web/src/lib/server/http-range.tsread-2-me67—CLEAN2.57
0.60src/routes/+layout.sveltedevagar57—CLEAN2.22
0.60src/routes/api/speech/+server.tsdevagar29branch tableLOOK2.31
0.59src/routes/api/practice-plan/+server.tsdevagar28—CLEAN2.36
0.58src/lib/components/Icon.sveltedevagar34—CLEAN2.91
0.56scripts/verify-deployment.tsdevagar78—LOOK?2.28
0.54src/lib/voice-auditions.tsdevagar80—CLEAN3.23
0.53web/src/routes/doc/[id]/+page.svelteread-2-me132—CLEAN2.55
0.52src/lib/episode-audio.tsdevagar21—CLEAN2.77
0.52web/src/lib/server/tts/wav.tsread-2-me105—CLEAN3.10
0.50src/routes/progress/+page.sveltedevagar20—CLEAN1.74
0.44server.tsdevagar24—CLEAN1.70
0.44src/lib/today.tsdevagar45—LOOK2.40
0.43src/lib/portuguese-input.tsdevagar18—CLEAN2.04
0.42shared/src/state-merge.tsread-2-me45tandem parametersLOOK3.32
0.41src/lib/curriculum.tsdevagar142—CLEAN2.88
0.38src/routes/listen/voices/+page.sveltedevagar91—CLEAN2.73
0.38web/src/lib/server/tts/cache.tsread-2-me133—CLEAN3.16
0.37src/routes/map/+page.sveltedevagar44—CLEAN2.64
0.37web/src/lib/server/extract/readability.tsread-2-me74—CLEAN3.28
0.37web/src/routes/login/+page.server.tsread-2-me25—CLEAN2.18
0.36src/lib/appearance.tsdevagar18—CLEAN2.65
0.36src/lib/components/PracticeChooser.sveltedevagar31—CLEAN2.43
0.36web/src/lib/server/budget.tsread-2-me55—CLEAN3.16
0.35src/routes/learn/+page.sveltedevagar52—CLEAN2.22
0.33web/src/routes/api/tts/+server.tsread-2-me60—CLEAN2.58
0.33web/src/routes/+page.svelteread-2-me235—CLEAN3.03
0.32shared/src/types.tsread-2-me68—LOOK2.83
0.32web/src/lib/server/store.tsread-2-me141—CLEAN3.29
0.31src/lib/components/ProgressTrack.sveltedevagar19—CLEAN2.54
0.31src/lib/practice-session.tsdevagar24—CLEAN2.98
0.31web/src/routes/+page.server.tsread-2-me68—CLEAN2.95
0.30web/src/lib/server/submit.tsread-2-me61—CLEAN3.22
0.29extension/src/extract-live.tsread-2-me75—CLEAN3.43
0.29web/src/lib/server/extract/pdf.tsread-2-me41—CLEAN2.88
0.28web/src/lib/server/tts/fal.tsread-2-me44—CLEAN3.06
0.27shared/src/parse.tsread-2-me123—CLEAN3.15
0.27web/src/lib/server/auth.tsread-2-me31—CLEAN2.69
0.26src/routes/listen/samples/+page.sveltedevagar54—CLEAN2.06
0.26extension/build.tsread-2-me46—CLEAN2.78
0.24web/src/hooks.server.tsread-2-me41—CLEAN2.58
0.23src/lib/listening-series.tsdevagar16—CLEAN2.83
0.23shared/src/index.tsread-2-me26—CLEAN1.94
0.21src/lib/components/AudioSpeed.sveltedevagar16—CLEAN2.80
0.21web/src/lib/server/extract/url.tsread-2-me45—CLEAN3.37
0.19src/lib/audio-samples.tsdevagar44—CLEAN3.47
0.19extension/src/messages.tsread-2-me70—CLEAN2.99
0.17web/src/routes/login/+page.svelteread-2-me55—CLEAN2.82
0.12src/lib/components/Illustration.sveltedevagar25—CLEAN3.64
0.12web/src/lib/server/extract/types.tsread-2-me24—CLEAN3.59
SELECT A FILE
WHAT JEV SAID
WHAT I WROTE BEFORE THE RUN
Pick any row above.
ONE REQUEST, VERBATIMread-2-me:shared/src/timings.ts · 51 LINES · 352 MS

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.

REQUEST · POST api.typesafe.ai/v1/systemoneAUTHORIZATION: BEARER …
{
  "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."
      ]
    }
  }
}
RESPONSE · HTTP 200jev-latest
{
  "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
  }
}
WHAT THIS DOES NOT SHOW

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.