spiral-curriculum

Spiral Curriculum Design

Design a series of lessons so that a few core concepts repeatedly return throughout the entire series, and each time a structural upgrade occurs. The smallest design object is the "concept spine + the encounter history of each concept", not the table of contents of a single lesson.

First load /stage-design to obtain the creation baseline for a single lesson, and load /curriculum-planner to obtain multi-lesson folder, cross-lesson reading, and batch delivery rules. This Skill adds spiral architecture, upgrade operators, and false-spiral checks on top of them.

Scope of Application

For the following requests:

• Use Bruner's spiral curriculum to design a unit or series of lessons;
• Have the same set of core concepts be revisited across lessons and gradually deepened;
• Use how learners' understanding develops as the main line, rather than arranging lessons linearly according to textbook chapters.

Do not use for:

• A single independent lesson, in which case use /stage-design and the corresponding topic Skill;
• A series that only requires covering content in order, without conceptual upgrade revisits, in which case use /curriculum-planner；
• Style replication or direct PPT import, in which case use /style-clone or /pptx-import。

First Principle: Revisit Is Not the Same as Review

"Lesson 1 teaches the concept, Lesson 3 reviews the concept, Lesson 6 reviews it again" is not a spiral. Each revisit must clearly answer:What does this time have more than last time?

Each revisit must upgrade in at least one of the following dimensions:

Dimension	Initial Contact	Subsequent Revisit
Complexity	Single relationship	Interaction of multiple variables
Abstraction	Concrete cases	General models
Relationship density	Isolated concept	Connected with more concepts
Representation mode	Intuitive experience	Diagrams, models, symbols
Transfer distance	Familiar situations	Unfamiliar situations, cross-domain
Boundaries and counterexamples	Positive examples	Counterexamples, boundaries, limitations

If a return is not higher in any dimension, it is only repetition and must be rewritten.

Page Content Red Lines

Concept Spine、encounter、growth operator、Spiral Contract、revisit、概念脊柱、遭遇史、●/▲/◆ and the like are teacher-side planning language. They may appear in dialogue, architecture, and page briefs, but must not appear in student-visible titles, labels, or body text.

"What does this time have more than last time" goes into the brief, not written as a "complexity upgrade" label on a student page. Teachers' and agents' spoken words go through narration / actions, not written as static body text such as "the teacher says" or "the student says".

Concept Spine

Do not first arrange the lesson schedule list. First answer: after the entire series ends, which few core ideas that can be repeatedly used and transferred should students truly establish?

• Write each core concept as a transferable understanding, not as a noun;
• A series usually chooses 3-6 core concepts, avoiding too many and causing each lesson to touch only superficially;
• Each concept simultaneously declares an initial understanding goal and a final understanding goal, as the two endpoints of the Learner Progression;
• Can be combined with /understanding-by-design to determine big ideas, essential questions, and performance evidence, then use this Skill to arrange cross-lesson upgrade revisits.

Spiral Map

Maintain a cross-lesson encounter history for each core concept: intuitive experience → mechanistic explanation → multivariable relationships → formalized model → transfer to unfamiliar situations → integration with other concepts.

The teacher-side Spiral Map can use:

• ●: first encounter;
• ▲: deepening;
• ◆: synthesis and transfer.

Next to each marker, the new structure added this time must also be stated. A table with only symbols and no progression notes has no value.

Planning a Revisit

For each concept + previous encounter + target growth decide four things:

1. What to keep: which existing understandings do not need to be retaught;
2. What to add: the content or conditions newly added in this round;
3. What to reorganize: which isolated pieces of knowledge need to be formed into mechanisms or relationships;
4. Where to transfer: which new situation will be used to test the concept structure.

Progression Operators

• ADD_COMPLEXITY: add variables or interactions;
• ADD_RELATION: make the current concept form a necessary relationship with another concept;
• ABSTRACT: rise from cases to a general model;
• FORMALIZE: introduce symbols, models, or specialized language;
• CHANGE_REPRESENTATION: reconstruct the concept among operations, pictorial models, and symbolic representations, without mechanically forcing it into a fixed lesson sequence;
• INCREASE_TRANSFER_DISTANCE: gradually enter more unfamiliar or cross-domain situations;
• ADD_EXCEPTION: add counterexamples, boundaries, constraints, or limitations.

