Most of what gets written about AI authoring tools is aimed at people who have never built a course before. The promise is always some version of the same thing: paste in a document, click generate, get a course. That capability is real and useful — we wrote about it here — but it is not the most interesting thing about LearnBuilder for someone who already knows instructional design.
This post is for the people who know what a branching scenario is and why it matters. Who have spent time in Storyline wiring up triggers. Who understand the difference between a knowledge check and a performance-based assessment. And who are wondering whether LearnBuilder has enough depth to be worth adopting — or whether it is just another tool built for beginners that you will outgrow in a month.
The short answer is that LearnBuilder was designed with this question in mind. Here is what the authoring environment actually gives you.
AI Dialogue: scenario-based learning without the branching overhead
Scenario-based learning is one of the best-evidenced approaches in instructional design. It is also one of the most time-consuming things to build well. A realistic branching scenario in a traditional authoring tool involves writing multiple response paths, anticipating learner choices, creating consequence slides for each branch, and testing the whole thing for logic errors. For a single scenario of moderate complexity, that can easily be a day's work.
LearnBuilder's AI Dialogue block approaches this differently. Instead of pre-authored branches, the learner interacts in free-form text with AI-played characters. You write the scenario context and define the characters — their name, role, and how they should behave — and the AI plays them dynamically throughout the conversation. The learner can say anything. The scenario responds accordingly.
This shifts the design effort from writing every possible path to writing a strong scenario and clear learning outcomes. The learning outcomes you define are what the Assessment Agent evaluates against when the dialogue ends — it scores the conversation and gives the learner written feedback. As the designer, you set the passing threshold.
A few things worth knowing for design purposes:
Character poses. Characters can be rendered standing (as a cutout against a background) or sitting, where the system composites them naturally into a desk or workspace setting. Individual emotion variants can be regenerated if they don't look right, without affecting the rest of the character.
Observer mode. You can set a dialogue to observer mode, where the learner watches two AI-played characters have a conversation rather than participating. This is useful when you want to model a scenario — show what good looks like, or deliberately show a failure — before asking learners to practice themselves.
Linked dialogues. Dialogues can be chained into multi-part sequences. The context carries over from one to the next, so you can design a scenario that unfolds in stages.
Audio input. Learners can speak their responses using a microphone instead of typing. This is particularly well-suited to language training, presentation coaching, or any scenario where verbal communication is specifically what you are trying to develop.
The honest limitation: the AI Dialogue block is powerful for naturalistic conversation practice, but it is not the right tool for every scenario. If your use case requires very tightly controlled decision points — where the specific choice the learner makes should determine a specific consequence — the Interactive Slides block (below) gives you that precision.
Interactive Slides: a canvas editor with a full trigger-action system
If you have used Articulate Storyline, the Interactive Slides block will feel immediately familiar. It is a visual canvas editor where you place and position elements freely, then wire up behaviors using a trigger-action system.
The trigger list covers what you would expect — click, hover, hover out, double-click — plus video events (play, pause, ended, specific timestamp), drag-and-drop events (drag start, drop, correct drop, incorrect drop), timer completion, scroll position, and animation completion. Actions include navigation between slides, show/hide/toggle on individual elements or element groups via tags, text input validation, variable manipulation, timer control, and video playback control.
Variables are a first-class element type. You can place a variable on the canvas and wire up actions to increment, decrement, toggle, or reset it — which means you can build scored activities, track multi-step choices, and display results on a dedicated slide. The scoring system has dedicated score, maxScore, and passingScore variables built in.
The element library covers text, images, video, audio, shapes, icons, buttons, text inputs, textareas, checkboxes, drag items, drop zones, timers, variables, scroll containers, and Lottie animations. Scroll containers are worth noting specifically: they let you create a scrollable region inside a fixed-size slide — which is how you would build a simulated email inbox, a document review interface, or any other content that needs to scroll within a defined space.
A few interaction design details that experienced designers will care about:
Element tags. You can tag multiple elements with a shared label and then target the tag in actions. A single "hide" action can hide every element tagged feedback-correct or option at once, rather than wiring the same action to each element individually.
Element animations. Independent of trigger interactions, elements can have looping animations: pulse, bounce, float, shake, wiggle, spin, fade, glow. These are useful for drawing attention to an element or giving a simulation life without requiring a trigger.
Multi-select editing. Shift-click or drag-select to select multiple elements and change shared properties (fill, stroke, text color, font size) across all of them at once. Useful for consistency across answer buttons or feedback elements.
Lottie animations. You can import .lottie or .json animation files from LottieFiles or After Effects (via Bodymovin), control them via triggers, and use the Animation Complete trigger to fire subsequent actions when a sequence finishes.
AI generation. The fastest path to an Interactive Slides build is the Generate with AI button. You describe the simulation you want — a phishing email checker, a compliance decision tree, a software walkthrough — and the AI generates the full slideshow including elements, triggers, actions, and scoring. It is not always production-ready, but it gives you a working skeleton to refine rather than a blank canvas to start from. The Help Me Plan option is worth using before generating: it asks clarifying questions about scope, audience, and interaction style, which improves the output meaningfully.
Interactive video: quiz and text cuepoints embedded in the timeline
Video blocks in LearnBuilder support cuepoints — moments in the video timeline where additional content appears.
There are two types:
Text cuepoints overlay a callout or annotation at a specific timestamp. Useful for adding context, highlighting something on screen, or flagging a key point without interrupting playback.
Quiz cuepoints pause the video at a specific timestamp and present a question. The video resumes after the learner answers. This is a straightforward implementation of a technique with solid research support — embedding retrieval practice inside video content improves retention compared to end-of-video quizzes, because the question fires while the content is still active in working memory.
Cuepoints work on uploaded video files. YouTube and Vimeo embeds are also supported in video blocks, though cuepoints require uploaded files.
Talking Head video: lip-synced presenter video from a portrait and script
Talking Head generates a lip-synced video from a character portrait and a text script. You pick a portrait image (upload, stock, AI-generated, or a course character), write the script, choose a voice, and optionally add a scene variation prompt to change the background or setting between videos — useful for avoiding visual repetition across multiple videos in a course.
The system generates VTT subtitles automatically from the script, which means every generated video is accessible out of the box rather than requiring a manual caption step.
From an instructional design perspective, Talking Head is most useful for instructor-style presentations, scenario introductions, and character voices in content that doesn't need full AI Dialogue interactivity. It is faster than recording video and sidesteps the production overhead of camera, lighting, and editing — which matters when you are building a course with ten or fifteen video segments.
Custom Embed: HTML/CSS/JavaScript when nothing else fits
The Custom Embed block lets you write or generate arbitrary HTML, CSS, and JavaScript that runs inside a sandboxed iframe within the lesson. You can also upload files (images, data files) and reference them in code via EmbedFiles.get('filename').
AI generation is available here too: describe the activity in plain language and the AI writes the code. You can iterate with follow-up prompts to refine. For IDs who are not developers, this is a useful capability — the AI can produce working interactive content from a clear description.
Where Custom Embed earns its place is for things that do not fit the standard block types: custom calculators, branded interactive infographics, mini-games, mock interfaces for software training, or any interaction with unusual requirements. It is an escape hatch that experienced designers occasionally need.
AI Assessment: grading open-ended responses at scale
The Assessment Agent grades short-answer questions, essay responses, and AI Dialogue conversations. For quiz questions, you define a model answer and criteria; the agent evaluates each learner's response against them and provides written feedback.
For IDs, this changes the cost calculation on open-ended practice. The main reason knowledge checks in most courses are multiple-choice is not that multiple-choice is pedagogically ideal — it is that open-ended responses require a human to read and grade. The Assessment Agent makes it practical to include short-answer questions in a self-paced course and have every learner receive individualized written feedback. That is a meaningful capability for courses where the learning objective is something more than fact recall.
Accessibility checker
The lesson editor includes a built-in accessibility checker that flags issues against WCAG standards before you publish. It catches missing captions on video blocks, missing alt text on images, hover-only interactions that are not keyboard accessible, and low-contrast elements, among others. Each issue links to the relevant WCAG rule.
For designers working to accessibility requirements — whether regulatory or organizational — having this built in is more useful than checking after the fact.
SCORM / xAPI import
If you have existing content in Storyline, Rise, iSpring, or any other tool that exports a valid SCORM or xAPI package, the SCORM/xAPI block imports it directly. The package runs inside the lesson and completion and scores are recorded in the learner dashboard.
This matters practically because migration is never all-or-nothing. You may have a library of Storyline content you are not going to rebuild from scratch, alongside new content you are building in LearnBuilder. The import block means those can coexist in the same course.
What AI actually does in LearnBuilder for experienced designers
Worth being explicit about this, because "AI-powered authoring tool" has become a category claim that covers everything from genuine capability to marketing language.
In LearnBuilder, AI does three things that are genuinely useful if you already know what you are doing:
It accelerates the build, not the design. The Creator Agent can generate a course outline, write lesson content, create images, produce talking-head videos, and build Interactive Slides simulations from a description. None of that replaces instructional analysis or learning objective design — it starts from what you give it. If you feed it well-structured learning objectives and good scenario context, you get a usable first draft. If you feed it vague inputs, you get vague output.
It enables things that would otherwise require significant production overhead. AI Dialogue scenarios and Talking Head videos require resources (writers, actors, video production) at scale in a traditional production process. The AI equivalent is not the same as a professionally produced scenario — but it is closer than nothing, available in minutes, and iterable.
It grades what you cannot grade at scale. The Assessment Agent makes open-ended practice genuinely viable in a self-paced course. That changes what you can include without inflating review time.
If you are an instructional designer evaluating whether LearnBuilder fits your practice, the free trial is the best place to form a view. The AI Dialogue block and Interactive Slides builder in particular are the features that tend to answer the question — they are where the depth of the tool shows up most clearly.