The unit plan was half-built when MagicSchool stopped. Not a spinner. Not a loading delay — just a hard stop, an “Output Limit” warning, and a blank second half where the lesson sequence should have been.
The instinct is to hit regenerate. That produces the same truncated output, cut at roughly the same point, because the underlying constraint has nothing to do with a button press.
What Most People Try First (and Why It Doesn’t Work)
When you search this error, the results are almost entirely forum threads and generic AI troubleshooting guides recommending the same three moves: refresh the page, clear the cache, try a different browser. Nearly every result treats the output limit as a network error or a platform glitch. That framing sends the fix in the wrong direction entirely.
The real cost here is not the missing output — it’s the twenty minutes spent reloading a page that was never broken in the first place.
MagicSchool is built on large language models, and those models process text through a measurement called tokens. A token is roughly four characters of text — not a word, not a sentence, a fragment. Every prompt you write consumes tokens. Every word the model generates consumes tokens. The model has a fixed ceiling for the combined total of input plus output in a single generation request. When that ceiling is hit mid-output, generation stops. The platform surfaces this as an “Output Limit” warning, but what actually happened is that the model reached its context window boundary and had nowhere left to write.
Refreshing does not raise the ceiling. Regenerating does not raise the ceiling. The ceiling is a property of the model itself, not a setting you can adjust inside MagicSchool.
Why Long-Form Requests Hit the Wall Faster Than Expected
A full unit plan prompt typically includes grade level, subject, standards alignment, learning objectives, a sequence of lessons, differentiation notes, and assessment criteria. By the time MagicSchool finishes reading that input, a significant portion of the available token budget is already spent — before a single word of output has been written.
The model then begins generating. It writes lesson one, lesson two, maybe lesson three — and somewhere around the midpoint of a five-day plan or a multi-chapter story, the combined token count crosses the threshold. Generation stops mid-sentence or mid-lesson, not because the platform failed, but because the model ran out of space.
This is why regenerating produces the same truncation. The prompt is identical, the token budget is identical, and the model hits the same wall at roughly the same word count every time. The visible error message implies a platform problem. The actual constraint is architectural.
The Fix: Modular Generation (Outline First, Sections Second)
The working approach treats one long generation request as a sequence of smaller ones. Instead of asking MagicSchool to produce an entire five-day unit plan in a single prompt, you generate the skeleton first, then fill each section individually. This keeps every generation request well inside the token ceiling, and each section completes cleanly.
The operating rule: generate the structure first, then generate each piece. This applies to unit plans, long stories, multi-lesson sequences, and any output that consistently stops before completion.
Step-by-step chunking sequence
- Generate the outline only. Ask MagicSchool to produce a unit outline — lesson titles, learning objectives per lesson, and assessment checkpoints — without expanding any section. This request is short enough to complete in full and gives you the skeleton to build from.
- Copy the outline into a document. Paste it into Google Docs or any working document before proceeding. Do not rely on MagicSchool’s session memory between generations.
- Generate Lesson 1 in a new prompt. Include the outline as context, then ask MagicSchool to expand only Lesson 1 in full detail. One lesson at a time keeps the output well within the token limit.
- Paste and continue. Copy the completed Lesson 1 output into your document, then return to MagicSchool and generate Lesson 2 using the same approach. Repeat for each lesson or section.
- Generate the assessment section last. Assessment tasks and rubrics often expand significantly. Keeping them as a final separate generation prevents them from consuming tokens that the lesson content needs.
This sequence works because each generation request carries only the context needed for that one section. The token budget resets with every new prompt, so no single request accumulates enough input plus output to hit the ceiling.
Before and After: What the Output Actually Looks Like
Before — single-prompt generation (truncated output)
“Unit Plan: Forces and Motion — Grade 5
Lesson 1: Introduction to Forces — Students will identify push and pull forces…
Lesson 2: Measuring Force — Students will use spring scales to…
Lesson 3: Friction and Surfaces — Students will compare…
[Output limit reached. Generation stopped.]”
After — chunked generation (complete output per request)
Request 1 → Full outline with five lesson titles and objectives. Complete.
Request 2 → Lesson 1 expanded with activities, materials, and formative check. Complete.
Request 3 → Lesson 2 expanded. Complete.
Request 4 → Lessons 3–4 expanded. Complete.
Request 5 → Lesson 5 plus summative assessment rubric. Complete.
The total generation time across five requests is roughly the same as one long request — except every section actually finishes. A unit plan that previously stopped at Lesson 3 now completes across five short sessions, each taking about two to three minutes.
Copy-Paste Prompts for the Chunking Workflow
Use these prompts directly in MagicSchool. Adjust the bracketed fields to match your subject and grade level.
PROMPT 1 — OUTLINE ONLY
Create a [5]-day unit plan outline for [Grade 5 Science: Forces and Motion]. Include only: lesson titles, one learning objective per lesson, and one formative assessment checkpoint per lesson. Do not expand any lesson into full detail. Output the outline only.
PROMPT 2 — SINGLE LESSON EXPANSION
Here is the unit outline: [paste outline]. Using only Lesson [1] from this outline, expand it into a full lesson plan. Include: learning objectives, warm-up activity (5 minutes), main activity with instructions (25 minutes), materials list, differentiation notes for early finishers and students needing support, and a formative assessment question. Do not expand any other lesson.
PROMPT 3 — ASSESSMENT SECTION (FINAL REQUEST)
Here is the completed unit outline: [paste outline]. Generate a summative assessment for this unit. Include: one performance task description, a 4-level rubric with criteria for [understanding of forces, application, communication], and three short-answer questions. Do not regenerate any lesson content.
Where This Approach Breaks
Chunking solves the truncation problem for most unit plans and long-form stories, but two edge cases push back.
When the outline itself is too long. If you ask for a ten-day unit outline with five objectives per lesson and full standards citations, the outline prompt can hit the token limit before it finishes. Keep outline requests minimal — titles, one objective, one checkpoint. Save the detail for the expansion prompts.
When the expansion prompt carries too much context. Pasting a full five-day outline plus detailed instructions into every expansion prompt adds token weight that accumulates quickly. For longer units, paste only the relevant lesson title and objective as context rather than the entire outline. The model does not need to read all five lessons to write lesson three.
A third failure worth knowing: if you ask MagicSchool to “continue from where it left off” after a truncation, the results are inconsistent. The model does not retain the previous output in memory between separate prompts. It generates a continuation based on whatever context you paste in, which often produces repeated content or a mismatched tone. Starting the next section as a fresh, scoped request produces cleaner output than asking for a continuation.
Chunking for Long-Form Stories and Other Formats
The same logic applies outside unit plans. A multi-chapter classroom story, a long differentiated reading passage with comprehension questions, or a detailed project-based learning sequence all share the same vulnerability — they are long enough to exhaust the token budget before completing.
For stories, the chunking sequence runs: story premise and chapter outline first, then one chapter per prompt. For differentiated reading passages, generate the base passage first, then generate the below-grade and above-grade adaptations as separate requests. For project-based learning sequences, generate the driving question and phase overview first, then each phase individually.
Generate the structure first, then generate each piece. That rule holds regardless of the format.
Verification: How to Confirm the Fix Is Working
After switching to the chunking workflow, check these three signals to confirm each generation is completing cleanly:
- The output ends with a logical conclusion — a closing sentence, a completed rubric row, a final formative question — rather than cutting mid-sentence or mid-list.
- No “Output Limit” warning appears at the bottom of the generation window.
- Requesting the next section in a new prompt produces content that continues logically from where the previous section ended, without repeating the opening context.
If the warning still appears on an outline-only request, the prompt itself is too dense. Strip it back to lesson titles and a single objective per lesson, nothing else, and regenerate.
If you want a ready-to-use template for this chunking workflow — including a pre-structured outline prompt, a reusable lesson expansion prompt, and an assessment generation prompt formatted for different grade bands — the AI Lesson Workflow Template Pack on AI EdTech Review includes all three, formatted for direct use in MagicSchool and similar tools. No adaptation required.
Run the outline prompt first on your next long unit plan and confirm it completes before writing a single lesson. If it stops before finishing the outline, the prompt is still too long — cut it to titles and objectives only, then try again. That test takes under two minutes and tells you exactly where your token ceiling sits for that request type.