Skip to content
Japanese Versatility List

Research overview

Japanese acquisition-order research

Versatility list (live): https://ferricelement.github.io/japanese-acquisition-research/

Audio-first, romaji-only, listening/speaking target (~6,000 words). Generated 2026-08-20 by a 12-agent workflow plus a 4-agent recovery run.

Published artifacts:

Files

  • 01-synthesis.json — 11 ordering laws, 21 stages, 10 contested calls, 10 deviations from standard curricula. The core deliverable.
  • 02-completeness-critique.md — adversarial review of the synthesis. Finds the remaining structural gaps: within-stage order absent, the ~35 -te dependents never enumerated, ~25 named items with no scheduled position, the -eru disambiguation broken on 5 of 6 cited pairs, and the steelmanned case that order buys ~20% and input volume buys the rest.
  • 03-phonology-corrections.md — merged output of three adversarial lenses (phonetics, SLA methodology, implementability) against the perceptual-foundation layer. Kills the 20%-inter-mora-variance gate, the 40-trial/90% exit, and the six-TTS-voices = high-variability-training assumption.
  • 04-phonology-analysis.json — the original perceptual-foundation analysis those corrections apply to (25 units, 8 principles).
  • 05-acquisition-order.html — source of the published artifact.

Known open items

  1. Emit the full ordered ledger (one row per item, index + gate + interference partner). The 60-verb ledger is done and lives in the artifact; the ~180 nouns, ~60 adjectives, the 35 -te dependents, and the 140-item exit battery are still unenumerated.
  2. Reconcile the -eru separation (5 weeks) with the kango homophone window (200 items = 10 days at N=20). Currently inconsistent.
  3. Re-derive the daily braid under the concession that input volume dominates order.

Round 2 — the ledger (2026-08-20, later)

Published: the item ledger

  • 10-list-nouns.json — 180 nouns, sorted by special-mora load ascending, accents + glosses
  • 11-list-adjectives.json — 63 adjectives, class-tagged, sorted by the stage-10 induction gate
  • 12-list-te-dependents.json — 65 nodes: 33 true -te dependents ranked by fanout x frequency, 8 on the -ta branch, 13 IMPOSTORS that take the i-stem, 6 homophone collisions
  • 13-list-exit-battery.json — 140 items with stimuli, allocated by expected error mass
  • 14-input-rebalance.md — the big one. The coverage gate, not the card budget, caused the input starvation. Repealing it frees ~50 min/day at every phase. 2.9x listening at month 9.
  • 15-separation-rule.md — interval(i) >= [R/(1-R)] * c * k. Cue overlap is direction-specific: homophones are a listening problem, near-synonyms a speaking problem. Plus the real -eru collision inventory: 14 live, 4 blocked, ~30 that never needed separating.
  • 16-verifier-findings.json — 116 findings (18 fatal, 51 major, 47 minor)

Fix these before recording any TTS

  1. -te chant has no ichidan row (taberu > tabete) and no irregular row (suru/kuru). Add R0, R6.
  2. Voiced allomorphs missing everywhere: -jau, -yondoku, -yondara, -yonja dame.
  3. Adjective list omits the i-adjective nai.
  4. Battery writes sensei/kirei — must be sensee/kiree. Global -ei- sweep needed.
  5. Noun list: separate te/me, kippu/koppu; flag soba and kawa as accent-identical homophones.
  6. au is [1] not [0], which breaks the atte/atte pitch-separation claim.

Still open

  • The ~47 minor verifier findings are unapplied.
  • Noun ordering variable does no work over items 1-120; restate as a partition, not a sort.
  • Within-stage ordering exists now for stage 17 only (in 15-separation-rule.md).

Round 3 — the versatility list (2026-10-01)

