🤖 AI

CourseBlueprint: A Structured Pipeline for Adaptive Pedagogical Video Generation Grounded in Course Corpora

CourseBlueprint is a structured pipeline that generates adaptive pedagogical videos by grounding them in course corpora through typed intermediate representations, deterministic validation, and explicit instructional contracts to ensure prerequisite-aware sequencing, learner adaptation, and cognitive engagement.

Original authors: Md Zabirul Islam, Md Motaleb Hossen Manik, Ge Wang

Published 2026-06-23

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Md Zabirul Islam, Md Motaleb Hossen Manik, Ge Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a complex subject, like how an MRI machine works, using a video. You have two choices: you can ask a smart AI to "just make a cool video about this," or you can act like a master architect and give it a strict, step-by-step blueprint.

This paper introduces CourseBlueprint, a system that chooses the second option. It's a new way to build educational videos that actually teach, rather than just looking pretty.

Here is how it works, broken down into simple concepts and analogies:

1. The Problem: The "Improvising Actor" vs. The "Scripted Director"

Current AI video generators are like talented improvising actors. If you ask them to make a video about "X-rays," they can speak fluently and show moving pictures. But they often forget the rules of teaching. They might explain advanced math before the basics, use confusing jargon for a beginner, or just ramble without ever checking if the viewer is actually paying attention.

The authors say: "Stop improvising. We need a script."

2. The Solution: The "Typed Blueprint"

Instead of giving the AI a vague prompt, CourseBlueprint forces the AI to fill out a structured form (a "typed contract") before it makes a single frame of video. Think of this like a construction blueprint for a house. You don't just tell the builder, "Build a nice house." You give them a plan that says:

Foundation: What does the student already know?
Framing: What is the order of the rooms (concepts)?
Decor: How should we talk to this specific student (simple words vs. technical terms)?
Engagement: Where do we put the "hook" to keep them interested?

The system builds this blueprint in three specific steps:

The Scaffolding (The Ladder): It looks at a real university course (23 lectures, over 1,000 slides) and builds a map of concepts. It ensures you don't try to climb the roof before you've built the stairs. It checks for "loops" (like saying "A needs B, but B needs A") and fixes them automatically.
The Adaptive Controller (The Chameleon): It looks at who is watching (e.g., "an undergraduate student who knows some physics"). It then assigns a specific "style" to every single concept. One concept might get a "concrete, real-world" explanation, while the next gets a "technical" one, all tailored to that student.
The Engagement Generator (The Storyteller): This is the most important part. The system forces the narration to follow a strict recipe for every single idea:
1. Hook: Ask a curiosity-inducing question.
2. Retrieval: Remind the student of what they learned just before.
3. Core: Explain the new idea.
4. Analogy: Compare it to something familiar (like comparing a medical scan to a musical score).
5. Forward Link: Tease what is coming next.

3. The "Magic Trick": Reusing Real Slides

One of the biggest failures of AI video is that it tries to draw new pictures, which often look nothing like the real diagrams used in class.

CourseBlueprint has a "safety switch." If the AI finds a perfect match in the original course slides, it skips the drawing part entirely and pastes the original instructor's slide directly into the video.

Without this: The AI tries to draw a complex medical diagram and gets it wrong (0 out of 9 times it worked in their tests).
With this: It grabs the real slide (9 out of 10 times it worked). It's like the AI knowing when to stop pretending and just show the real thing.

4. The Results: Why the "Script" Matters

The authors tested this by making videos on five different medical topics. They compared their "Full Blueprint" system against a version where they removed the "Engagement" part (the hook, analogy, and story structure).

The results were dramatic:

Engagement Score: Dropped from a perfect 5.0 to a terrible 1.2. The video became boring and forgettable.
Adaptability: Dropped from 4.8 to 3.4. The video stopped feeling like it was talking to the student.
Readability: The text became much harder to read (like switching from a clear textbook to a confusing dictionary definition).
Analogies: The "No-Engagement" version almost completely stopped using analogies, making abstract concepts impossible to grasp.

The Big Takeaway

The paper concludes that structure is more important than fluency.

You can have an AI that speaks perfectly and draws beautiful pictures, but if it doesn't follow the "rules of teaching" (scaffolding, adapting, and engaging), it won't teach anything. By forcing the AI to follow a strict, auditable blueprint, CourseBlueprint turns a "cool video generator" into a "reliable teacher."

It's the difference between a friend telling a story at a party (fun, but maybe messy) and a teacher delivering a lesson (structured, clear, and designed to make sure you learn).

Technical Summary: CourseBlueprint

Problem Statement

While generative text-to-video systems have achieved high visual fluency, they frequently fail to encode Pedagogical Content Knowledge (PCK) required for effective instruction. Current approaches typically treat instructional video as generic content generation, relying on ad-hoc prompt chaining to produce outlines and scripts. This results in videos that lack:

Prerequisite-aware sequencing: Concepts may appear in arbitrary orders.
Learner-adaptive depth: Explanations often remain static regardless of the learner's persona.
Sustained cognitive engagement: Instructional moves (e.g., hooks, analogies, retrieval prompts) occur incidentally rather than systematically.