A revisit usually chooses 1 main operator and a small number of auxiliary operators. Do not stack all operators at once; that only piles on difficulty.

Concept Memory

The spiral depends on shared memory across stages. The platform will not automatically maintain a concept model for this Skill, so the teacher-side run record must be saved in the current conversation, containing at least:

• concept id；
• encounter history；
• representation history；
• complexity level；
• known relations；
• misconceptions detected；
• examples used；
• transfer distance；
• mastery evidence；
• next revisit target。

Before starting the next lesson, use read_stage_outline to read back the persistent page list from previous lessons; when the actual content needs to be checked, continue to use read_stage. Do not trust only the original plan; adjust this round's "keep, add, reorganize, transfer" based on what has actually landed in the lessons.

Spiral Contract for Each Lesson

Each stage must have a contract in the teacher-side plan:

• returning_concepts: which old concepts return;
• new_concepts: which concepts appear for the first time;
• added_complexity: where it is more complex or abstract than before;
• new_relation: what new conceptual relationships are added;
• representation_shift: whether the representation is changed;
• transfer_target: which new situation is entered;
• future_hook: what is deliberately left for later revisits.

future_hook allows productive incompleteness: build a usable but incomplete model early on, then reorganize it later; there is no requirement to explain the concept completely in every lesson.

Two-Layer Design

Layer One: Spiral Architecture

First produce in the conversation and ask the user to confirm:

1. Concept Spine: the initial and final understanding goals for each core concept;
2. Course Timeline: the topics and tasks of each lesson;
3. Concept Spiral Map: when each concept appears, when it returns, and what is added each time;
4. Learner Progression: how student understanding should change lesson by lesson;
5. the Spiral Contract and concept intersections for each lesson.

Use ask_user to let the user adjust the number of lessons, concept timing, depth, and intersection relationships. Do not create lessons before the architecture is confirmed.

Layer Two: Generate Lessons

After the architecture is confirmed, by default continue building the entire approved series through to completion, without repeatedly stopping between lessons for confirmation, unless the user explicitly requests batch-by-batch acceptance:

1. create_folder Create the series folder;
2. For each lesson, call create_stage, passing in that folderId；
3. For each lesson, first set_roster, then page by page according to the approved plan generate_scene；
4. When narration needs to be supplemented, page by page generate_actions, after modifying the narration, supplement generate_tts；
5. Use list_scenes、read_stage_outline and read_stage to verify the persisted results;
6. Update concept memory before starting subsequent lessons.

The architecture itself remains only in the teacher-side planning and does not generate student pages.

Fake spiral check

After the entire series is complete, check concept by concept:

• The same concept appears multiple times but the complexity does not increase: Repeated, not spiraled;
• Later on, only terminology is added, without adding structural understanding: Vocabulary inflation;
• Every lesson is new content, and old concepts do not return: Linear curriculum;
• So-called review only happens at the end of the unit: Review curriculum;
• When a concept returns, the context and representation are exactly the same: Context repetition;
• Later on, it is only that the problems are harder, not that the concepts are deeper: Difficulty escalation without conceptual deepening.

If any item is hit, return to the corresponding Spiral Contract to modify the page brief or lesson arrangement, then re-verify.

Completion criteria

• Every concept has an initial understanding goal, a final understanding goal, and a complete encounter history;
• Each revisit indicates the main escalation operator and the newly added structure;
• Every lesson has a seven-field Spiral Contract;
• The architecture is confirmed first, and after confirmation the entire series is continuously persisted into the folder;
• The actual content of each lesson has been read back, and concept memory does not rely only on the original plan;
• Student-visible text does not contain spiral metadata, planning jargon, or character lines;
• Each lesson still satisfies /stage-design 's page, roster, persistence, and audio completion criteria;
• The series passes the fake spiral check.

Relationship with other teaching methods

• /understanding-by-design can first determine the big ideas, essential questions, and performance assessments, and this Skill is responsible for making these concepts be revisited with escalation across lessons;
• /feynman-learning within a single lesson drives repeated externalization and reconstruction of explanations, while this Skill arranges for concepts to return repeatedly throughout the entire series;
• /learning-to-learn and /social-emotional-learning are parallel goals, and are embedded only when serving the current concept revisit, without starting a separate lesson mainline.