Published: single-page version (the live site above replaces it)

  • 20-list-versatile.json — 484 items, 113 chunks, 4 stages. The words, endings and patterns that work in almost any conversation: time & sequence, degree, stance, adjectives, connectors, sentence endings, responses & set phrases, general verbs, grammar patterns, ko/so/a/do & question words. Casual form is the headword (romaji); the desu/masu counterpart sits beside it (polite). Every item has a casual and a polite example sentence (romaji, ja, english). Romaji uses kotoba’s stored spelling (sou, daijoubu, kotchi), not the soo/kiree style above.
  • Frequency: freqRank = rank in jiten.moe’s drama-subtitle list (3,030 TV dramas, CC BY-SA 4.0). Contractions are split by its tokenizer; freqNote says what was looked up instead. 31 items have no usable rank.
  • Built by an 85-agent workflow: per-category harvest (662) → 3 rounds of gap hunting (pool 1,049) → 3-judge selection → write → naturalness / nuance / form review → fix → cross-category consistency → course order. The panel cut the relative time words (asa, raishuu, kotoshi…) and several endings (darou, n da yo, -te ne, sa/wa/zo/yo na); those were restored through the same write+review steps.
  • cuts in the JSON lists the 561 candidates that didn’t make it, each with a verdict (covered / skip) and reason.
  • 2026-10-02: a second review of all 621 cuts (per-category reviewer + usage and redundancy checks) re-added 33 clear gaps, 10 strong maybes and boku (atsui, samui, itai, kirei, otsukare, oyasumi, hisashiburi, tetsudau, okureru, -you ni, the passive…). Most joined existing chunks; 8 existing items got small edits so the new partners pair up (existing-edits in the merge step).
  • Item ids (A-ima, J-kotchi) are stable keys; prereqs are item ids, all pointing backward in course order.
  • 2026-10-02 (later): the remaining 16 maybes were added at the learner’s request (nakanaka, douse, nigate, hazukashii, nagai, abunai, -kawari ni, wake nai, moshimoshi, bikkuri shita, ki o tsukete, ireru, tariru, okoru, -sasete, dou iu). All joined existing chunks; 12 chunks now sit at the 6-item maximum.

The site

The live site is an Astro Starlight project at the repo root. It builds every page from 20-list-versatile.json: each of the 113 chunks is a short page (/stages/<n>/<chunk>/) listing its items in full, and the sidebar groups them by stage in course order so Next walks the course. Stage and category pages are tables of contents; the cuts are split by category; the research notes above are pages too. src/lib/data.ts loads the list, src/components/ renders items and chunk lists, src/pages/ holds the routes, and src/content/docs/index.mdx is the home page. Pushing to main deploys it through .github/workflows/deploy.yml.

Terminal window
npm install
npm run dev       # http://localhost:4321/japanese-acquisition-research/
npm run build     # static site + search index in dist/

Rebuilding the data

versatility-build/ holds everything 20-list-versatile.json is generated from: the workflow outputs (result.json, additions-result.json, readds-result.json, maybes-result.json), the cuts review (cuts-full.json, cuts-verdicts.json), stage placement for added chunks (placement.json), edits to existing items (existing-edits.json) and the merge script. It also writes artifact.html, a single-page version for the claude.ai artifact. workflow-main.js is the original 75-agent workflow script, kept for reference.

Terminal window
cd versatility-build && python3 merge.py

freq.py looks words up in the jiten.moe drama frequency list, which is not committed (CC BY-SA 4.0, 7.8 MB):

Terminal window
curl -L -o versatility-build/jiten_freq_Drama.csv "https://api.jiten.moe/api/frequency-list/download?mediaType=Drama&downloadType=csv"

