Checkpoint 1 · P2 Content Pass

P2 — sense, fill, and forms: the design calls

P1 — the machinery that writes example sentences and checks their quality — hit its passing bar today. P2 is next: teaching that same proven machinery to do the deeper content work for every word. Everything P1 taught us about running this safely is already locked in below. Five real design questions are still open, and building doesn't start until you've ruled on them.

P1 closed clean today 5 decisions need you 7 ground rules — confirm only Forms↔examples reuse: confirmed
Checkpoints Latest →
The pivot

From "does it work" to "run it on everything"

When P1 closed, the plan for what comes next was put in your own words: “we need to productionize… utilize our learning to optimize the remaining pipeline processes.” In plain terms: P1 spent real time proving that ONE piece — writing example sentences and grading them automatically — actually works and can be trusted. P2 takes everything that process taught us and reuses it to build out everything else a flashcard needs, instead of designing each new piece from a blank page.

You also had a hope for one specific piece: “hopefully form example sentences can leverage examples work already done.” The answer is yes. Word-form example sentences (e.g. the different conjugations or affixed forms of a word) will use the exact same system, same rules, and the same 6–10 sentences per set as regular example sentences — not a separate, smaller version. See Decision Ledger item 1 below.

Confirm-only — nothing to decide here

What P1 already taught us — now locked in as ground rules

These aren't up for debate; P1 proved them out the hard way and P2 inherits them as-is. This list is here as the misread-catcher — flag anything below that doesn't match what you remember locking in.
1
Every new P2 piece goes through the same proven loop before it ships.
Write the spec → write the AI's instructions → an adversarial cross-check of those instructions → build it → run the quality gate → a scoped human review → merge. How much effort each step gets scales with how risky the piece is — but the gate itself never gets skipped.
Locked in by P1
2
Instructions given to the AI read like a professional work order, not a list of shouted rules.
Each requirement is stated once, plainly. Repeating a rule over and over for emphasis doesn't make the AI follow it better — it just adds noise the AI has to wade through.
Locked in by P1
3
Example sentences shown to the AI are format guides only — never content it should copy.
Real sentence-to-sentence variety comes from a separate "seed" mechanism — a bit like a random seed in a game — that's deliberately changed on every single call. This machinery is proven and working; P2's writing prompts plug into it from day one instead of bolting it on later.
Locked in by P1
4
P2 keeps handing the AI the FULL background research for a word — never a trimmed-down version.
We tested trimming that material down to save time and cost. Results got worse, not better, with no upside. So the full material — dictionary entries, related-word data, and real usage examples — stays in every call.
Locked in by P1
5
Automated quality checks each look at ONE thing, and don't get final say alone until proven reliable.
Anything that's simply countable (like sentence length) is checked by fixed code, never AI judgment. Each AI check is scoped to a single quality question. Right now, the same content can get a different verdict on different runs — until that's fixed, these checks advise rather than block alone; a majority vote decides instead.
Locked in by P1
6
The quality bar P1 had to clear also applies to everything P2 produces.
85% of output has to pass with no human touch-up, even after one automatic repair pass. Anything that doesn't clear that bar gets flagged and held for a person to look at — it's never shipped quietly.
Locked in by P1
7
Every category-tag write has to say exactly which category it's writing to.
P2 writes a lot of tags — register, domain, and more — into a shared tag table. A near-miss bug already showed it's dangerous to let the system guess the category from an ambiguous field name. From here on, every write names its target category explicitly, no inference allowed.
Locked in by P1
Decisions ledger

What's already decided vs. what's inferred

The misread-catcher — flag anything here that doesn't match what you meant.
1
Word-form example sentences use the exact same system as regular example sentences — full rules, standard 6–10 sentences per set.
No separate, smaller system gets built for forms. This directly answers your hope, quoted above, that form examples could reuse the work already done on examples.
Decided by Frank
2
P2 ports the OLD content-generation logic into the NEW, quality-gated machinery — it doesn't redesign sense-partition and fill from a blank page.
Inferred from "we need to productionize… utilize our learning to optimize the remaining pipeline processes" — the goal is reusing what already works, not reinventing it.
Inferred from what you said
Your call

