Canvas Course Builder

Build complete Canvas course structures from a natural language description, a JSON template, or by cloning an existing course. Creates modules with pages, assignments, discussions, and proper organization in one workflow.

Prerequisites

Canvas MCP server must be running and connected.
Authenticated user must have instructor or designer role in the target course.
Target course must already exist in Canvas (this skill populates it, does not create the course itself).

Modes

This skill operates in three modes:

Mode 1: Build from Spec (default)

The user describes the course structure in natural language or provides a structured spec.

Mode 2: Build from Template

Load a saved JSON template to scaffold a course.

Mode 3: Clone from Existing Course

Read the structure of Course A and replicate it into Course B.

Steps

1. Determine Mode and Gather Input

Ask the user how they want to build:

How would you like to build the course structure?

Describe it -- Tell me the structure (e.g., "15 weeks, each with an overview page, assignment, and discussion")

From template -- Load a saved template file

Clone another course -- Copy structure from an existing course

For Mode 1 (Spec): Ask for:

Target course (code or ID)
Number of modules/weeks/units
Module naming pattern (e.g., "Week N: [Topic]")
Standard items per module (overview page, assignment, discussion, etc.)
Any module-specific variations (midterm week, final project, etc.)

For Mode 2 (Template): Ask for the template file path. Parse the JSON template.

For Mode 3 (Clone): Ask for:

Source course (code or ID)
Target course (code or ID)
Call
```
get_course_structure(source_course)
```
to read the full structure

2. Generate Structure Preview

Build a preview of what will be created and present it to the user:

## Course Build Plan: [Course Name]

### Structure: 15 modules x 4 items each = 60 items total

| Module | Page | Assignment | Discussion | SubHeader |
|--------|------|------------|------------|-----------|
| Week 1: Introduction | Overview | HW 1 (10 pts) | Week 1 Forum | Materials |
| Week 2: Fundamentals | Overview | HW 2 (10 pts) | Week 2 Forum | Materials |
| ... | ... | ... | ... | ... |
| Week 14: Review | Overview | -- | Review Forum | Materials |
| Week 15: Final | Overview | Final Project (100 pts) | -- | Materials |

### Items to create:
- 15 modules
- 15 overview pages
- 14 assignments
- 14 discussion topics
- 15 subheaders
- Total: 73 Canvas objects

Shall I proceed?

3. User Approves or Modifies

Wait for explicit approval. The user may:

Approve as-is
Request modifications (add/remove items, change naming, adjust points)
Cancel

Do NOT proceed without approval.

4. Execute Creation

Create items in dependency order:

Modules first: Call
```
create_module
```
for each module (unpublished by default for safety)
Pages: Call
```
create_page
```
for each overview page
Assignments: Call
```
create_assignment
```
for each assignment (unpublished)
Discussions: Call
```
create_discussion_topic
```
for each forum
Module items: Call
```
add_module_item
```
to link each created item to its module

Track progress and report as you go:

Creating modules... 15/15 done
Creating pages... 15/15 done
Creating assignments... 14/14 done
Creating discussions... 14/14 done
Linking items to modules... 58/58 done

If any creation fails, log the error and continue with remaining items.

5. Report Results

## Build Complete: [Course Name]

### Created:
- 15 modules
- 15 overview pages
- 14 assignments
- 14 discussion topics
- 58 module items linked

### Failed (0):
None

### Next Steps:
- All items created **unpublished** -- publish when ready
- Add content to overview pages
- Set due dates on assignments
- Run `/canvas-course-qc` to verify structure

6. Save as Template (Optional)

After building, offer to save the structure as a reusable template:

Would you like to save this structure as a template for future courses?

If yes, call

get_course_structure(target_course)

and save the output as a JSON file.

MCP Tools Used

Tool	Purpose
`list_courses`	Find available courses
`get_course_structure`	Read source course for cloning; verify after build
`create_module`	Create each module
`create_page`	Create overview/content pages
`create_assignment`	Create assignments
`create_discussion_topic`	Create discussion forums
`add_module_item`	Link items to modules
`update_module`	Publish modules when ready

Template Format

Templates are JSON files with this structure:

json

{
  "template_name": "Standard 15-Week Semester",
  "modules": [
    {
      "name_pattern": "Week {n}: {topic}",
      "items": [
        {"type": "SubHeader", "title_pattern": "Week {n} Materials"},
        {"type": "Page", "title_pattern": "Week {n} Overview"},
        {"type": "Assignment", "title_pattern": "HW {n}", "points": 10},
        {"type": "Discussion", "title_pattern": "Week {n} Discussion"}
      ]
    }
  ],
  "special_modules": [
    {"position": 8, "name": "Midterm Review", "items": [{"type": "Page", "title": "Midterm Study Guide"}]},
    {"position": 15, "name": "Final Project", "items": [{"type": "Assignment", "title": "Final Project", "points": 100}]}
  ]
}

Example

User: "Build a 15-week structure for BADM 350 with a weekly overview page, homework, and discussion"

Agent: Generates preview, asks for approval, creates 60+ items.

User: "Clone the structure from CS 101 into CS 102"

Agent: Reads CS 101 structure, generates preview for CS 102, asks approval, creates matching structure.

Notes

All items are created unpublished by default for safety.
Content is not copied when cloning -- only structure (module names, item types, organization).
For content migration, copy page bodies using
```
get_page_content
```
+
```
create_page
```
with the body.
Run
```
canvas-course-qc
```
after building to verify the structure is complete and consistent.

canvas-course-builder

NPX Install

Tags

SKILL.md Content