Round 4 — collocations (2026-10-03)

  • 21-list-collocations.json — 405 noun + verb (or noun + adjective) sets that Japanese speakers use together: ame ga furu, kaze ga fuku, doa o akeru, hon o yomu, te o arau, kaze o hiku, the wearing verbs, se ga takai. 13 topics, 94 chunks, 4 stages of ~100 that run alongside the versatility list’s stages (Stage N collocations are learned during Stage N). Same shape as the versatility list: casual headword, polite form beside it, casual and polite examples. Extra fields: the parts (noun, particle, verb + verbSense), measured (corpus counts), trap (the mistake English leads you to, or null), englishVerb, partners, listLinks.
  • Selected on commonness and typicality, at the learner’s direction: guessable sets belong if people say them all the time; a trap is a note, never a reason to keep or cut.
  • Measured in OpenSubtitles 2018 Japanese (3.17M subtitle lines, via OPUS), tokenized with fugashi + unidic-lite: every noun + particle + verb/adjective pair counted on dictionary forms (particle dropped or not), plus adjective + noun. measured.count = occurrences; measured.shareN = typicality (the share of everything said with the noun that goes to this verb). 357 of 405 have counts. The corpus is mostly subtitles for foreign films, so it over-counts plot lines (keisatsu o yobu) and under-counts Japanese daily life (kasa o sasu, warikan); native judgement corrects for that, and the site says which sets rest on judgement.
  • Built in four workflow runs: the first list (595 candidates by topic and gap hunts); a corpus mining pass (the 1,848 most frequent typical pairs sorted into collocation / idiom / grammar / suru verb / free / film / artifact: 520 new sets, 175 idioms saved); a re-selection on commonness (208 sets); and an expansion to 405 (a second gap hunt found 319 more candidates, 200 added). Every new entry was reviewed four ways (native naturalness, whether each trap is really a mistake, meaning and register, romaji and data). Hand edits: kaze ga fuku restored (the learner asked for “wind blows”), and five split pairs given back their other half (megane o hazusu, shiai ni makeru, mise ga shimaru, denki ga tsuku, kagi ga kakaru) — see edits.json.
  • cuts lists every candidate left out with a verdict (maybe / covered / less-common / narrow / film / not-a-collocation / idiom), a reason and its count.
  • On the site: /collocations/ (overview, by topic), /collocations/<n>/<chunk>/, By verb, By English word, Cuts. Each main-list stage page links its stage’s collocations.

Rebuilding the collocations

collocations-build/ holds the workflow outputs (result.json, reselect.json, expand.json), the candidate tables, hand edits (edits.json), the workflow scripts (*.js, for reference) and the counting tools. The corpus and the tokenizer are downloaded, not committed:

Terminal window
cd collocations-build
curl -L -o corpus/ja.txt.gz https://object.pouta.csc.fi/OPUS-OpenSubtitles/v2018/mono/ja.txt.gz
python3 -m venv .venv && .venv/bin/pip install fugashi==1.5.2 unidic-lite==1.0.8
.venv/bin/python count.py      # corpus/pairs.tsv: every noun + verb pair, ~10 s
python3 merge.py               # ../21-list-collocations.json

count_cli.py pair <noun> <verb> and count_cli.py phrase <forms...> count a single set; measure.py is the shared lookup (it matches the tokenizer’s readings and the written forms, since it reads 家 as ie and 開く as hiraku).

Round 5 — idioms (2026-10-03)

  • 22-list-idioms.json — 365 Japanese idioms in their own right: kanyouku (te o kasu, atama ni kuru, ki ga au, kao ga hiroi, saba o yomu, goma o suru) plus the sayings (saru mo ki kara ochiru) and four-character phrases (isseki nichou, jigou jitoku) that people really say. Chosen on how commonly they are said in Japanese — whether English has an equivalent plays no part. 7 topics by meaning, 86 chunks, 4 stages of ~90 alongside the main stages.
  • Fields as in the other lists, plus literal (word for word), english (what it means) and englishIdiom (a close English idiom, only as a note, when a natural one exists). Flags include saying and four-character.
  • Measured in the same subtitle corpus: noun + verb idioms by their pair (any inflection, particle or none) when the written forms account for at least half of it, otherwise by their written forms (measure_idioms.py); 354 of 365 have counts.
  • Built in three workflow runs: a harvest by source with gap hunts (758 candidates); a wider gap hunt (sayings, four-character phrases, idioms without body parts, everyday situations, the corpus: 1,479 more), a three-judge selection on commonness (~260), writing, four reviews per topic and chunking; and a vetting run, because the fix step had added 169 idioms nobody selected — three judges voted (113 kept), the kept ones were reviewed four ways, and every topic was re-chunked and the course re-ordered.
  • cuts lists every candidate left out with a verdict (maybe / covered / less-common / bookish / literal / single-word / narrow) and a reason.
  • On the site: /idioms/ (overview, by topic), /idioms/<n>/<chunk>/, Cuts. Each main-list stage page links its stage’s idioms.

