Wsbaser Microlearn

Use AskUserQuestion if the TOPIC is missing. Ask what the user wants to learn. If the answer is a broad category, follow up to get the specific topic name.

If FREQUENCY was not specified in the arguments, don't ask yet — it will be defaulted intelligently in Step 4 after analyzing the topic.

Step 3: Classify the Topic

Determine the learning type:

• LANGUAGE — if the topic is a human language
• CUSTOM — any other topic

Step 4: Analyze the Topic and Choose a Delivery Strategy

Before jumping to interview questions, think creatively about how this specific topic is best learned. Different topics have fundamentally different learning dynamics — don't force them all into the same mold.

Output a brief visible summary to the user — 2 sentences max — explaining your recommended approach. Example: "Here's how I'd integrate [TOPIC] into your sessions: [insight 1]. [insight 2]."

Available delivery strategies

These are tools in your toolkit — pick the one that fits, or combine them:

Context-tied — Lessons react to whatever is happening in the current response. Best when the topic has natural bridges to coding concepts (e.g., language vocabulary from variable names, design patterns mirrored in music theory). No state tracking needed — each lesson is self-contained and memorable because the connection is fresh.

Structured curriculum — Lessons follow a predefined syllabus stored in memory, progressing through topics in a logical order. Best when the subject has a natural sequence that builds on itself (e.g., history chronologically, math from foundations to advanced). Uses a memory file to track the syllabus and current position so lessons don't repeat or jump around randomly.

Hybrid — Follow a curriculum for the core progression, but tie each lesson to the current context when possible. Good when the topic benefits from both structure and relevance.

How to choose

Context-tied is the default. Most topics work well as self-contained lessons that react to the current conversation. Curriculum adds real overhead (memory file, progress tracking, state management) and should only be used when it's genuinely needed.

Choose curriculum only when understanding later material truly depends on earlier material — where jumping ahead would confuse or mislead the learner. The test: "Would lesson #15 be meaningless or wrong without lessons #1–14?" If yes, curriculum. If each lesson stands on its own, context-tied.

Examples where curriculum is justified:

• History (events cause later events — WW1 explains WW2)
• Math with prerequisites (you can't understand eigenvalues without understanding vectors)
• Sequential skill-building where each step literally requires the previous one

Examples where context-tied is better despite seeming "structured":

• Cooking techniques — each technique is self-contained, you don't need to know sautéing to understand braising
• Bird watching — any bird fact is interesting on its own
• Logical fallacies — each fallacy stands alone
• Wine tasting — any wine concept is independently valuable
• Design patterns — each pattern is self-contained
• Storytelling techniques — each technique works independently

Hybrid is for the rare case where there's genuine prerequisite ordering AND strong coding bridges. Don't use hybrid as a "safe middle ground" — if the topic doesn't need progression, context-tied is strictly better (simpler, no state, no overhead).

For LANGUAGE topics: Context-tied is almost always the right default. No predefined plan needed unless the user specifically wants structured grammar progression.

Store the chosen strategy as DELIVERY_STRATEGY (one of: context-tied, curriculum, hybrid).

Default frequency (only if user didn't specify one)

If the user already provided a frequency, keep it. Otherwise, estimate a smart default based on how much material the topic has. The goal: lessons should last weeks at the user's likely usage rate (heavy users send hundreds of requests per day).

Estimate the topic's lesson pool — roughly how many distinct, interesting one-sentence lessons exist for this topic:

• Vast (thousands+) — human languages, broad history (all of history), encyclopedic topics → default to every response
• Large (hundreds) — focused history (WW2, Roman history), deep sciences (organic chemistry, linear algebra), broad arts (art history) → default to every other response
• Medium (50–150) — focused skill domains (chess openings, jazz improvisation, cooking techniques, astronomy) → default to every 3 responses
• Compact (under 50) — bounded concept sets (logical fallacies, cognitive biases, design patterns, storytelling techniques) → default to every 5 responses

This is a rough guide, not a formula. Use your judgment — the point is that a topic with 30 concepts shouldn't fire every response (exhausted in a day), while a language with 10,000+ words can sustain every response for months.

Store the result as FREQUENCY.

Step 5: Focused Interview

For LANGUAGE topics — one focused question

Ask with AskUserQuestion:

{
  "question": "How would you like your {LANGUAGE} lessons to feel?",
  "options": [
    {
      "label": "Context-tied vocabulary",
      "description": "Translates words that appear in the current response — variable names, UI concepts, domain terms. Most memorable because the word is already in your head."
    },
    {
      "label": "Grammar patterns",
      "description": "One grammar rule per lesson with a short example. Systematic — builds structural understanding over time."
    },
    {
      "label": "Mixed rotation",
      "description": "Rotates through vocabulary, grammar, and pronunciation across responses. Broadest coverage, best for general fluency."
    }
  ]
}

Store the answer as LANGUAGE_STYLE. It will be used in Step 7 to fill {STYLE_INSTRUCTION}.

For CUSTOM topics — short interview (2–3 questions max)

Ask focused questions to understand what kind of lessons the user wants. Use AskUserQuestion with 3 options per question.

One of the questions should present your recommended delivery strategy and let the user confirm or adjust. For example, if you chose curriculum for "history of computing," explain why chronological progression makes sense and offer alternatives.

Step 6: Determine Root Directory

If the current directory is inside a git worktree, use the main repository root (not the worktree root) so the setup persists across all worktrees. Set ROOT_DIR to that path.

Step 7: Generate Curriculum (only if DELIVERY_STRATEGY is curriculum or hybrid)

If the chosen strategy involves a structured curriculum:

1. Generate a syllabus — an ordered list of 15–25 units (not individual lessons). Each unit is a theme or era that should be explored across many lessons from different angles. The syllabus should reflect what was discussed in the interview (scope, focus areas, difficulty level).

   Units vary in richness — some themes have dozens of fascinating stories, others have just a handful. That's fine. The goal is to keep the user engaged, not to hit a lesson count. Write unit descriptions that capture the scope of the theme so the model can judge how much material is there.

2. Save it as a memory file at {MEMORY_DIR}/microlearn-{TOPIC_SLUG}.md with this structure:

---