Jev names the missing data structure 98% of the time, and its 0–4 match score separates clean code from smelly by 1.29 points

{
  "state": {
    "context": "Product page on an ecommerce website",
    "code": "public setProductDisplayType(displayType: string): void {\n    if (displayType === \"compact\") {\n        this.maxDescriptionLength = 140;\n        this.numSimilarProductsToShow = 2;\n        this.numReviewsToShow = 1;\n    } else if (displayType === \"detailed\") {\n        this.maxDescriptionLength = 500;\n        this.numSimilarProductsToShow = 5;\n        this.numReviewsToShow = 7;\n    }\n}",
    "notes": "`code` is representative, not complete. Judge the shape of the data, not missing error handling, naming style or tests."
  },
  "model": "jev-latest",
  "questions": {
    "verdict": {
      "type": "choice",
      "instructions": "Is there a data structure waiting to break out of this code? Say in one sentence how `code` works — `plain_english_sentence` gives that sentence when it is present — then check whether every concept the sentence names is a type in the code. Where a concept the sentence needs is carried as loose parts, that concept is a data structure waiting to break out. Pick the shape it takes, or `no_structure` if the code already carries every concept its sentence 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."
        },
        "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 severity setting colour, icon and repage delay"
          ]
        },
        "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",
            "Map<UserId, string> beside Map<UserId, Role> written and deleted together"
          ]
        },
        "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 version string re-split by every function that compares versions"
          ]
        }
      }
    },
    "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."
      ]
    }
  }
}

{
  "model": "jev-1.13.0",
  "answers": {
    "verdict": {
      "type": "choice",
      "choice": "branch_table",
      "confidence": 0.99,
      "probabilities": {
        "branch_table": 1.0,
        "stringly_encoded": 0.0,
        "tandem_params": 0.0,
        "parallel_collections": 0.0,
        "no_structure": 0.0
      }
    },
    "tandem_params": {
      "type": "noul",
      "noul": 0.6
    },
    "branch_table": {
      "type": "noul",
      "noul": 0.89
    },
    "parallel_collections": {
      "type": "noul",
      "noul": 0.17
    },
    "stringly_encoded": {
      "type": "noul",
      "noul": 0.09
    },
    "plain_english_match": {
      "type": "score",
      "score": 1.9,
      "confidence": 0.46,
      "legend": {
        "0": "The reader must rebuild every concept from loose parts: values travel in groups, records live inside strings, collections share an index.",
        "1": "One concept the sentence names exists as a type; the rest are carried as loose parts.",
        "2": "The main concept exists as a type, but several of its parts are still passed or stored separately.",
        "3": "Nearly every concept the sentence names is a type; one small group of values is still loose.",
        "4": "Every concept the sentence names is a type in the code, and every type is a concept in the sentence."
      },
      "probabilities": {
        "0": 0.07,
        "1": 0.24,
        "2": 0.54,
        "3": 0.04,
        "4": 0.11
      }
    }
  },
  "usage": {
    "input_tokens": 1625,
    "output_tokens": 156
  }
}

Paired by case: both right 78, right only without the reference 0, right only with it 2, both wrong 0.

The classification gain is two cases out of 80 — small, and both in the hard tier. The real change is the match score: smelly code drops from 2.00 to 0.72 while clean code stays put, so the rank AUC goes to 1.00. Reading the rule makes the model harsher about loose parts without making it suspicious of clean code. That is the opposite of what the same technique did on the MIRO tab, where the reference only moved the bias.

THE PLAIN ENGLISH TEST, AND DATA STRUCTURES WAITING TO BREAK OUT.

Say in one sentence how the code works. Then read the sentence and the code side by side.
Every noun in the sentence should be a type in the code, and every type in the code should
be a noun in the sentence. Where the sentence names a concept the code does not have, that
concept is a data structure waiting to break out. This is the Embedded Design Principle:
design decisions should be visible in the code, not reconstructed by the reader.

Asked what data defines a rectangle, almost nobody says four integers. They say a corner and
a size. A constructor taking four numbers therefore fails the test twice: it does not match
the sentence, and it allows 24 argument orderings of which 23 are wrong.

FOUR SHAPES THE MISSING STRUCTURE TAKES

1. VALUES THAT TRAVEL TOGETHER. The same two, three or five parameters appear in signature
   after signature, always in the same order, always from the same source. Fields with a
   shared prefix (shipLine1, shipCity, shipCountry / billLine1, billCity, billCountry) are
   the same thing with the type spelled into the names. The fix is one type holding them.

2. A CONDITIONAL THAT ASSIGNS A TUPLE OF CONSTANTS. Each branch writes the same set of
   fields with different constants. The branches are rows of a table and the tuple is the
   type. Replacing the strings with an enum, or the if-chain with a switch, renames the
   conditional; passing a record containing the tuple removes it. A default branch that
   assigns real-looking values is the sign that the missing type would have made a gap
   explicit.

3. COLLECTIONS INDEXED IN LOCKSTEP. Two arrays with a shared index, or two maps with a
   shared key, written together, deleted together and read together. Any operation that
   reorders or removes must be performed once per collection, and the day one is forgotten
   the data is silently wrong. The row is the type.

4. A RECORD PACKED INTO A STRING, A FILENAME OR A BITFIELD. "paid|2026-01-03|card",
   "user:42:posts:page3", IMG_20260102_083000_lisbon.jpg, flags |= EXPORT. Every reader
   splits it again with its own parsing, every writer rebuilds it by hand, and the format is
   defined by whichever function last touched it. Parse once at the edge into a real type.

WHAT IS NOT A MISSING STRUCTURE
   Code whose types already match its sentence, even when it is short, mutable, or could be
   faster. A discriminated union with one branch per case in the sentence is the goal, not a
   smell. Judge the shape of the data, not the naming, the error handling or the tests.