Course authoring

AI Course Builder

Instructor-only, like the Course Builder Studio it builds on top of. Two different ways to have AI build a course, for two different situations: a turn-by-turn chat you steer message by message ("New course with AI" on the Courses list, or "AI Assistant" in an existing course's Studio), or a one-prompt build you describe once and walk away from ("Build course from a prompt" on the Courses list)

see One-prompt build below. This section covers the chat.

What it is

A conversational alternative to hand-building a course in the tree- based Studio: describe what you want, and the assistant builds it turn by turn by creating real modules, lessons, and exams - the same entities, use cases, and database rows the Studio itself works with, never a separate draft representation. When the assistant creates or changes something, the chat shows it as a card in the transcript - a read-only preview that looks exactly as a learner would see it, not a description of what it did. Every change is made by asking the assistant: the cards aren't editable, so the conversation is always the true history of what changed. For precise or formatting work, each card has an "Open in Studio" link - it's the same course either way - and the chat's top bar has a Studio icon (once the course exists) that opens the whole course in the Studio. Going the other way, the Studio's top bar has an assistant icon at its top right (shown when AI features are on for your workspace) that opens this course's chat, with its history. The Studio icon is dimmed while a reply is still on its way, since leaving would abandon it.

How it works

Text the assistant writes for a lesson - in the chat or in a one-prompt build - lands as one text block (with its headings, paragraphs and lists inside it), not a run of separate one-paragraph blocks. Text on either side of a code block, image or other non-text block stays as separate blocks, since something sits between them. Blocks you made yourself in the Studio are never merged.
Each message you send runs the assistant's full turn on the backend, and you watch it happen: your message appears in the transcript straight away, and a live status line says what the assistant is doing right now ("Reading your message", "Adding module "Basics"", "Writing lesson content", ...) with how long it has been going once it passes a few seconds. Anything it says along the way shows up as it goes, and the finished result - the cards for what it created or changed - appears when the turn completes. It is step-by-step, not a token-by-token typing effect (yet).
Nothing you see before the turn completes is final. If the turn fails or you leave the page part-way, none of it is kept - no half-applied edits - and the message is marked "Not sent" so you can retry.
If the live connection can't be opened at all, the message is sent the ordinary way instead and you just get the result at the end, without the live status.
You can keep typing your next message while a reply is on its way; only sending is held until it finishes.
If a message fails to send (a network or server error), it stays in the transcript marked "Not sent", with a Retry button - nothing you typed is lost.
Every module/lesson/exam the assistant creates or changes takes effect immediately - there's no separate "apply" or "insert" step. To change something it just built, ask for it in the chat ("In the lesson 'Hello', make the tone friendlier" - the Ask AI to change this button on a card starts that message for you), or open the course in the ordinary Studio and edit it by hand - it's the same entity either way. See What it can do for everything it can change, and what still needs the Studio.
For a brand-new course, the assistant's first move is creating the course itself from your description - you don't need to name or configure anything up front.
For an existing course, the assistant sees that course's current modules/lessons/exams fresh on every message, so it stays correct even if you've also been editing directly in the Studio.
The conversation is saved per course, so you can leave and come back to keep building later - reopening "AI Assistant" on that course resumes right where you left off.

Getting started and following along

Starting a new course: an empty chat shows a few example prompts (click one to put it in the message box) and optional "shape the brief" chips - audience level, length, and whether to include a final exam and/or a quiz per module. A chip simply adds a sentence to your message text (click it again, or delete the sentence yourself, to remove it), so you always see and can edit exactly what will be sent. Nothing here sends a message for you.
Result cards are read-only and fold away: each module, lesson, or exam the assistant builds is a card in the chat - the newest turn's lessons and exams start open, and older ones fold down to a one-line row ("LESSON Introduction to Flexbox") so a long conversation stays readable. Click a row to open it; a folded card only loads its content the first time you open it. A card always shows the current lesson or exam: if a later message changes it, the earlier card updates too. If the assistant adds a lesson and then writes its content in the same turn, that's one card, not two. Under each card: Ask AI to change this (puts a message about that item in the box for you to finish and send) and Open in Studio.
Ideas for modules and lessons: ask "what modules should this course have?" (or use the Recommend modules / Recommend lessons chips) and the assistant puts a card of ideas in the chat - the same ideas the Studio's Recommend buttons give, without repeating what the course already has. Nothing is created yet. Everything starts ticked; untick what you don't want and click Add N modules (or lessons) and they are created straight away, in that order. You can add a few now and the rest later - anything already added shows "added" and can't be added twice. The assistant is told what you added, so you can carry on ("write the first lesson of the second module"). After you add modules, the chat offers Recommend lessons for the module "..." chips for them, so ideas -> add -> ideas -> add is a couple of clicks. When you ask for lesson ideas the assistant picks the module from what you say. A newer card of ideas for the same thing replaces the older one, which becomes read-only.
Quick replies: chips under the latest reply. Sometimes the assistant offers its own - up to four short options that fit what it just asked or suggested - and those replace the defaults. Otherwise, once a course exists, you get "Recommend modules", "Recommend lessons", "Add another module", "Add a lesson", "Add an exam", and "Publish this course". Either way, clicking one puts the text in the message box for you to edit and send - it never sends by itself, so a stray click can't publish a course. They belong to the newest reply, so they're gone once you move on.
Course outline: once a course exists, a read-only outline of the whole course - every module with its lessons and exams, in the order the Studio shows them - sits beside the chat on wide screens (open by default; the Outline button in the top bar hides or shows it, and remembers your choice) or opens as a sheet from the bottom on a phone. It reads the course itself, not just what this conversation touched, so it is right for a course you opened in the chat that already existed, and right after a change made anywhere; it refreshes after every reply, and marks what the latest reply changed with a dot. Click an item to jump to its card in the conversation (opening it if folded); an item the conversation never touched starts a message about it instead. The small button on each row is Ask AI to change this. You can't rename or edit in the outline
- every change is a message.
Message box and transcript: the box grows as you type (Enter to send, Shift+Enter for a new line). Hovering a message shows a copy button. Scroll up to re-read and a "Latest" button appears to jump back down; new replies won't pull you away from where you were reading.

Handing the whole course to the build agent

When you ask for a whole course (several modules, lessons with real content, exams) and the assistant has enough to go on, it can offer to build it in one go instead of turn by turn - using the same background build described under One-prompt build. It asks a couple of short questions first if your request is vague.

It only proposes. A card appears in the conversation, "Build the whole course?", showing the brief the build would receive, and the assistant tells you plainly that nothing has started. A build is dozens of AI calls and takes minutes, so it never starts unless you click Start building on that card.
The brief is editable on the card - correct it, narrow it, or add what's missing before you start. What you see is exactly what the build gets.
Progress appears right in the conversation as the same live tree the build status page shows: each module as its lessons start, a check as each one is written. You can also leave and come back - after a reload it resumes live if the build is still running, or shows how it ended.
You can't send messages while it runs (you can still type the next one): the message box explains why and unlocks when the build finishes. A message sent meanwhile would make the assistant create a second course.
The chat continues on the new course. When the build finishes, the conversation switches to the course it created with all of its history intact, the outline fills in, and you can keep asking for changes exactly as with any other course. The course lands in Draft, like every course.
If it doesn't go fully to plan: partially completed keeps everything that was written (ask the assistant to write the rest, or finish in the Studio); failed means nothing was created - refine the brief and propose again, or just keep building here turn by turn. You can only run one build from a conversation at a time, and your workspace's concurrent-build limit still applies, in which case Start building tells you so.
An older proposal stops being clickable once a newer one appears or a build has started from it. A conversation that already has a course can't start a build (a build always creates a new course) - use the assistant's edit tools instead.

What it can do

Build: create a course (with a title/description), add modules, add lessons and write their content, create exams (course- or module-attached) and write MCQ/MAQ questions, and publish the course.

Lesson blocks beyond text. Besides text, the assistant can add - and later rewrite - these lesson blocks: code (with a language), matching exercises, ordering exercises (put the steps in the right order), multiple-choice and multiple-answer questions, callouts (info / tip / warning boxes), tables, flashcards (tap-to-flip study cards), accordions (expandable sections), step-by-step walkthroughs, and video, audio and attachment links. Ask for them in plain words ("add a warning callout about hot water and a table comparing the timings"); it reaches for them where they teach better than a paragraph and does not pad a lesson with them. Video, audio and attachment blocks need a full https link that you give it - it never makes one up, and asks if you haven't. Everything it writes is checked before it is saved (a question's right answer must be one of its options, table rows must line up, links must be https), so a mistake comes back to the assistant as an error to fix rather than a broken block. Images, diagrams and vocabulary-linked terms are not something it can add or change - do those in the Studio.

