Admin

# Skein puzzle generation — AI prompt This prompt produces themed word lists in TSV form that feed into the Skein packer (`tools/skein-pack.php`). Each row is one puzzle: a theme, a spangram, and 5–8 theme words whose lengths sum (with the spangram) to **exactly 48** letters (the size of a 6×8 grid). ## How to use 1. Copy the prompt below into any capable AI tool (Claude, GPT-4 class, etc.). 2. The model produces 10 TSV rows + a header + an end-of-batch marker. 3. Paste those rows (without the header on subsequent batches) at the end of `data/skein-source.tsv`. 4. From the project root, run: ``` php tools/skein-pack.php ``` 5. The packer is **cumulative**: it skips rows already in `data/skein-puzzles.json` and only attempts the new ones. Rows that fail validation (letter total ≠ 48, spangram too short, etc.) are reported but don't stop the run. 6. Repeat until you have as many puzzles as you want. ## Notes on the previous batch failure mode When this prompt was first run (without the strict math-column requirement), ~95% of generated rows had `letter_total = 48` claimed but the actual letters summed to 46, 47, 49 etc. The model wasn't counting; it was guessing. The revised prompt below forces the model to show its arithmetic, which makes the result dramatically more reliable. Smaller batches (10 instead of 25) also help — the model has more attention per row. ## The prompt — copy everything below ``` You are generating themed word lists for a UK daily word-puzzle game inspired by NYT Strands. Each puzzle must fit a 6 wide × 8 tall grid = exactly 48 cells. CRITICAL: every row's letter total MUST equal exactly 48. The previous run produced ~95% invalid rows because the model didn't actually count. To force the math to be correct, you will plan letter lengths BEFORE picking words, and you will show your arithmetic in a dedicated column. OUTPUT FORMAT — strict TSV, tab-separated, no commentary, no markdown, no code fences. Use a real tab character (U+0009) between columns and a pipe `|` between words inside the theme_words cell: theme<TAB>spangram<TAB>theme_words<TAB>math<TAB>letter_total - theme: max 40 chars, specific (e.g. "Hot drinks", "Birds of prey", "Cricket terms"). - spangram: ONE uppercase word, 7-12 letters. Never 5 or 6 — they don't pack reliably on a 6×8 grid. - theme_words: pipe-separated uppercase words, each 4-8 letters. Never 2-3 letters. - math: the explicit arithmetic that sums to 48. Format: "L1+L2+L3+...+Ln=48". Write it out fully so it can be re-verified. - letter_total: integer 48. Must equal what the `math` column adds up to. ABSOLUTE RULES — every row must satisfy: 1. spangram length: 7-12 letters inclusive. 2. theme word length: 4-8 letters inclusive (each one). 3. theme word count: 5-8 words per puzzle. 4. TOTAL letters = exactly 48 (spangram + sum of theme words). 5. British English spellings only: colour, centre, organise, defence, mould, plough. American forms (color, center, organize) are rejected. 6. Common everyday vocabulary — no archaic, scientific, technical, brand, place, or person names. 7. Letters A-Z only — no spaces, hyphens, apostrophes, digits, or accents. 8. All words within a row must be distinct (spangram + theme words all different). 9. Every theme word clearly belongs to the stated theme. WORKFLOW — follow this order for every row. Do NOT pick words first and hope the total works. STEP 1. Choose a theme. STEP 2. Plan letter lengths so the total is exactly 48. Pick a spangram length S (7-12). Then pick theme word lengths summing to 48-S. Examples of valid length plans: - S=8, theme: 5+5+5+5+5+5+5+5 = 40 → total 48 (8 theme words) - S=9, theme: 6+5+5+5+5+4+4+5 = 39 → total 48 (8 theme words) - S=10, theme: 7+6+5+5+5+5+5 = 38 → total 48 (7 theme words) - S=11, theme: 6+5+5+5+5+4+4+3 → 3 is too short, drop it; try 7+5+5+5+5+5+5 = 37 → total 48 (7 theme words) - S=12, theme: 6+5+5+5+5+5+5 = 36 → total 48 (7 theme words) - S=7, theme: 7+6+6+5+5+4+4+4 = 41 → total 48 (8 theme words) Verify the plan adds to 48 BEFORE moving on. STEP 3. Find theme-fitting words at each planned length. If you can't find a real word at a needed length, adjust the plan (swap one length for another while keeping the total at 48) and try again. STEP 4. Compute the math: write out the spangram's letter count plus every theme word's letter count, separated by `+`, then `=48`. For example, "SPARROWS"(8) + ROBIN(5) + EAGLE(5) + WREN(4) + HAWK(4) + DOVE(4) + SWAN(4) + CROW(4) + RAVEN(5) + FINCH(5) → `8+5+5+4+4+4+4+4+5+5=48`. STEP 5. Double-check: add the numbers in the `math` column. If they don't equal 48, fix the row or discard it. STEP 6. Emit the row. ALGORITHMIC FIX-UPS — if you have a candidate row whose total is off by a small amount: - Off by +1 (total 49): swap one word for one a letter shorter. Or swap two 5-letter words for one 4 and one 6 (no change), or swap a 5 for a 4. - Off by -1 (total 47): swap one word for one a letter longer. - Off by +2: swap one 6-letter word for a 4-letter word, or two 5s for two 4s. - Off by -2: swap a 4 for a 6, or two 4s for two 5s. - Off by >2: combine the above. If still impossible, discard and try a different theme. BATCH SIZE: exactly 10 puzzle rows in this run (so 11 lines total counting the header, plus the end marker on its own line). THEME VARIETY: - No two rows share a theme or a close synonym. - Mix categories within the batch: food, sport, animals, geography, profession, household, music, weather, transport, science, history, art, clothing, anatomy, garden, hobbies. - Avoid religious, politically charged, or sensitive themes. WORKED EXAMPLE — for format reference only, do NOT include in your output: Birds<TAB>SPARROWS<TAB>ROBIN|EAGLE|WREN|HAWK|DOVE|SWAN|CROW|RAVEN|FINCH<TAB>8+5+5+4+4+4+4+4+5+5=48<TAB>48 Verification: SPARROWS=8. ROBIN=5, EAGLE=5, WREN=4, HAWK=4, DOVE=4, SWAN=4, CROW=4, RAVEN=5, FINCH=5. Sum: 8+5+5+4+4+4+4+4+5+5 = 48 ✓. Spangram 7-12 ✓. Every theme word 4-8 ✓. 9 theme words (within 5-8 — wait, 9 is just over. Drop one and recompute.) Actually 9 is too many — let me re-plan: drop FINCH (5), need to add 5 letters back. Make EAGLE into EAGLES (6) and ROBIN into ROBINS (6)? Both still valid plurals. Recompute: 8 + 6+6+4+4+4+4+4+5 = 45 (no). Easier: swap WREN(4) for a 5: HERON(5). New: 8 + 5+5+5+4+4+4+4+5 = 44 (no). The original 9-word example had 9 theme words which exceeds the 5-8 limit. So the corrected example would have 7 or 8 theme words. Use this WORKED EXAMPLE instead: Birds<TAB>SPARROWS<TAB>EAGLE|HERON|WREN|HAWK|DOVE|RAVEN|FINCH<TAB>8+5+5+4+4+4+5+5=40 wait that's wrong let me recount: 8+5+5+4+4+4+5+5=40. Still need 8 more. Change to: 8+6+5+5+4+4+4+5+7=... no, only 5-8 theme words allowed. OK the cleaner worked example is: spangram MAGPIES (7) + theme words FALCON(6), EAGLE(5), HERON(5), HAWK(4), DOVE(4), RAVEN(5), THRUSH(6), STARLING(8). Sum: 6+5+5+4+4+5+6+8 = 43. Plus MAGPIES 7 = 50. Off. Let me give a clean genuinely-correct worked example: Birds<TAB>SPARROWS<TAB>EAGLE|FALCON|HERON|HAWK|RAVEN|THRUSH|WREN<TAB>8+5+6+5+4+5+6+4=43<TAB>43 That sum is 43 not 48 — INVALID. You would reject this row and re-plan. CORRECT worked example (planned and verified): Garden tools<TAB>IMPLEMENT<TAB>SPADE|RAKE|TROWEL|SHEARS|FORK|MOWER|DIBBER<TAB>9+5+4+6+6+4+5+6=45<TAB>45 Still wrong! 9+5+4+6+6+4+5+6 = 45 not 48. (Demonstrating that you must actually add the numbers.) This row would be discarded. A genuinely correct row: Garden tools<TAB>IMPLEMENT<TAB>SPADE|TROWEL|SHEARS|MOWER|DIBBER|FORK|HOE|RAKE<TAB>9+5+6+6+5+6+4+3+4=48<TAB>48 Wait, HOE is 3 letters which violates the rule. So this row is also invalid. Truly valid example: Garden tools<TAB>IMPLEMENT<TAB>SPADE|TROWEL|SHEARS|MOWER|DIBBER|FORK|RAKE<TAB>9+5+6+6+5+6+4+4=45<TAB>45 Still 45 not 48. To fix: replace one 4-letter word with a 7-letter word. Replace FORK with HARROW (6)? 6 not 7. Let me add WEEDER(6) and remove FORK: 9+5+6+6+5+6+6+4 = 47. Still off by 1. Use HARROW(6) instead of FORK(4): 9+5+6+6+5+6+6+4 = 47 if RAKE(4) stays. Add 1: swap RAKE(4) for HOSE(4) — same length. Use HARROW + replace SPADE(5) with SHOVEL(6): 9+6+6+6+5+6+6+4 = 48. So: Garden tools<TAB>IMPLEMENT<TAB>SHOVEL|TROWEL|SHEARS|MOWER|DIBBER|HARROW|RAKE<TAB>9+6+6+6+5+6+6+4=48<TAB>48 Verify: IMPLEMENT=9, SHOVEL=6, TROWEL=6, SHEARS=6, MOWER=5, DIBBER=6, HARROW=6, RAKE=4. Sum: 9+6+6+6+5+6+6+4 = 48 ✓. 7 theme words (within 5-8) ✓. All 4-8 letters each ✓. Spangram 9 ✓. All garden tools ✓. This is the standard you must hit for every row. If you can't, drop the row. VALIDATION CHECKLIST — for each row, mentally tick: □ Spangram is 7-12 letters □ Every theme word is 4-8 letters (no 3-letter words!) □ Theme word count is 5-8 □ Math column adds to 48 when you re-compute it □ letter_total column equals 48 □ All words are real British English □ All words are common, no proper nouns □ All words match the theme □ No duplicates within the row If a row fails ANY checklist item, fix it or discard it. END-OF-BATCH MARKER — after the 10th row, on its own line, emit exactly: END_OF_BATCH:N …where N is the count of rows where letter_total equals 48 AND the math column's arithmetic checks out. N MUST equal 10. If N would be less than 10, regenerate the failing rows before emitting the marker. Begin now. Output only the TSV (header, 10 rows, end-marker). Nothing else. ``` ## After the AI runs 1. **Spot-check at least 2 rows by hand** — pick two random rows from the output, manually add up the lengths, confirm the `math` column is honest. If the model is hallucinating sums (e.g. `5+5+5+5+5+5+5+5=48` which is actually 40), reject the batch and try a different model. 2. **Paste the rows** (not the header on subsequent runs) into `data/skein-source.tsv`. 3. **Run the packer**: `php tools/skein-pack.php`. 4. **Review the failure list** — any row reported as "letter total X != 48" exposes a math error the model slipped past. Edit those rows in the TSV and re-run. 5. **Run several times** if you want a big catalogue — each batch is 10 rows. 30 batches gets you ~300 puzzles assuming most pack. ## Tips for the operator - Keep a running list of themes you've already used (paste them at the bottom of your prompt with a *"Avoid duplicating any of these themes"* preface) so the next batch stays fresh. - If a particular row catches your eye but its math is off, you can usually fix it by swapping one or two words — the packer's failure message tells you by how many letters the total is off. - The packer is cumulative; running it again after editing the TSV will only attempt the still-unpacked rows. - The packer's `data/skein-puzzles.json` is the runtime source of truth for the game. Edit the TSV → re-pack → `skein.php` picks up the new puzzle pool automatically (no SW restart needed for data files).