Five decisions before P2 starts building

Everything above is locked in or already decided. These five are genuinely open — tap an option, and use the note box for anything that needs more than a letter.
🔗
Natural word-pairs vs. the repetition check. When we generate a batch of example sentences for a word, an automatic check flags the word if too many of its sentences lean on the same neighboring word — meant to catch the AI getting lazy and reusing a phrase. But some pairings ARE just how Indonesian works: turun (go down) almost always shows up next to dari (from), because "get off (a vehicle)" is naturally "turun dari." Right now the check can't tell lazy repetition apart from normal language.
A — give each word (or word + word-type) its own tolerance setting, so some words are simply allowed to repeat a neighbor more than most.
B — build a list of known, legitimate word-pairings straight from data we already have (the compound-word fields in the official dictionary source) and auto-clear anything on that list.
C — do nothing new for now — those sentences just sit in the human-review queue like any other flagged item.
🧩
What makes a meaning worth its own teaching card. Many Indonesian words carry more than one meaning. Something has to decide: does each meaning become its own flashcard, do some get merged into one card, or does a meaning get held back entirely? The old system used a simple rule — a meaning only earns its own card once it shows up often enough across real usage (a "coverage" threshold). Two questions: keep that rule as-is, and separately — what should the automatic checker reviewing these splits actually be checking for?
A — keep the old coverage rule exactly as it is.
B — keep it, and also require that every kept meaning trace back to a real source (a dictionary entry or corpus example), not just a raw frequency count.
C — hold off and redesign this rule in a later phase, once there's more data on how it behaves.
AI recommendation: B. The source data already exists, so this is close to free to add, and it directly extends P1's core lesson — don't guess, show your source.
Use the note box to tell us what the split-checker should actually look for (e.g. "would a fluent speaker call this a genuinely different meaning?").
🔧
Fix one bad sentence, or redo the whole batch? Today, if a batch of example sentences has one bad sentence in it, the system doesn't just fix that one — it throws out and regenerates the ENTIRE batch. We've now seen that backfire twice: regenerating the whole batch to fix one problem sentence broke a different sentence that was already fine.
A — build "fix just the broken one" repair as part of P2. More work up front, but stops good sentences from taking collateral damage.
B — not yet. Keep living with full-batch regeneration and revisit this later.
💸
Cheap bulk processing — design it in now, or bolt it on later? Once P2 is running at real volume, there's a much cheaper way to run the AI generation calls — submitted as one big batch instead of live, one-at-a-time calls, at a lower price. The catch: our mechanism for making sure every sentence set actually looks different from every other one ("seeded variation," proven and working today) isn't wired into that bulk pathway yet. Wiring it in is its own chunk of design work.
A — design that wiring in from day one of P2, so the cheap path is ready the moment volume needs it.
B — start with the simpler, pricier one-at-a-time path first; add the cheap bulk path once the first phase (sense partition, P2a) is proven out.
🗺️
The build order. The proposed order below builds P2 one piece at a time, each one checked and merged before the next starts.
Step 1
P2a
Sense partition — decide which meanings become teaching cards
↓
Step 2
P2b
Fill fields — definitions, glosses, tags, pronunciation package
↓
Step 3
P2c
Forms roster + forms example sentences
↓
Step 4
P2d
Tag writes — register, domain, and other category tags
↓
Step 5
P2e
Cheap bulk processing + the final quality-bar check
✅
Ratify this build order? Each step above ships and gets merged before the next one starts — so a "reorder" answer only changes what gets built first, not whether the check-first process applies to each piece.
A — approve this order as written.
B — reorder it — say what changes in the note.