Tier 1 starterLowest load

Parent Practice Pack

“Send practice home parents can actually run.”

AI Builder

open

AI Champion

open

Illustrative team — open seats are real invitations.

Build mode: assemble on blocks
Built on: @k12vls/worksheet-core + @k12vls/curriculum
Output: printable packet + parent guide

The brief

What it is, and why a teacher says yes

The pain point

Home practice fails at the kitchen table. A teacher sends work home, but the parent doesn't know how to help — “is this how you're supposed to do it now?” — so the practice stalls or teaches the wrong method. The teacher can't reliably extend learning past the classroom door, and the gap between school and home is where momentum is lost.

What it does

Teacher picks grade + standard → gets a printable home-practice packet (problems aligned to that standard) and a parent guide that, for each problem type on the sheet, explains in plain language how to help — what the skill is, what to say, what a right answer looks like, and what not to correct away.

Why it's adoptable

There's no app for families to install — it's a printout in a backpack. The teacher extends their reach into the home with zero family-side tech: no account, no device, no login on the parent's end. It meets every family where they are, including the ones a classroom app would leave out.

What the teacher receives — a synthetic example

Addition Facts — Home Practice

Name: ______________________Grade 2 · 2.OA.B.2

8 + 6 = ____ (make a ten: 8 + 2 + 4)
Fill in the fact family for 6, 8, 14:
6 + 8 = __ 8 + 6 = __
14 − 6 = __ 14 − 8 = __

… ~8 more …

For the grown-up helping (≈10 min)

Make-a-ten problems: Ask: “How many to get to 10?” then add the rest. It's fine if they don't line it up in columns yet — that comes later.
Fact families: The point is seeing that + and − use the same three numbers. Don't “correct” them into memorizing — let them find each one.
A right answer looks like: The number and a way to explain it. “14, because 8 plus 2 is 10, plus 4 more” is exactly right.

Plain-language, tied to the exact problems on the sheet. No app to install.

Illustrative mockup. All example data is synthetic — no real student data.

The graduation signal

“Built” doesn't count — real, repeated use does. Here's the ladder.

1
Pilot
A teacher sends one real pack home with a real class — not a trial run for the builder (teacher-side).
2
Active use
The teacher sends packs home across multiple cycles — week after week, unit after unit (teacher-side MAU is the primary signal).
3
Sustained MAU
It becomes the teacher's default way to send practice home — counted as teacher-side MAU (the family logs into nothing), with student participants estimated from classes served, not as logins; the stronger downstream signal is home completion coming back — sheets returned, the parent guide referenced (teacher-side, with student-/home-side evidence behind it).

For the AI Builder

How you build it

The honest build path — what it builds on, the rough assembly, the data flow, and the gaps the blocks don't give you for free.

Blocks it builds on