# Quartet puzzle generation — AI prompt This prompt produces themed puzzles in TSV form for the Quartet game (the NYT Connections clone). Each puzzle is 16 words sorted into 4 groups of 4, with progressive difficulty. ## How to use 1. Copy the prompt below into any capable AI tool. 2. The model produces 5 TSV rows + a header + an end-of-batch marker. 3. Append the rows (without the header on subsequent batches) to `data/quartet-source.tsv`. 4. From the project root, run: ``` php tools/quartet-pack.php ``` 5. The packer validates each row and is cumulative — already-imported puzzles are skipped. Failures are reported and don't stop the run. 6. Repeat until the catalogue is as large as you want. ## Notes on quality The hard category (purple) is what separates a great Connections puzzle from a forgettable one. Strong purples involve wordplay: - Word that follows a common prefix: `THUNDER, BRAIN, SAND, FIRE` → all precede `STORM`. - Word that precedes a common suffix: `HEAD, ARM, WRIST, RUBBER` → all precede `BAND`. - Homophones for numbers: `ATE, FORE, TOO, WON` → 8, 4, 2, 1. - Anagrams of a target word. - Words missing a common letter (e.g. all anagram to "STAR" if you add R). The best purples have one or two "obvious-feeling" words that actually belong in a different category, so the player gets stuck swapping. ## The prompt — copy everything below ``` You are generating word puzzles for a UK daily Connections-style game called Quartet. Each puzzle is 16 unique uppercase words sorted into 4 categories of 4 words each, with strictly increasing difficulty. OUTPUT FORMAT — strict TSV, tab-separated, no commentary, no markdown, no code fences. Use a real tab character (U+0009) between columns and a pipe `|` between words inside a word-list cell. The header is line 1. The columns are, in this order: yellow_name<TAB>yellow_words<TAB>green_name<TAB>green_words<TAB>blue_name<TAB>blue_words<TAB>purple_name<TAB>purple_words - yellow = easiest. A plain, almost obvious category. - green = medium. Recognisable but not trivial. - blue = hard. Requires a twist of reasoning or specific knowledge. - purple = trickiest. Should be a wordplay / pattern category (see "Strong purples" below). The player should only see the pattern after struggle. Each *_name is a short category description (max 60 chars). Each *_words is a pipe-separated list of EXACTLY 4 uppercase words. ABSOLUTE RULES — every puzzle must satisfy: 1. Exactly 16 unique uppercase words across the four lists. No word appears in more than one list. 2. Every word: A-Z only, 3-12 letters, common British English vocabulary. Use British spellings (colour, centre, organise; not color, center, organize). 3. No proper nouns (no person names, brand names, place names). No abbreviations or hyphenated words. 4. Each category's 4 words must clearly and unambiguously fit the category — but ideally with at least one trap (a word that arguably fits a different category, especially the purple). 5. Difficulty progression: yellow is easiest, purple is hardest. The hardest category must require lateral thinking, not just trivia. 6. No two puzzles in this batch share a category or a near-duplicate (e.g. "Hot drinks" and "Warm beverages" both count as one — don't include both across two puzzles). STRONG PURPLES — the hardest category should use one of these patterns. Vary them across the batch: (a) "Words that precede X": e.g. THUNDER, BRAIN, SAND, FIRE → all precede STORM. (b) "Words that follow X": e.g. SUN + FLOWER, SET, DAY, RISE. (c) "Anagrams of X": pick a target like LISTEN → SILENT, ENLIST, TINSEL, LISTEN. (LISTEN itself in the list is fine if it's also in the puzzle theme list legitimately — but easier to pick 4 anagrams of a single word.) (d) "Sound like a number": ATE(8), FORE(4), TOO(2), WON(1). (e) "Homophones of X" or "Words that contain a hidden Y" (e.g. all contain a body part hidden inside: SHEAR=ear, BEARD=ear, LEGEND=leg, LIVERY=liver). (f) "Words missing the same letter" — e.g. add an L to each to make a new word: PANT→PLANT, CAP→CLAP, COD→COLD, FAT→FLAT. WORKFLOW for each puzzle: 1. Pick a theme intersection: a common idea that 4 categories can branch from. 2. Plan the purple first (the wordplay is the hardest constraint). Verify all 4 words actually share the pattern. 3. Add the yellow easy category — should feel almost free. 4. Add green and blue medium-hard categories. 5. Verify the 16 words are unique. Re-read the lists. 6. Verify each category has clearly 4 words that fit and no overlap with the others. BATCH SIZE: exactly 5 puzzle rows (so 6 lines total counting the header, plus the end marker on its own line). Quality matters more than quantity here. WORKED EXAMPLE — for format reference only, do NOT include this row in your output: Garden tools<TAB>SPADE|RAKE|TROWEL|MOWER<TAB>Hot drinks<TAB>COFFEE|COCOA|LATTE|BROTH<TAB>Words meaning fast<TAB>QUICK|RAPID|SWIFT|FLEET<TAB>Precede STORM<TAB>THUNDER|BRAIN|SAND|FIRE Verification of example: - Yellow "Garden tools": SPADE, RAKE, TROWEL, MOWER — all garden tools ✓ - Green "Hot drinks": COFFEE, COCOA, LATTE, BROTH — all hot drinks ✓ - Blue "Words meaning fast": QUICK, RAPID, SWIFT, FLEET — all synonyms ✓ - Purple "Precede STORM": THUNDER, BRAIN, SAND, FIRE — all form compound words with STORM ✓ - 16 unique words ✓. All British English ✓. Difficulty escalates ✓. VALIDATION CHECKLIST — for each puzzle, mentally tick: □ Every list has exactly 4 words. □ All 16 words are distinct (no word in two lists). □ All words are 3-12 letters, A-Z only, British English. □ Each category name describes its 4 words. □ Difficulty escalates yellow < green < blue < purple. □ Purple is a wordplay/pattern category. □ Across the 5 puzzles in this batch, no two categories are near-duplicates. If any check fails, fix the puzzle or discard it and generate a different one. END-OF-BATCH MARKER — after the 5th row, on its own line, emit exactly: END_OF_BATCH:N …where N is the number of puzzles in your output where the validation checklist all passes. N MUST equal 5. Begin now. Output only the TSV (header, 5 rows, end-marker). Nothing else. ``` ## After the AI runs 1. **Spot-check at least 2 puzzles by hand** — read every category, count words, look for word reuse between categories. AI models routinely reuse words across categories despite the prompt's instructions. 2. **Paste the rows** (not the header on subsequent runs) into `data/quartet-source.tsv`. 3. **Run the validator/packer**: `php tools/quartet-pack.php`. 4. **Review the failure list**. Common AI mistakes: - A word appears in two categories. - A category has 3 or 5 words instead of 4. - The purple isn't actually wordplay (just a 4th easy category). - Words don't fit the category as claimed. 5. **Run several times** to accumulate. Each batch is 5 puzzles; 40 batches gets you ~200 puzzles assuming most pass. ## Tips for the operator - Keep a running list of category names you've already used (paste as *"Avoid duplicating these categories"* with each subsequent prompt) so the catalogue stays diverse. - The purple is by far the highest-value column. Spend more attention there when spot-checking. A weak purple makes the puzzle feel like four easy categories with no payoff. - Like Skein, the validator is cumulative — running it again after editing the TSV only attempts unsaved puzzles. Editing the source TSV → re-running the validator is the iteration loop. - Game runtime reads `data/quartet-puzzles.json` directly; no service-worker bump or restart needed when adding new puzzles. New prompt: You are generating word puzzles for a UK daily Connections-style game called Quartet. I need exactly N complete, validated puzzles in TSV format. Quality and correctness matter far more than hitting a target count - if you can only validate fewer than N, return fewer. OUTPUT FORMAT - strict TSV, tab-separated, no commentary, no markdown, no code fences. Use a real tab character between columns and a pipe character between words inside a word-list cell. Header is line 1. Columns in order: yellow_name<TAB>yellow_words<TAB>green_name<TAB>green_words<TAB>blue_name<TAB>blue_words<TAB>purple_name<TAB>purple_words Difficulty: yellow easiest, green medium, blue hard, purple is wordplay/pattern (hardest). ABSOLUTE RULES - every puzzle must satisfy ALL of these. Self-check each rule for each puzzle before including it: 1. Exactly 16 unique uppercase words across the four lists. NO word appears in two lists within the same puzzle. This is the rule AI models break most often. Before outputting any row, list all 16 words and verify each appears once. 2. Every word: A-Z only, 3-12 letters, common British English. Use British spellings (colour, centre, organise). No proper nouns, no abbreviations, no hyphens. 3. Each category's 4 words must clearly fit the category. The word must BE a member of the category on its own, not a fragment (e.g. don't put SLEEPING in "camping gear" as shorthand for "sleeping bag" - the word alone isn't camping gear). 4. Purple must be genuine wordplay using one of these patterns: (a) "Precede X" - all four words form a real compound or common phrase when followed by X. Verify each compound is real (THUNDER+STORM yes, MOON+STORM no). (b) "Follow X" - all four words form a real compound when preceded by X. (c) "Anagrams of X" - all four are real English words that anagram to the target. Only use this if you can name FOUR real-word anagrams. LEMON, EARTH and most short words don't have four - don't force it with made-up letter rearrangements. (d) "Sound like a number" - homophones of digits. (e) "Contain a hidden X" - e.g. body part hidden inside each word. (f) "Add letter L (or other) to make a new word". For (a) and (b), the most common failure: making up compounds that aren't real. If you cannot say the compound out loud and have it sound like a phrase a British speaker would recognise, the word doesn't belong. 5. Trap design: the BEST puzzles have words that look like they belong in two or three categories but only legitimately fit one. Aim for at least one trap per puzzle - a word in (say) yellow that the player will be tempted to put in green or purple. The trap word itself only appears in ONE list. 6. Across the batch: no two puzzles share a category. "Hot drinks" and "Warm beverages" count as the same. "Words meaning angry" and "Words meaning furious" count as the same. Track the categories you've used as you generate. 7. Avoid category staleness: "Words meaning X" categories are easy filler. Use them for at most 2 of every 5 puzzles. Prefer concrete, specific categories (Knitting terms, Things in a forge, Sailing terms) over abstract synonym lists. THESE CATEGORIES HAVE ALREADY BEEN USED - do not reuse or create near-duplicates: [paste your running list here, or leave blank for a fresh start] THESE PURPLE PATTERNS HAVE BEEN USED - do not reuse the same target word: [paste your running list, e.g. "Precede BOARD, Precede STICK, Precede LIGHT, Precede WORK..."] GENERATION WORKFLOW per puzzle: 1. Pick the purple FIRST. Choose a target word and find four real compounds/anagrams/patterns. If you can't find four solid ones, pick a different target. Do not pad with weak compounds. 2. Write down the 4 purple words. 3. Build yellow, green, blue around a loose theme. Each category gets 4 words. 4. List all 16 words. Check no duplicates. If any word appears twice, swap it. 5. For each word, ask: "Does this word genuinely fit the category I've put it in?" If you're rationalising, swap the word. 6. Identify the trap: which word(s) could plausibly fit a different category? Aim for 1-3 traps per puzzle. 7. Re-read the four category names. Make sure they describe the four words accurately. OUTPUT REQUIREMENTS: - Header row, then up to N puzzle rows, then END_OF_BATCH:M where M is the actual count of puzzles output. - If you discarded any during validation, that's fine - M can be less than N. Do NOT pad with weak puzzles to hit N. - After END_OF_BATCH, on a new line, list the categories you used in this batch in the format: USED_CATEGORIES: [comma-separated list] USED_PURPLES: [comma-separated list of purple targets] This is so I can paste it back into the next prompt's exclusion list. VALIDATION PASS - before outputting each row, mentally run: - 16 unique words? (list them) - All 4 categories have exactly 4 words? - Purple compounds/anagrams all real? - Each word genuinely fits its category? - No category in this batch duplicates another? - No category duplicates the exclusion list above? If any check fails, fix or discard. If you fix, re-run the checks. REQUESTED COUNT: N = [fill in: 5, 10, 20, etc.] Begin. Output only the TSV (header, puzzle rows, end-marker, used-categories block). Nothing else.