AI Syllabus Design
Published Jul 9, 2026
Building a course used to mean staring at a blank page, arguing with yourself about what a beginner needs first and what can wait. Praxis924's AI Syllabus Design collapses that into a single click: you pick a technology and framework, and the system plans a complete, ordered outline from basics to advanced, then drops a draft lesson into your workspace for every topic it identified. This walkthrough is for admins building curriculum in the /admin console. By the end you'll be able to go from an empty framework to a reviewed, reorderable set of lesson drafts ready to generate.
What you'll need
- An admin account. Syllabus generation lives behind
require_admin, so learner accounts won't see it. - A Technology and a Framework already created. The domain is
Technology -> Framework -> Lesson, so the syllabus is always planned at the framework level. - A working LLM provider key. The
LLMServicesingleton picks the first configured provider by priority — NVIDIA -> Groq -> Gemini -> Hugging Face — and fails over on quota or outage. With no key at all you'll still get output, but it's deterministic placeholder content, not a real plan.
Note: Attaching a dataset to the framework first is optional here, but it pays off later. The syllabus planner works without it; the per-lesson generation step uses it for RAG grounding.
Step 1 — Open the framework
In the admin console, navigate into your Technology, then open the Framework you want to build out. This is the page that owns the lesson list. If the framework is brand new, that list will be empty — that's exactly what we're about to fill.
Step 2 — Click Generate Syllabus
Trigger the plan from the framework page. Behind the scenes the LLM is asked to design an ordered, basics-to-advanced outline for the framework's subject. It isn't just spitting out a flat list of titles — it runs a gap and granularity analysis, checking that foundational concepts come before the topics that depend on them, that nothing essential is skipped, and that no single topic is so broad it should really be two lessons (or so thin it should be folded into another).
The result is a sequence of topics, each becoming one draft lesson. Every draft is created with generation_status of pending and publish status draft — planned, but no section content or exercises generated yet.
Tip: Think of this step as producing a table of contents, not the book. It's cheap and fast because it's a single planning call, not the full per-lesson pipeline. Regenerating or tweaking the outline here costs far less than regenerating lessons.
Step 3 — Review, reorder, and prune the drafts
This is the step people skip and regret. The AI is a strong first-drafter, not the final word on your course. Walk the list top to bottom and treat it as editable:
- Reorder anything that's out of teaching sequence. The planner aims for basics-first, but you know your learners.
- Delete drafts that don't belong — off-scope topics, duplicates, or anything your audience already knows.
- Rename or adjust titles that are too broad or too vague before you spend generation tokens on them.
Because each topic is a real draft lesson row, the changes you make here define exactly what gets generated next. Curating now is the single highest-leverage move in the whole flow.
Step 4 — Generate the lessons
Once the outline reflects the course you actually want, generate the content. Each draft runs through the DBOS durable generation workflow: build a grounded source, generate the 4 sections (main_explanation, practical_explanation, key_principles, summary) — each passed through a review loop that re-improves any section scoring below 7 — then generate exercises, persist with citations, and flip the lesson to generated. You can generate them one at a time to spot-check, or bulk-generate the whole framework.
Warning: Don't generate everything before you've curated. Generation is the expensive step (multiple LLM calls per lesson, per section review rounds). Deleting a junk draft after generating it means you paid for content you throw away.
When it goes wrong
| Symptom | Likely cause | What to do |
|---|---|---|
| Outline looks generic / placeholder-y | No provider key configured | Set a provider key; the service falls back to deterministic placeholders without one |
| Generation stops partway | Provider quota / outage (LLMUnavailableError) | It's re-runnable — the durable workflow resumes from the last completed step; retry once quota resets |
| Topics feel too broad or too fine | Granularity is a judgment call | Split or merge drafts by hand in Step 3, then generate |
| A lesson came out with gaps | A section or exercise kind failed to generate | Use Fill Gaps — it regenerates only what's missing and makes zero LLM calls when the lesson is already complete |
Tip: If a topic is genuinely too large, split it into two drafts before generating rather than after — you keep the ordering clean and avoid re-running the pipeline on a lesson you're going to break in half anyway.
What you get
After these steps you have a fully sequenced framework: a curated set of lessons, each with four reviewed sections, exercises, and cited sources, moving from draft toward generated. From there the path is short — publish the lessons and they appear in /learn, where learners read them in the focused viewer, practice in /practice/[lessonId], ask Lucy for help, and have their progress tracked. The syllabus step is what turns a single decision — "teach this technology" — into a structured course you can ship the same afternoon.