Agent skill

Curriculum Planner

by THU-MAIC in THU-MAIC/OpenMAIC

Plans a multi-classroom series such as a seven-day course, clarifies the brief in rounds, gets sign-off on the full lesson list, then builds each stage in a shared folder.

MITAuto-check passedEducation

Install Curriculum Planner

skills CLI
$ npx skills add THU-MAIC/OpenMAIC --skill curriculum-planner -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install THU-MAIC/OpenMAIC curriculum-planner --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/THU-MAIC/OpenMAIC.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/agent-runtime/curriculum-planner .claude/skills/curriculum-planner && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
curriculum-planner
GitHub stars
40k
Token cost
~2.8k tokens
SKILL.md length
1,755 words
Files
1
Skills in repo
25
Repo updated
First seen
Licence
MIT

At a glance

Plans a multi-classroom series such as a seven-day course, clarifies the brief in rounds, gets sign-off on the full lesson list, then builds each stage in a shared folder.

  • Works in 4 steps: create_folder for the series, named as… → For each stage, in order → Before starting a stage that builds on… → …
  • Requests for a multi-lesson course, such as a seven-day Python primer
  • SKILL.md covers ask_user ends the run, Gate 1 — Clarify, in rounds, Gate 2 — The confirmation gate and Designing the series, plus 5 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Used when a request calls for several classrooms that belong together: a short course, an onboarding track, a unit split into lessons, or a book turned into one lesson per chapter. A single stage, however large, is out of scope. The agent owns three things: getting the brief straight, getting your explicit approval of the whole lesson list before anything is generated, and carrying the series from first stage to last.

Clarification happens in two or three narrowing rounds, each one a single `ask_user` call that ends the agent's run until you answer. The first round settles who the learner is and what they want out of the course. Series-level tools are `create_folder`, `create_stage`, `move_to_folder`, `list_folder_stages` and `read_stage_outline`; per-stage work uses the normal single-stage toolset with that stage's id, and a separate `stage-design` skill governs how each stage is built.

When your agent uses it

  • Requests for a multi-lesson course, such as a seven-day Python primer
  • Building a four-week onboarding track as a set of linked classrooms
  • Turning a book into one lesson per chapter
  • Planning a semester unit that spans several lessons

Example prompts

  • “Make a seven-day beginner course on Python, one classroom per day.”
  • “Turn the book I uploaded into a lesson per chapter, and show me the lesson list before building anything.”
  • “Plan a four-week onboarding track for new support staff, with a folder that holds every stage.”

Requirements

  • The OpenMAIC classroom toolset (`create_stage`, `generate_scene`, `ask_user` and related tools)

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. create_folder for the series, named as the user would name it.
  2. For each stage, in order
  3. Before starting a stage that builds on an earlier one, read_stage_outline
  4. list_folder_stages when you need to know where the series stands — which

What it can do on your machine

Read from SKILL.md and the folder at commit 7d324aa. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Curriculum Planner loads about 2.8k tokens when it runs. Until then it costs about 121 tokens; SKILL.md has 1,755 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~121
When it runs · the whole SKILL.md, loaded when a task matches
~2.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from THU-MAIC/OpenMAIC at commit 7d324aa, republished under its MIT licence (© THU-MAIC). 1,755 words, ~2,778 tokens.