Furthermore, existing retrieval-augmented generation (RAG) methods often ground only the text, leaving the visual layer vulnerable to "drift," where generated images diverge from the source material despite correct textual grounding.

Methodology

The authors propose CourseBlueprint, a retrieval-augmented pipeline that replaces free-form prompt chaining with typed instructional contracts. The system operates on an undergraduate biomedical imaging corpus (BMED 2300; 23 lectures, 1,116 slides) and processes a topic and learner persona to generate a structured teaching blueprint in a single forward pass.

Core Architecture

The pipeline consists of three coordinated components:

Pedagogy Core: Converts inputs into validated, typed intermediate representations.
- Scaffolding Module: Constructs a prerequisite-aware concept graph. It extracts concepts, predicts directed prerequisite edges, and assigns nodes to five pedagogical stages (motivation, prereq-recap, core-build, application, synthesis). A deterministic cycle-breaking algorithm (greedy removal of minimum-confidence edges) ensures the graph is a Directed Acyclic Graph (DAG).
- Adaptive Style Controller: Assigns per-concept style specifications (depth, vocabulary, example density, abstraction, analogy use) based on the learner persona. These are validated against closed enumerations.
- Engagement Generator: Produces narration following a strict hook → retrieval → core → analogy → forward contract. Each narration is bounded (150–220 words) and must include specific instructional moves (e.g., a curiosity gap, a callback to prior concepts, and a forward link).
- Optional Verifier: An atomic-claim extraction and verification step to check factual grounding against retrieved sources (disabled in main experiments to control cost).
Audiovisual Stack: Renders the blueprint into a video.
- Deterministic Slide-Image Override: Instead of relying on fragile prompt markers to request specific images, the system uses a slide-hints map. If a retrieval match exceeds a similarity threshold ( $\tau=0.78$ ), the renderer directly inserts the original instructor's slide image, bypassing text-to-image generation. This ensures visual grounding.
- Synthesis: Text-to-speech generates narration, which is aligned to word-level timings and composited with slides using MoviePy.
Evaluation Harness: Combines repeated LLM-judge scoring (1–5 scale) with regex-grounded objective metrics (counts of analogies, retrieval prompts, Flesch readability).

Key Contributions

Typed PCK Pipeline: A system integrating scaffolding, adaptation, and engagement into a single forward pass using validated intermediate representations (Concept Tree, Styled Tree, Enriched Script, Course Blueprint). This makes the instructional plan inspectable and supports controlled ablations.
Deterministic Slide-Image Override: A mechanism that replaces prompt-based image selection with direct corpus-slide insertion based on retrieval confidence, significantly improving visual grounding.
Reusable Benchmark: A release of the BMED 2300 corpus (1,116 slide-transcript pairs), a FAISS retrieval index, and an evaluation harness combining LLM judges with objective metrics.
Empirical Evidence on Engagement: Demonstration that structured engagement is a "load-bearing" component of pedagogical video generation, significantly influencing adaptation and readability metrics.

Results

The system was evaluated on five in-corpus topics (e.g., filtered back projection, MRI relaxation) using a single undergraduate persona. The study compared the full system against an ablation where the Engagement Module was disabled (replaced with single-sentence fallbacks).

Key Findings:

Engagement Scores: Removing the engagement contract caused the LLM-judge engagement score to drop from 5.00 to 1.20.
Adaptation Scores: The adaptive score dropped from 4.80 to 3.40, indicating that the engagement generator is necessary to realize the adaptive style controller's specifications in the final narration.
Objective Metrics:
- Analogies: Dropped from 20.0 to 0.2 per video.
- Retrieval Prompts: Dropped from 18.6 to 0.0 per video.
- Flesch Readability: Decreased from 38.0 to 19.8.
- Narration Length: Reduced from ~2,089 words to ~192 words.
Visual Grounding: The slide-image override improved corpus-slide recovery from 0/9 (using marker-based prompts) to 9/10 (using the deterministic override) on the same topic.

Significance and Claims

The paper argues that pedagogy must be treated as a first-class constraint in generative video systems. The primary significance of CourseBlueprint lies in its demonstration that:

Structured Engagement is Critical: Engagement is not merely a surface feature; it is the mechanism through which adaptation and readability are realized in the final artifact.
Typed Contracts Enable Auditability: By replacing prompt chaining with typed intermediate representations, the system makes scaffolding, adaptation, and grounding auditable and ablation-friendly.
Visual Grounding Requires Determinism: Relying on prompt markers for visual selection is fragile; deterministic overrides based on retrieval confidence are necessary to prevent visual drift from source material.

The authors conclude that while surface fluency is achievable, effective instructional video generation depends on explicit, typed instructional contracts that enforce pedagogical structure. The paper acknowledges limitations, including the use of a single model family for judging (risk of self-preference), the lack of human learner evaluation, and the narrow scope of topics and personas, framing these as direct extensions for future work.