Rebuilding the idioms

Terminal window
cd idioms-build
python3 measure_idioms.py   # harvest.json -> candidates.json / .tsv with corpus counts (needs the corpus above)
python3 merge.py            # result.json + vet.json -> ../22-list-idioms.json

Round 6 — collocation listening scripts (2026-10-04)

  • exercises/collocations/collocation-scripts.json — 94 listening scripts, one per collocation chunk in course order: a short scene (1,580 lines in all) where the chunk’s collocations are each heard at least twice (300 of the 405 three times or more), plus 235 uses of earlier chunks’ collocations for review. Same format as the Stage 1 stories: speaker, romaji, ja, kana (for a voice that misreads a kanji), english, and uses (the collocations in that line). A fixed cast of eight with fixed voice notes (build/conventions.md), so the audio stays consistent.
  • 499 quiz questions: a gist question per script, then one per collocation — heard (which phrase was said; the wrong options are the English-speaker calques, like kekka o morau for kekka o dasu), meaning, and respond (a character says a cue line and you answer out loud with the collocation; 224 of them, at least half of each script’s collocation questions). Each has an explanation citing the lines.
  • exercises/collocations/stage-<n>.md — the same scripts as readable pages: what each teaches, the audio script, questions, new words, then answers and the romaji transcript behind a fold.
  • Built by workflow: three pilot scripts written, reviewed three ways (native naturalness, data accuracy, quiz quality), fixed and rechecked; 78 drafts from a stopped full run plus 13 new ones, then one reviewer per four scripts returning field edits (92 applied). One hand edit (build/hand-edits.json: Kenji calls his sister neechan). Code checks on every script: structure, each collocation heard twice and tested once, romaji against the kana reading (build/checks.py).

Rebuilding the scripts

Terminal window
cd exercises/collocations/build
python3 make_briefs.py                      # 21-list-collocations.json -> briefs/, briefs-slim/, index.json
python3 merge.py run-pilot.json             # store the pilot's scripts (workflow output), then check
python3 apply_edits.py run-lean.json        # lean run: drafts/ + written scripts + review edits -> merge
python3 build_md.py                         # ../collocation-scripts.json -> ../stage-<n>.md
python3 recover.py <journal.jsonl> out.json # rebuild results from a run that didn't finish

Round 7 — core words, word sets, set phrases, conjugations (2026-10-16)

Four more lists, built to fill what the first three don’t teach. Before this round the versatility, collocation and idiom lists covered 58% of the 1,000 most frequent words in the drama list and 42% of the top 2,000; with these four they cover 89% and 82% (wordlists-build/coverage.py; what’s left is mostly grammar fragments, names, laughs and crime-plot words).

  • 23-list-core.json — 1,204 everyday verbs, nouns, adjectives, adverbs, mimetics and connectors the other lists don’t teach, in 34 meaning topics and 290 chunks. Stages are by frequency: half of Stage 1’s words rank in the top ~1,000 of spoken Japanese, Stage 4’s in the top ~3,800.
  • 24-list-sets.json — 381 words in closed sets learned whole: numbers with their sound changes, counters (one entry per counter, irregular readings listed), clock time, days, dates, months, years and age, family (own vs someone else’s), body, position, pronouns, colours, seasons, tastes, countries. Sets stay complete even where the main list has a member.
  • 25-list-phrases.json — 416 set phrases: greetings and home rituals, thanks and apologies, polite formulas, shopping, eating out, what staff say to you, phone and meeting up, sympathy, celebrations, reactions, trouble. role says whether you say it or mostly hear it; count is how often the phrase came up in the subtitle corpus.
  • 26-list-conjugations.json — 60 verb and adjective forms and rules plus 63 grammar patterns. Each form has a table built by rule (conjugate.py: 13 model verbs covering every class and -te sound change, or takai / ii / kirei / a noun) and measured: how often the form occurs in the subtitle corpus as a share of all verbs or adjectives (conj_tag.py tags the corpus once, conj_forms.py maps endings to forms; potential and -yasui can’t be picked out).