Download SKILL.mdSave it as .claude/skills/curriculum-planner/SKILL.md (or your agent's skills folder).
name
curriculum-planner
description
Multi-stage series — a request for several classrooms that belong together, like 「7 天学 Python」, a four-week onboarding track, a semester unit split across lessons, or "turn this book into a lesson per chapter". Clarifies the series brief, gets the user's explicit sign-off on the full lesson list before spending anything, then builds the stages one at a time into a shared folder. Use when the ask is a sequence of classrooms; not for a single stage, however large.
title
系列课规划

Planning and building a stage series

A series is many stages — many classrooms — that a learner takes in order. The unit of work is still one stage, and stage-design governs how each one is built. Three things are yours and only yours: getting the brief straight, getting the user's sign-off on the whole list, and carrying the series from the first stage to the last without losing the thread.

Your tools for the series layer: create_folder, create_stage, move_to_folder, list_folder_stages, read_stage_outline, and ask_user. Everything else — planning in conversation, set_roster, generate_scene, list_scenes, read_stage, patch_stage, grep_stage, edit_deck, generate_tts, the material tools, web_search, fetch_url, render_scene_preview — is the same toolset you would use for a single stage, applied with that stage's explicit stageId on every call.

ask_user ends the run

Calling ask_user turns the user's composer into a question form and stops this run. Their answer starts the next one, with the conversation intact. Two consequences shape how you clarify:

  • One round is one call. Everything you are asking at this point goes into a single ask_user — two calls back to back is two waits for one round of questions, and the second card lands on a user who is still reading the first.
  • The rounds themselves are sequential, on purpose. What you ask second depends on what they answered first: you cannot offer 「案例领域偏好:生活化小 工具 / 办公自动化 / 小游戏」 before you know they have never written code. Two or three rounds that each build on the last are how someone who knows the subject takes a brief; one giant form is a questionnaire.

Gate 1 — Clarify, in rounds

A series request is almost always underdetermined. A single sentence like 「7 天学 Python」 fixes the topic and the lesson count and leaves open everything that decides what the lessons actually contain. Work through it in two or three rounds, one ask_user per round, each round narrower than the one before.

Round 1 — where this lands. The two or three things nothing else can be decided without:

  • who the learner is — absolute beginner, someone who codes in another language, a team with mixed levels;
  • what they want out of it — a working script of their own, an exam they have to pass, a concept they can hold up in a meeting.

Put the example inside the option label: 「完全零基础,没写过一行代码」 tells the user what you mean by beginner, 「初级」 makes them guess.

Round 2 — the shape, fitted to Round 1's answers. Now ask what Round 1 made askable: how long one session is, the pace, the language of instruction, how hands-on it should be. Build the options out of what they just told you — 「零基础」 turns into 「案例领域偏好:生活化小工具 / 办公自动化 / 小游戏」, and 「平时写 Java」 turns into 「从 Python 与 Java 的差异切入,还是从语法从头讲一遍」. An option set that could have been written before their answer is the giveaway that this is a form and not a conversation.

Round 3 — the edges, and only when they are real. Whether a book, syllabus or deck they already have should be the source the series is built from; how much checking they want (a quiz per lesson, one at the end, none). Skip this round whenever neither question would change the plan.

Rules that hold for every round:

  • At most three big things per round. A round carrying six questions is the giant form again, wearing three hats.
  • Open each round by saying what you took from the last one. «既然是零基础、 每天 30 分钟,我把每课压到一个当天能跑起来的小工具» — the user has to see their answer being used. This is the whole reason several rounds read as professional rather than slow: a round that does not visibly consume the previous answers is just a second form.
  • Never ask what you already know. Anything the request settled, or that you can safely default, is stated as your decision for them to overrule rather than asked: 「默认中文讲授、每课 30 分钟,要改直接说」 costs no round at all.
  • Two or three rounds, not four. Opening a round to ask something you could have decided yourself is padding, and padding reads as stalling, not as care. When the next round has nothing load-bearing left in it, go to Gate 2.

The question IS the tool call, never the text. Writing the questions into chat prose is not asking: the user gets no answer form, only a turn that ended in a paragraph, and nothing to answer with. Two patterns are banned outright — listing the questions in narration instead of calling the tool («为确保安排合适, 请一次确认以下信息:…» followed by no ask_user, which is exactly how this gate fails), and narrating the question before asking it. The sentence you write before the gate says what you are about to do; it must not contain a question mark, and it must not preview the questions themselves.

When the request is already specific enough — the user described the audience and the shape they want, or attached the syllabus — skip this gate. Go straight to a proposal and let Gate 2 be the one place they confirm.

Gate 2 — The confirmation gate

Never start building before the user has signed off on the full series. A series of seven stages is seven times the work of one stage; the user has to see the whole plan before anything is built. This is its own round, after the clarification rounds are done — never folded into one of them, because a plan proposed before the answers are in is a plan built on guesses.

Present, in the chat, before any stage exists:

  • the series title and the number of stages;
  • every stage, one line each: its title and, in a clause, what it is for and what the learner can do at the end of it;
  • anything you decided for them that they might disagree with — the level you pitched it at, the order, what you deliberately left out.

Then call ask_user for an explicit go, and offer the obvious alternatives to a plain yes: change the count, reorder, drop or add a lesson, adjust the level. A silent or ambiguous answer is not a go. If they change something, show the revised list and ask again — a second confirmation round is far cheaper than seven stages built to the wrong brief.

The list above belongs in the chat — it is what the user reads. The ask does not. The go is an ask_user call with those alternatives as its options; a turn that presents the list and then asks «可以开始吗?» in prose ends with no way to answer, and treating that silence as consent is the one thing this gate exists to prevent. Same rule as Gate 1: no question mark in the narration, and no preview of the question you are about to ask.

Show full SKILL.md (646 more words)Show less

Designing the series

  • Progression. Each stage opens where the previous one closed. What is assumed to be known must have been taught, in an earlier stage, in a form the learner will recognize.
  • Self-contained lessons. Every stage must stand on its own as a class: a learner who takes only day 4 gets a complete lesson with its own opening, its own payoff, and enough framing to make sense. A lesson that only works as the continuation of another is not a lesson, it is half of one.
  • Review hooks. From the second stage on, open by reactivating what the learner needs from earlier — briefly, and as use rather than repetition: apply the earlier idea to the new problem instead of restating it.
  • Difficulty curve. Difficulty rises steadily and never jumps. Watch for the usual failure: three easy lessons, then one that carries the whole hard part. If one lesson is doing too much, split it and say so at Gate 2 — the lesson count is a proposal, not a constraint the user imposed.
  • Titles that say what the lesson does, in the series' own language, so the folder reads as a curriculum: 「第 3 天:把重复的活写成函数」 rather than 「Python 基础(三)」.

The execution loop

Once you have the go:

  1. create_folder for the series, named as the user would name it.
  2. For each stage, in order:
    • create_stage passing the series folder's folderId — the stage is filed into the folder in the same call, never left sitting in ungrouped — keep the returned stageId and pass it to every generation/edit/read call;
    • build it by the stage-design sequence — outline once, roster, one generate_scene per page in order, list_scenes to verify, audio checked before it counts as done;
    • after the lesson is built, list_folder_stages and check the stage is in the series folder. If it shows no folder (the folderId was dropped), call move_to_folder to file it right away — never let the whole series run to the end before noticing an ungrouped stage;
    • write one short paragraph into the chat: what this lesson ended up covering, and what the next one starts from. Three or four sentences.
  3. Before starting a stage that builds on an earlier one, read_stage_outline on that earlier stage. Read what was actually built, not what you planned to build — the outline generator's plan is never exactly your proposal, and continuity has to be against reality.
  4. list_folder_stages when you need to know where the series stands — which stages exist, in what order.

Long-run context discipline

A series is a long conversation, and everything you write stays in it. Your per-lesson recap is the series' memory: keep it about the lesson — what it teaches, what it assumed, what it left for later. Do not replay tool detail (page counts per call, ids, which tool returned what); do not re-quote outlines you already summarized; do not restate the whole series plan at every step. If you need a detail from an earlier lesson, read it back with read_stage_outline or list_folder_stages instead of keeping it alive by repetition.

When something fails

Page recovery follows stage-design; one failed page does not abort the rest of the series.

Finishing

Close with:

  • the folder link, so the user lands on the series;
  • a short series summary: the lessons that were built, in order;
  • the rework list — anything that failed or that you would build differently — or a sentence saying there is none.

stage-design governs each individual stage; this skill adds the layer above it and never replaces it — read both. If a lesson in the series has a shape of its own — hands-on, vocational, research-backed — the matching topic skill applies inside that stage. And if the subject rests on facts you would have to verify rather than recall, run deep-research BEFORE Gate 2, not after: a series plan the user approved is a plan you then have to build.

© THU-MAIC, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in skills/agent-runtime/curriculum-planner of THU-MAIC/OpenMAIC.

Open the folder on GitHubat commit 7d324aa

Compare with similar skills

Curriculum Planner next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Curriculum Planner compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Curriculum Planner this skillTHU-MAIC/OpenMAIC40k—~2.8kAutomated safety check: PassMIT
Teaching Resource Research Skillmingchen666/Reviva244—~1kAutomated safety check: PassNone
Worksheet Skillmingchen666/Reviva244—~1.1kAutomated safety check: PassNone
Competency UnpackerGarethManning/education-agent-skills840—~4.5kAutomated safety check: PassCustom licence
HTML Ppt Course Modulesanqiufong/slides-from-anything132—~1.1kAutomated safety check: PassApache-2.0
Course Builderrevfactory/harness-1001.3k—~1.8kAutomated safety check: PassApache-2.0

Similar skills

  • Find, verify, and curate teaching resources for lesson preparation.

    244 GitHub stars~1k tokensUpdated today
    EducationAuto-check passed
  • Worksheet Skill

    mingchen666/Reviva

    Create teacher-ready worksheets, guided learning sheets, preview sheets, class exercises, homework, layered assignments, remediation sheets, answer keys, and teacher notes.

    244 GitHub stars~1.1k tokensUpdated today
    EducationAuto-check passed
  • Competency Unpacker

    GarethManning/education-agent-skills

    Unpack a broad standard or competency descriptor into specific, assessable success criteria and sub-skills.

    840 GitHub stars~4.5k tokensUpdated 1 mo ago
    EducationAuto-check passed
  • HTML Ppt Course Module

    sanqiufong/slides-from-anything

    Online-course / workshop module deck — warm paper background + Playfair serif, persistent left sidebar of learning objectives, MCQ self-check page.

    132 GitHub stars~1.1k tokensUpdated today
    EducationAuto-check passed
  • Course Builder

    revfactory/harness-100

    A full production pipeline where an agent team collaborates to design online courses all at once — curriculum, lesson plans, quizzes, and hands-on labs.

    1.3k GitHub stars~1.8k tokensUpdated 6 mo ago
    EducationAuto-check passed
  • Paw Ps Knowledge Executor

    pawbytes/skill-suites

    Builder of knowledge products such as courses, ebooks, guides, memberships, and educational assets.

    113 GitHub stars~1.8k tokensUpdated 7 days ago
    Documents & OfficeAuto-check passed

More from THU-MAIC/OpenMAIC

All 25 skills in this repo
  • Guides setup, classroom generation and secondary development for OpenMAIC, the multi-agent interactive classroom, one confirmed phase at a time.

    40k GitHub stars~1.7k tokensUpdated today
    Auto-check: notes
  • Designs a Chinese K-12 classroom for one OpenMAIC stage around the core-literacy model, using authentic tasks, performance assessment and observable evidence.

    40k GitHub stars~2.4k tokensUpdated today
    Auto-check passed
  • Maps the structure of an OpenMAIC stage document so an agent can find the right path, read it and patch quizzes, widgets, actions and project pages without guessing.

    40k GitHub stars~2.4k tokensUpdated today
    Auto-check passed
  • Designs a review-and-practice lesson around an independent first attempt, targeted feedback, supported practice, a fresh independent check and a next step.

    40k GitHub stars~1.1k tokensUpdated today
    Auto-check passed
  • Derives a reusable personal skill for course-making from a representative sample of the user's own past classrooms and chat history, confirmed with them before saving.

    40k GitHub stars~678 tokensUpdated today
    Auto-check passed
  • Plans online courses so learners manipulate simulations, diagrams, code, games or 3D scenes on most pages, with slides only for the opening and the close.

    40k GitHub stars~681 tokensUpdated today
    Auto-check passed

Categories

Questions about Curriculum Planner

What does Curriculum Planner do?

Plans a multi-classroom series such as a seven-day course, clarifies the brief in rounds, gets sign-off on the full lesson list, then builds each stage in a shared folder. Used when a request calls for several classrooms that belong together: a short course, an onboarding track, a unit split into lessons, or a book turned into one lesson per chapter. A single stage, however large, is out of scope.

When should I use Curriculum Planner?

Curriculum Planner fits situations like: requests for a multi-lesson course, such as a seven-day Python primer; building a four-week onboarding track as a set of linked classrooms; turning a book into one lesson per chapter; planning a semester unit that spans several lessons.

How do I install Curriculum Planner in Claude Code?

Run `npx skills add THU-MAIC/OpenMAIC --skill curriculum-planner -a claude-code`. Or copy the skill folder (skills/agent-runtime/curriculum-planner in THU-MAIC/OpenMAIC) into .claude/skills/curriculum-planner in your project. Claude Code loads it when a task matches its description.

How do I install Curriculum Planner in Codex?

Run `npx skills add THU-MAIC/OpenMAIC --skill curriculum-planner -a codex`. Or copy the skill folder (skills/agent-runtime/curriculum-planner in THU-MAIC/OpenMAIC) into .agents/skills/curriculum-planner in your project. Codex loads it when a task matches its description.

Can I use Curriculum Planner in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add THU-MAIC/OpenMAIC --skill curriculum-planner -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/curriculum-planner, .gemini/skills/curriculum-planner, .github/skills/curriculum-planner and .opencode/skills/curriculum-planner in your project.

What does Curriculum Planner need to run?

SKILL.md names no scripts, command-line tools or credentials: Curriculum Planner is instructions for the agent only. Our summary lists: The OpenMAIC classroom toolset (`create_stage`, `generate_scene`, `ask_user` and related tools).

Does Curriculum Planner access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Curriculum Planner safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Curriculum Planner use?

Curriculum Planner is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Curriculum Planner use?

About 2.8k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Curriculum Planner?

Skills that share tags, products or a category with Curriculum Planner: Teaching Resource Research Skill (mingchen666/Reviva, 244 stars), Worksheet Skill (mingchen666/Reviva, 244 stars), Competency Unpacker (GarethManning/education-agent-skills, 840 stars) and HTML Ppt Course Module (sanqiufong/slides-from-anything, 132 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Curriculum Planner?

THU-MAIC (a GitHub organization) maintains it in THU-MAIC/OpenMAIC, which has 40,274 GitHub stars. The repository holds 25 skills in this directory. The repository was last updated on October 10, 2026.

Source: THU-MAIC/OpenMAIC on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.