Checkpoint · v4 refactor — early framing, not a build spec

Ad-hoc card generation — shaping your vision

A user brings their own AI account (say, their own Gemini Pro login) and some source material — a book, a PDF, a chapter, a screenshot of a lesson — picks a card type, and the system asks their AI to turn that source into a deck, in the same structured format the rest of WordSense uses. This checkpoint captures the vision you've already described and the handful of questions that shape it. Nothing here locks in a build.

EARLY — shaping, not deciding Rides the v4 refactor, doesn't need its own foundation Your own words, from two prior notes
Checkpoints Latest →
This is early. Unlike the other two checkpoints this week, nothing below is a clean multiple-choice ruling. It's your vision, written back to you, plus the open questions that would need answers before anyone scopes real build work. Answer as much or as little as you want — a short note on any item moves this forward.
Your notes so far

What you told us, in two places

Quoted from v4-refactor-plan — lightly cleaned up from voice dictation, your words

Your note, v4-refactor-plan · Decision 5 (dharma deck scope)

"We shouldn't be so concerned about the content, but the thing that we need is the ability to have ad-hoc learning — L1 equals L2 — and have the system be able to generate cards based on some kind of prompt or input or something like that. Not exactly sure if it should be a separate product or not, but it's definitely in my target functionality line, and I think it's going to be an important aspect of this application moving forward."

Your note, v4-refactor-plan · language-dial requirement

"Some of the other card archetypes may not actually have a situation where L1 differs from L2 — it may be that L1 equals L2, so if they're just learning vocabulary or information in one language, we won't do any translating, but we'll still generate the necessary content in that language. That's private data more than likely, or custom data. I haven't worked out if I'm going to have profile packs with preset card archetypes and content, other than the language learning we're doing right now — which is well-defined: Indonesian into English."

The key insight

This rides the refactor — it doesn't need its own foundation

The reason this belongs in the v4 conversation at all: if the "Card Types" checkpoint's Decision 3 lands (generated, self-documenting schemas per card type, pulled straight from the database), those same schemas become the target format an ad-hoc request sends to the user's AI — and the card types themselves (simple flashcard, cluster card, grammar-rule card) become the menu a user picks from. Nothing new has to be invented for ad-hoc generation to work; it's a new front door onto machinery the refactor already builds.

Roughly, how a request would flow
1
User picks a card type + brings source material (PDF, chapter, screenshot)
2
WordSense sends the source + that card type's schema to the user's own AI account
3
The AI's structured result becomes a deck, same-language in and out
Framing item 1

When — after the refactor, or sooner?

⏱️
Since this reuses the refactor's schemas and card types, doing it after the core refactor lands means building it once, on solid ground, instead of twice.
A — After the core refactor lands.
B — Sooner — note why it can't wait.
Recommended: A — building on the not-yet-settled schema shape risks redoing this work once Decision 3 (canonical schemas) actually lands.
Framing item 2

Confirm: ad-hoc reuses the canonical schemas as the AI's target format

🎯
The key insight above, as a direct question: should an ad-hoc request send the user's AI the exact same generated schema (e.g. vocabulary-schema.ts) the main pipeline enriches to, or a different, simpler format built just for this?
A — Yes, reuse the canonical schemas as-is.
B — A separate, simpler format — note what's different and why.
Framing item 3

Bring-your-own AI account

🔑
The app calls the user's own AI account (their Gemini Pro login, for example) — not WordSense's own AI pipeline or budget. That keeps the cost off WordSense and lets the user pick whatever AI they already pay for. Open questions this raises: which AI providers get supported first, how a user connects their account, and what happens if their source material is too big for their AI's own limits. Use the note to shape any of this.
Framing item 4

Each request creates its own profile

🗂️
An ad-hoc request would create its own profile — a language plus a card set — separate from the main Indonesian-into-English learning you've built out today. Your language-dial note above already anticipates this: most ad-hoc content is likely L1 = L2 (same language in and out, no translation pass needed, just content generation), and you've floated the idea of "profile packs" — presets beyond the core language-learning use case — without having fully worked out the shape yet.
Confirm — each ad-hoc request auto-creates its own profile (language + card set).
Shape it differently — note how.
Framing item 5

Anything else to frame

💬
Catch-all for anything else that shapes this before it's a real plan: how source material gets read in (a pasted PDF vs. a photographed textbook page are very different problems), which card types get offered first on the menu (simple flashcard and grammar-rule card are probably simplest; cluster card needs Decision 1/2 from the "word's family" checkpoint settled first), and how a finished ad-hoc deck gets saved, revisited, or shared with someone else.
Worth your eye

Where to spend your attention

🧩
If Decision 3 on the Card Types checkpoint (generated schemas) and the family/cluster-card decisions land as proposed, ad-hoc generation mostly becomes a UI + AI-hookup problem — not a new data model. Worth reading all three checkpoints together for that reason.
🧭
This is the one item on all three checkpoints most likely to grow past its current framing once it's actually scoped — worth deliberately keeping it "framing only" until the foundation decisions are locked, per your own recommended answer on Framing item 1.