Change what's already there - all by asking in the chat, and always limited to the course this conversation is about:

Read first. Before revising something, the assistant looks at what is really there, so it works from the current text and not a guess.
Rename the course, a module, a lesson, or an exam.
Edit a lesson. It changes only the blocks you point it at and leaves every other block - including images, diagrams and anything it cannot edit - exactly as it was. Bold, headings and lists in the text it rewrites are preserved, and a code block, table, question, callout, ordering, matching, flashcards, accordion or step-by-step block it wrote can be rewritten too (a block keeps its own kind: it can change a table's rows, not turn a table into a callout). If a change would remove a block entirely, it tells you to do that in the Studio instead.
Reorder modules, lessons, and exams; everything around the moved item shifts to make room.
Delete - only with your confirmation. Ask it to remove a module, lesson, or exam and it does not delete anything: it puts a card in the chat saying what would be deleted (a module also takes its lessons and exams with it) with Delete and Keep it buttons, and says plainly that nothing has been deleted yet. The item is deleted only when you click Delete. After a page reload, a card for something you already deleted just says "Deleted", and any earlier preview of it in the transcript folds down to a struck-through "Deleted" row. "Keep it" only closes that card - if you reload before deleting, an item that still exists shows the buttons again, and ignoring it is harmless.
After a change, the assistant closes with a sentence about what it changed (and what it deliberately left alone).

What it deliberately doesn't do

Delete on its own, ever - see above.
Remove a single block from a lesson, or add or edit an image, a diagram or a vocabulary-linked term - use the Studio.
Rewrite an existing lesson wholesale if it contains non-text blocks, or replace an exam's questions if it has any question type other than multiple-choice / multiple-answer - both would silently erase things, so it refuses and points you to the Studio.
Stream its replies token by token (it reports its steps, not each word), or support more than one active conversation per course.

One-prompt build

Instructor-only, reachable two ways: "Build course from a prompt" next to "New course with AI" on the Courses list, or from inside the chat, where the assistant can propose it and you start it from a card (see Handing the whole course to the build agent). Always builds a brand-new course - unlike the chat, it can't extend a course that already exists.

What it is

A single-shot alternative to the chat: describe the whole course you want in one prompt, and it builds several modules and lessons with real content - and, if you ask for one, module and/or course exams - in the background, all at once, rather than one exchange at a time. Best for "I know roughly what course I want, just build a solid first draft" - the chat is still the better fit for "let's build this together, step by step" or for extending a course you've already started.

How it works

Submitting the prompt takes you straight to a status page for the build - no need to keep the tab open or watch it happen; the page updates live while it's running (Queued → Planning → Generating) and you can navigate away and come back to the same URL to check on it later.
You can watch the course actually take shape as it's built: each module appears as its own lessons start, with a checkmark once a lesson or exam is written, so you're watching the real structure form, not just a percentage.
The build plans the course's structure first (titles, modules, lessons, whether to include module/course exams), then writes real content for every lesson and exam the plan calls for - the same entities, use cases, and database rows the Studio and the chat both work with, never a separate draft representation.
A whole build typically takes a few minutes, not seconds - it's dozens of real content-writing steps, not one request.
The course always lands in Draft, exactly like every other course - nothing built this way is ever published automatically. Review it and publish when you're ready, same as any other course.
Once it finishes, the status page shows a link straight into the ordinary Studio, where everything it built is a normal, fully editable module/lesson/exam - there's nothing special about content that arrived this way versus hand-authored or chat-authored content.

If something goes wrong partway through

A build can finish in one of three states, shown on its status page:

Completed - everything the plan called for was written successfully.
Partially completed - most of it went through, but one or more individual lessons or exams failed along the way (a transient AI provider error, for example). The status page shows what failed and why, in plain language ("The AI service has hit its usage limit for the moment. Wait a minute or two, then ask again.") - not the provider's raw error payload, which is kept in the server logs for administrators. Nothing is lost - every lesson and exam that did succeed is already a real, saved part of the course - you just finish the rest by hand in the Studio, the same as writing any other lesson or exam content yourself.
Failed - the build never got past planning the course structure, so there's no course to finish; nothing was created. Try again with a clearer or more specific prompt.

There's no automatic retry of a failed step, and no way to resume a partial/failed build from where it left off - finishing it by hand in the Studio is the intended path, not a limitation to work around.

What it deliberately doesn't do

Extend or edit a course that already exists - every build creates a brand-new course. Use the chat's "AI Assistant" (in that course's Studio) to keep building on an existing one instead.
Show live token-by-token progress, or content itself, while it's running - the status page shows which step it's on ("Writing lesson 4 of 17: Loops and Iteration…"), not a preview of what's being written. Review the actual content once it lands, in the Studio.
Write diagrams, images, video/audio/attachment links, or vocabulary-linked terms - a build's lessons can hold text, code, matching and ordering exercises, questions, callouts, tables, flashcards, accordions and step-by-steps; add anything beyond that yourself afterward in the Studio (the chat can add media links if you give it the URL).
Retry a failed step automatically, or let you cancel a build once it's started.
Run more than a couple of builds at once for your organization - past that, a new build is turned away with a clear message rather than queued; wait for one to finish and try again.