Same entry shape as the other lists (casual headword, polite beside it, casual and polite examples), so the site renders them with one set of routes: /core/, /sets/, /phrases/, /conjugations/ (src/pages/[list]/, src/lib/wordlists.ts).

How it was built

  1. Code: the 5,000 most frequent words in the drama list, minus what the older lists teach (by written form and lemma), tagged by part of speech: 3,477 candidates (pool.py).
  2. Selection workflow (9 agents, select-workflow.js): seven judges routed every candidate to core / set / phrase / pattern / cut with a 1-5 everyday-commonness score, correcting the drama skew; one agent listed 369 everyday words the drama list under-counts (home, food, clothes, the doctor’s, mimetics); one harvested 320 set phrases. select_merge.py keeps score 4+, or 3 when the word ranks in the top 3,000 or came from the everyday hunt. Hand restores after reading the cuts: fune, inochi, hikari, tazuneru.
  3. Writing workflow (31 writers, write-workflow.js): about 68 core words, 86 phrases or one group of sets per writer, each writing entries and meaning-first chunks of 4-5. Writers save their entries to written/ in parts of 20 (a first attempt returning everything in one reply stalled).
  4. Code checks (checks.py): headword romaji against its kana (romaji.py, kotoba spelling), each example’s romaji against the tokenizer’s reading of its Japanese, chunk sizes, duplicates. merge.py drops a word that appears twice or that an older list already teaches.
  5. Review workflow (12 reviewers, review-workflow.js): one native-speaker review per ~200 entries, returning field edits only; 263 edits and 9 drops applied. Every entry was read by a reviewer (review_coverage.py checks the transcripts).
Terminal window
cd wordlists-build
../collocations-build/.venv/bin/python pool.py 5000       # pool.json from the drama list (needs jiten_freq_Drama.csv)
python3 select_merge.py                                   # select-result.json -> selected.json, select-cuts.json
python3 write_batches.py                                  # fresh runs only: re-slices write/*.json, which must match written/
python3 collect_written.py && python3 merge.py            # written/ + review results -> ../23-26 list files
../collocations-build/.venv/bin/python checks.py          # flags.json
../collocations-build/.venv/bin/python conj_tag.py        # corpus-tails.tsv (needs the subtitle corpus), then conj_forms.py

Conversation pass (2026-10-19)

The first version ranked by how common things are in general, which put shopping, eating out and staff phrases near the front. The learner’s goal is to sustain casual conversation, with small talk, getting to know someone and saying what you think above everything else, so all four lists were re-ordered around that:

  • Every entry has cv (conversational value, 1-5, judged) and focus (it serves small talk, getting to know someone or trading opinions). Chunks are staged by tier: Stage 1 is focus chunks and cv 3.5+, then 3.0+, then 2.5+. Core words below that go to a last stage, Errands, chores and formal; sets and conjugations just learn that tier last.
  • The phrase list became Conversation phrases, organised by the moves of a conversation: getting to know you, likes and free time, what do you think, small talk, then reacting, asking and following up, agreeing and disagreeing, telling what happened, feelings, plans, clarifying, teasing, changing the subject, greetings between friends. 349 new phrases came from three hunts for those moves (where you’re from, what you do, why Japan, hobbies, food, “dou omou?” …), written, reviewed once and chunked by move. The shopping, restaurant and staff phrases are kept, in a last stage, Errands and service. 765 phrases in all.
  • Hand edits: the numbers 0-10 and people counts are marked focus (age, family size and “how long have you been here” need them).

Built by conversation-workflow.js (5 cv judges, 2 phrase hunters), focus-workflow.js (3 focus judges, 1 hunter for the top-tier moves), the writers in write-workflow.js, and chunk-workflow.js (chunkers per group of moves plus reviewers of the new phrases). Code: cv_merge.py (scores -> cv.json, hunted phrases -> hunted.json + writer batches; run once, it keeps the hunt unless given --rehunt), chunk_batches.py, chunk_merge.py, then merge.py as before.

All files