Course Structure Pipeline

The course structure pipeline transforms a topic and audience profile into a fully designed course outline with section-level blueprints ready for content generation. It runs after the Audience and Depository pipelines and consists of 6 steps.

Pipeline overview

flow_audience_analyze          flow_depository_fill
        ↓                              ↓
        └──────────────────────────────┘
                         ↓
         flow_course_structure_concept      ← Step 1: Course concept
                         ↓
           flow_course_structure_plan       ← Step 2: Bloom's-aligned outline
                         ↓
          flow_course_structure_design      ← Step 3: Content plan with types & formats
                  ↙               ↘
flow_course_structure_     flow_course_structure_
  feedback_learner           feedback_expert       ← Step 4: Parallel review
                  ↘               ↙
          flow_course_structure_refine      ← Step 5: Improved final outline
                         ↓
              Section content generation

Step 1 — Concept (flow_course_structure_concept)

Inputs: course_title, topic, course_complexity, reasoning, target_persona, target_context, optional industry, audience_profile, pain, transformation, learning_objectives, depository Output: Markdown — course concept document

Analyzes the target audience and topic to design the course concept. Defines:

• One foundational framework or concept anchored in the depository, with one or two complementary frameworks only when they genuinely strengthen the course
• Bloom's complexity alignment (Beginner: ONE framework in depth; Intermediate: foundational + complementary)
• A compact course scope that should usually fit into 3 modules and must not require more than 4 across the whole course
• A narrative persona with a random European name (via how_to_pick_random_name injection) whose story threads through the entire course

When industry is provided, the concept step should also align framing, examples, and narrative angle to the learner's sector rather than relying on the depository alone to carry that context implicitly.

Key constraints:

• Always use established, research-backed frameworks from organizational psychology, management, or communication studies
• Never invent terms or pseudo-frameworks
• Selected core concepts must be generally recognized in the field, with accepted terminology and credible real-world use; do not use niche, ad hoc, or course-invented concepts as core concepts
• Do not force a fixed number of concepts; use one foundational framework by default and add complementary ones only when they materially improve the course
• Keep the concept narrow enough for a compact outline: 3 modules is preferred, and 4 is the maximum
• For Beginner scope, 3 modules should usually map to Remembering, Understanding, and Applying; use a 4th module only with a clear pedagogical reason such as cognitive-load reduction or a cleaner guided-practice transition
• At Beginner level: cover origins, supporting research, misconceptions, and limits of the framework

Step 2 — Plan (flow_course_structure_plan)

Inputs: course_conception (Step 1 output), learning_objectives, audience_profile, depository, course_complexity Output: Markdown — structured course outline with module/topic blueprints

Structures the concept into a Bloom's-progressive outline. Each topic gets a Blueprint with 5 fields:

Also produces a Narrative Spine (3–5 sentences) before the outline: persona, context, central conflict, stakes, desired outcome.

Key constraints:

• Bloom's progression must be explicit and sequential across modules
• Introduce each framework at full scope before narrowing
• No end-to-end projects
• Keep the full course compact: target 3 modules by default and never exceed 4
• For Beginner courses, module progression should usually map to Remembering, Understanding, and Applying; a 4th module is allowed only when the outline makes the pedagogical rationale explicit
• Module count and topic count are fixed from this step onward

Step 3 — Design (flow_course_structure_design)

Inputs: course_outline (Step 2 output), audience_profile, depository, types_list, formats_list + injections Output: Markdown — full content plan with sections per topic

Expands each topic into a list of sections. Each section gets:

• Title — unique, sentence case
• Type — from enabled types_list
• Format — from enabled formats_list
• Blueprint — a self-contained, extensively scoped prompt for an independent LLM author
• Reasoning — why this section matters for this topic

Critical design rule — blueprint independence: Different authors, each isolated from the others, will generate each section's content. The blueprint must be self-contained: it cannot assume the author has read adjacent sections. It should lock down the pedagogically necessary variables for the section: scope boundaries, factual anchors, concept labels, and assessment intent when needed, without jumping ahead into downstream production mechanics.