@k12vls/worksheet-core — provides the CCSS standards model (GradeID, CCSSStandard, the StandardsTree type), problem-generation config + record types (CcssProblemGenerationConfig, CcssProblemRecord), the problem-generation prompt constants (getProblemGenSystemPrompt), rendering UI (@k12vls/worksheet-core/ui), and a PrintOptions type. (It types the standards tree but doesn't ship the populated CCSS data or print CSS — the selector data comes from a CCSS data service/app source, and print layout is app-level styling you supply; verify against the repo before relying on either.)
@k12vls/curriculum — the curriculum data/utilities the standards selection draws on.

Rough assembly

1Pick — a grade + standard selector (populated from a CCSS standards tree typed by worksheet-core), plus a packet length control that feeds numProblems.
2Generate the practice — call the LLM with getProblemGenSystemPrompt(...) + a CcssProblemGenerationConfig (numProblems is required) to produce the home-practice problems (and their answers), collected as CcssProblemRecords. Any fluency/scaffold emphasis goes through customInstructions — there is no difficulty config input.
3Generate the parent guide (the distinctive build element). Run a second, separate LLM pass — not over the standard, but over the problem types that came back in step 2 — to write a plain-language “how to help” guide for a non-teacher adult. Prompt it for everyday wording (no jargon), what to say, what a correct answer looks like, and the method the child is expected to use so a well-meaning parent doesn't “correct” the school's approach away. The teacher's guide-length / reading-level controls shape this prompt. The input is the generated CcssProblemRecords; the output is the guide text, paired one-to-one with the problem types on the sheet. This pass is prompt-driven, not a verified alignment guarantee — the guide is a draft the sponsoring teacher reviews before it goes home.
4Render — display the practice sheet, the parent guide, and the answer key with the worksheet-core ui components; lay them out as one packet (practice first, guide as a clearly separated “For the grown-up helping” section or facing page, answer key as a teacher copy / fold-under).
5Print — apply PrintOptions / print styles; the teacher prints to paper or “Print → Save as PDF,” then the packet goes home in a backpack.

The data flow

Teacher picks grade + standard → build a CcssProblemGenerationConfig.

LLM call with getProblemGenSystemPrompt → problems + answers (CcssProblemRecord).

Second LLM pass over the problems → a plain-language parent guide per problem type.

Render the packet: practice + answer key with worksheet-core/ui, merging in the parent guide.

Apply PrintOptions → Print / Save as PDF: practice + parent guide + key → backpack.

Caveats — the honest gaps

The parent guide is a generation pass, not a block. worksheet-core gives you the problems and the rendering; it does not ship a “parent guide” generator. That plain-language second pass is your prompt and your quality bar. It's the part most likely to read as either too technical or too vague — budget your build time there, and review its tone against a real non-teacher reader before sending it home.

“PDF” means browser-print. worksheet-core exposes PrintOptions and print styling, not a turnkey generatePDF(). The packet becomes a PDF via the browser's print-to-PDF — fine for a backpack printout, but don't promise a server-side PDF the block doesn't provide, and lay the parent guide out so practice + guide paginate cleanly when printed.

firebase-auth dependency. worksheet-core depends on @k12vls/firebase-auth. For a no-login starter, keep generation/printing on a path that doesn't require a signed-in user; verify at runtime what the package actually requires before claiming “no login.” This matters doubly here: the teacher side may touch the package, but the family side must stay completely tech-free — there is no family login by design.

Scope boundaries

This is a print-to-backpack packet generator, not a take-home app: it does not track whether the family completed the work, does not collect returned sheets back into the tool, and adds no family-side login, scan, or upload — the moment the parent guide asks the family to go online, it stops being this starter and starts touching home data.

For the AI Champion

Taking it to a teacher

The adoption kit — the pitch, the pain it lands on, the objections you'll hear, and what a real pilot looks like.

The 30-second pitch

“You send homework home, but half the parents don't know how to help — so it stalls. Pick your grade and the standard, and this prints the practice sheet plus a one-page guide that tells the parent, in plain English, how to help with each kind of problem. Nothing for the family to download — it just goes home in the backpack.”

The pain it lands on

The kitchen-table breakdown — the parent who wants to help, sits down with their kid, and either can't, or teaches it the old way and confuses everyone. The teacher hears about it the next morning, and the practice they sent home did more harm than good.

Objections → responses

“My parents won't read a guide.”

It's one page, plain-language, and tied to the exact problems on the sheet — built to be skimmed at the table, not studied. And it goes home with work they were sending anyway.

“Will it teach the parent the wrong method?”

That's exactly what the guide is built to prevent — it's prompted to align to the method the standard expects and to tell the parent what not to correct away. Because that alignment is prompt-driven, you review the guide before it goes home (it's part of the pilot gate); a quick read is all it takes, and it's the same review you'd give any sheet you send.

“Where does my students' data go?”

Nowhere. You pick a standard; it prints a packet. No student logs in, no parent logs in, no names are entered, and the tool stores no student data — the blank packet that leaves the building carries none and the tool collects none back. (Once a child writes on the paper at home that sheet has their work on it, but it stays off the tool — there's no scan, upload, or return path.)

What a pilot looks like

Not one packet — a habit. The test is whether the teacher sends a pack home for the next unit, and the one after. Success = it becomes the teacher's default way to send practice home, and (the stronger signal) sheets start coming back completed, with parents who actually used the guide.

The bar

Safeguarding & the pilot gate

The minimum conditions before any classroom use, and the data posture that keeps the solution honest.

Pilot gate

Sponsoring adult: A classroom teacher (or a school / after-school / community lead serving real learners) who agrees to send the packs home.
Minimum version: The pick → generate → parent-guide pass → render → print path works end to end for a chosen grade + standard, producing a backpack-ready packet whose parent guide reads cleanly to a real non-teacher reader — and which the sponsoring teacher has reviewed for correctness, alignment, and the guide's method language before any pack goes home — not a demo of the generator alone.
Pilot setting: Take-home practice — a packet that goes home in the backpack for a real unit, parent-led at the kitchen table.
Success evidence: The teacher sends one real pack home with a real class (mirrors the Pilot rung of the Graduation signal).
Stop condition: The parent guide reads as too technical or too vague, teaches a method the standard doesn't expect, or quietly asks the family to go online — any of which means pause and revise before the next pack goes home.

Safeguarding

Lowest load

Data touched

No student data — the teacher-selected grade + standard generate the packet (and pass through the LLM problem-generation call, plus the second parent-guide pass); no student login, no parent login, no PII, no uploads, no completed work. No student data is persisted; the generated packet/PDF is ordinary lesson material the teacher may save and reprint. The packet leaves the building — it goes home to parents — but the family only receives a blank printout: they install nothing, log into nothing, and the page collects and transmits nothing. (The sheet has a Name: blank and a child writes on it at home, so the paper can carry student work once filled in — but that stays off the tool: there's no scan, upload, or return path back into it.) That zero family-side tech is the safeguarding strength, not a gap.

Checklist

Sponsoring teacher ✓ (required program-wide).
Data-handling review n/a (no student data).
Consent n/a (nothing is collected from the family).
Supervision = ordinary at-home practice, parent-led.
Content review applicable — both the practice and the parent guide are LLM-generated and go home to students and families, so the sponsoring teacher verifies correctness, standard alignment, suitability, and the parent guide's method language before sending (a required classroom quality/safeguarding gate, not a data-handling item).

One thing to verify

That the family side stays genuinely tech-free and data-free end to end — confirm the no-login path holds (see the firebase-auth caveat), and confirm the parent guide as generated includes no instruction to scan, log in, photograph, or submit anything. The “leaves the building but collects nothing” claim only holds if the printed page never quietly asks the family to go online.

What would change the load

The current Lowest profile holds only while the family side stays print-only. It rises the moment any of these is added — a family/student login on the take-home path, a scan/photo or upload of completed work, saved or returned sheets captured back into the tool, telemetry tied to a specific student/family/class (returned-sheet status, per-class home-practice history), parent contact collected, or personalized per-child feedback. Each turns “no student data” into student data; until one is added, the profile above holds.

Want to build Parent Practice Pack?

Tell us this starter caught your eye — or browse the others first.

Get in touch See all starters