Injections used: structure_instructions, naming_instructions, blueprint_instructions, assessments_instructions

Runtime variables: types_list, formats_list (generated from enabled rows in the source Excel — not static injections)

Key constraints:

• Prefer the smallest number of sections that still creates clear progression, manageable cognitive load, and distinct learning moves
• Module and topic count from Step 2 must be preserved exactly — do not merge, omit, or add
• Do not fragment one teaching move across several thin sections when one well-scoped section would teach it better
• Treat pure Text as a limited fallback, not the default explanatory format
• Use pure Text mainly for structural or supporting sections such as Whats_Next, Key_takeaways or Reference_List, and only rarely for teaching material when richer image/video formats are not a better fit
• Whats_Next is the text-only exception: always keep it in a pure text format and never assign a video format to it
• Do not plan more than 2 pure Text sections within one topic
• For explanatory sections, prefer text-with-image or video formats instead of adding more pure-text sections when those richer formats fit the material
• If an assessment idea implies a concrete mechanic, UI control, or interaction pattern, Step 3 should normalize it back to outline-stage pedagogical abstraction

Step 4a — Learner feedback (flow_course_structure_feedback_learner)

Inputs: course_outline (Step 3 output), target_persona, audience_profile, pain, transformation, learning_objectives Output: Markdown — learner perspective feedback Runs in parallel with: Step 4b

Simulates a real learner reviewing the course outline. The model adopts the target persona: tired, low motivation, but genuinely wanting to grow. Evaluates:

• Topic progression clarity and logical flow
• Concept linkage and coherent storyline
• Knowledge gaps and factual errors
• Realism of examples
• Distribution and variety of sections
• Presence of a culminating moment
• Scores: consistency (1–10), curiosity hooks (count), overall (0–100)

This step uses pure roleplay — the model is the learner, not the designer.

Step 4b — Expert feedback (flow_course_structure_feedback_expert)

Inputs: course_outline (Step 3 output), types_list, formats_list + injections Output: Markdown — expert instructional design audit Runs in parallel with: Step 4a

Conducts a rigorous structural and pedagogical audit across five areas:

1. Structural accuracy — subject matter logic, module sequence, transitions
2. Concept lifecycle — introduction placement, depth balance, reinforcement, and removal of pseudo-frameworks or unauthorized labels in favor of the official widely accepted framework/concept name
3. Completeness — missing components, theoretical grounding, surface vs. deep
4. Quality — terminology consistency, formatting, instructional design standards
5. Advancement — what would make the course suitable for a more advanced audience

Delivers: score (0–100), detailed list of identified mistakes, concrete improvement recommendations.

Injections used: structure_instructions, naming_instructions, assessments_instructions

Step 5 — Refine (flow_course_structure_refine)

Inputs: feedback_learner (4a), feedback_expert (4b), course_outline (Step 3), types_list, formats_list + injections Output: Markdown — improved final course outline + list of changes

Synthesizes both feedback streams and produces the definitive course outline. Applies expert suggestions for depth and theoretical grounding. Key upgrade rules:

• New frameworks must be evidently connected to the core framework
• Core framework explained fully; supporting frameworks explained partly, in strong connection
• If an additional framework does not strengthen the course — refuse it

Blueprint hardening — all blueprints are upgraded to be unambiguous for independent authors while staying at outline-stage abstraction:

Injections used: structure_instructions, naming_instructions, blueprint_instructions, assessments_instructions

Shared variables

Shared injections

See Injections for the cross-system index.

Related guidelines

• Course design — course architecture, structural rules, and quota constraints
• Persona model — narrative character framework used in Steps 1–2
• Naming conventions — title and naming rules applied throughout the outline
• Section types — semantic types assigned in Step 3
• Section formats — presentation formats assigned in Step 3
• Outline schema — JSON shape produced by the outline generation workflow
• Course schema — JSON structure the outline must produce