If you work in learning and development, you may have seen our post on Claude AI for Learning & Development Professionals. That post covers L&D program strategy: needs analysis, vendor selection, learning culture, and measuring training ROI. This post is different. This post is for the instructional designers who build the actual course deliverables — the professionals who turn a subject-matter expert's brain into a structured, learnable experience. The builders. The people who stare at blank course templates and know exactly how many hours it takes to script module 3 before the SME review deadline hits.
A single course project generates an enormous volume of structured documents. There's the course outline, then module-by-module scripts or narration guides, knowledge checks aligned to Bloom's taxonomy, scenario branches with consequence feedback, a facilitator guide for the ILT version, a learner job aid for post-training reference, and a set of SME review notes for every draft. Every one of those documents follows a predictable structure. Every one of them starts with a blank page. Claude doesn't replace instructional design craft — the learning theory, the cognitive load decisions, the learner empathy that makes a course actually work. Claude handles the scaffolding so you can spend your hours on the craft, not the typing.
One clear line before you start: Claude is a first-draft engine for structured instructional documents, not a course authoring tool. It has no integration with Articulate Storyline, Rise 360, Lectora, iSpring, or Adobe Captivate. It cannot publish to your LMS — no Cornerstone, Workday Learning, SAP SuccessFactors Learning, Moodle, or Canvas access. It cannot see your existing course files, media assets, or SME interview recordings. It has no accessibility checker (WCAG compliance must be verified separately). And it cannot produce voiceover or audio. What Claude does: gets you from blank page to working draft, fast. The ID validates against learning objectives, reviews with SMEs, and builds in the authoring tool. That workflow hasn't changed. What's changed is how fast the blank page becomes a usable draft.
What Claude Cannot Do (Read This First)
Before walking through the use cases, the honest constraints:
- No authoring tool access: Articulate Storyline, Rise 360, Lectora, iSpring, Adobe Captivate — Claude cannot open, edit, or publish to any of these
- No LMS integration: Cornerstone, Workday Learning, SAP SuccessFactors Learning, Moodle, Canvas — no SCORM upload, no xAPI tracking, no learner completion data
- No SME content or existing files: Claude works only from what you paste into the conversation — it cannot access your shared drive, course files, or SME interview recordings
- No accessibility validation: Claude can apply accessibility best practices in text, but WCAG compliance for eLearning modules must be tested in the authoring tool and reviewed separately
- No voiceover or audio: Claude generates scripts; recording is a separate production step
Frame this correctly: Claude is a document drafting engine. Every use case below produces a structured first draft you take into your authoring tool and SME review process. The instructional design judgment is still yours. The blank page problem is solved.
1. Course Outline and Module Structure
The course outline is the first deliverable and the one that sets up everything else. A well-structured outline sequences content logically, allocates time honestly, and gives the SME something concrete to react to before you've invested hours in scripts. Claude generates a full module-by-module outline from your topic, audience, objectives, and time budget — including sequencing assumptions flagged for SME review.
Given the following inputs, draft a course outline with module titles, estimated duration per module, and 2–3 key learning points per module. Sequence modules in a logical progression from foundational to applied. Flag any sequencing assumptions for SME review with [SEQUENCING ASSUMPTION — VERIFY WITH SME].
Topic: [COURSE TOPIC]
Audience: [JOB TITLE + EXPERIENCE LEVEL — e.g., "new sales representatives with less than 6 months in role" or "mid-level project managers with PMP certification"]
Learning objectives (list all):
- [Objective 1]
- [Objective 2]
- [Objective 3]
Available time: [X hours total — e.g., 3-hour eLearning, 1-day ILT, blended 4 hours async + 2 hours live]
Prior knowledge baseline: [what learners already know coming in — or write [CHECK AGAINST PRIOR KNOWLEDGE BASELINE]]
Modality: [eLearning / ILT / blended / microlearning]
Hard rule: Do not invent learning objectives I haven't listed. Flag any module where the learning point is extrapolated from your general knowledge rather than my inputs with [VERIFY WITH SME]. Add [VALIDATE LEARNING OBJECTIVES WITH CLIENT/SME] to the learning objectives section header.
What you get: A structured outline you can hand to a client or SME for first review before you've written a word of script. The [SEQUENCING ASSUMPTION — VERIFY WITH SME] flags turn the outline into a discussion document — your SME can validate or reorder before you build. Duration estimates give the client a realistic picture of learner time investment without waiting for a full prototype. This is the deliverable that prevents scope creep from starting late.
2. Module Script / Narration Script
The narration script is the highest-volume document in any eLearning project. A five-minute module runs roughly 600–750 words of narration — and a 10-module course means 6,000–7,500 words of on-brand, pedagogically sound, SME-reviewed script before a single slide goes into Storyline. Claude drafts a complete narration script from your topic, audience, and key points — with on-screen callouts, second-person voice, and [VERIFY WITH SME] flags on every factual claim that needs expert sign-off.
Write a narration script for a 5-minute eLearning module on [topic] for [audience: job title + experience level]. The module should cover these key points:
1. [Key point 1]
2. [Key point 2]
3. [Key point 3]
Format requirements:
- Conversational language, second-person ("you"), present tense
- Include on-screen text callouts in brackets where key terms or concepts appear — format as [ON-SCREEN: term or short phrase]
- Structure into clearly labeled sections: Introduction, [Section 1 name], [Section 2 name], [Section 3 name], Summary/Key Takeaway
- Estimate word count and approximate reading time at the end
- Flag any factual claim that requires SME verification with [VERIFY WITH SME]
- Flag any example that assumes client-specific context with [CONFIRM EXAMPLE MATCHES CLIENT CONTEXT]
Hard rule: Do not invent industry statistics, regulatory citations, or product-specific details I haven't provided. Use placeholder language in brackets for any specific figure or example that needs client confirmation.
What you get: A complete, ready-to-review narration script in the format your voiceover director and SME can both work with. [ON-SCREEN] callouts tell your developer where to add text reinforcement without a separate annotation pass. [VERIFY WITH SME] flags become your SME review checklist — hand the document with the flags visible and ask your SME to address each one. The word count and time estimate at the bottom helps you manage scope before recording. For more on structuring long-form professional content, see how Claude AI handles content creation across formats.
3. Knowledge Check and Assessment Questions
Assessment items are arguably the most technically demanding document in an ID's output — each question must align to a specific learning objective, operate at the right Bloom's level, have plausible distractors that aren't obviously wrong, and include rationale an SME can validate. Writing 30 assessment items from scratch for a single course is exhausting. Claude writes structured multiple-choice items with taxonomy labels, distractors, and rationale built in.
Write [X] multiple-choice questions assessing learner understanding of [topic/module name].
For each question, provide:
1. The question stem
2. One correct answer
3. Three plausible distractors (wrong but not obviously absurd — represent real misconceptions or common mistakes)
4. A brief rationale for the correct answer (2–3 sentences explaining why it's correct and why the distractors are wrong)
5. A Bloom's taxonomy level label: remember / understand / apply / analyze
Audience: [JOB TITLE + EXPERIENCE LEVEL]
Learning objectives this assessment covers:
- [Objective 1]
- [Objective 2]
Flag any question that requires scenario-specific client knowledge you haven't been given with [CLIENT CONTEXT NEEDED].
Flag any question where the correct answer depends on a policy, regulation, or process that should be verified with [VERIFY WITH SME].
Hard rule: Do not invent regulatory requirements, product specs, or compliance thresholds I haven't provided. If a question requires specific procedural knowledge, flag it and use a placeholder.
What you get: A complete item bank with Bloom's labels built in. When your client asks "how do these questions map to the learning objectives?" you have a structured answer. The rationale section doubles as SME review documentation — your SME sees exactly why each answer is correct, not just the question and options. [CLIENT CONTEXT NEEDED] flags prevent generic questions from slipping into a course that should reference specific systems, products, or policies. This is also a pattern that applies well outside instructional design — product managers use the same structured-output discipline for feature prioritization documentation.
4. Scenario and Branching Narrative
Scenario-based learning is where instructional design gets genuinely difficult — a good scenario requires a realistic trigger, decisions that are meaningfully different (not just "right vs. obviously wrong"), and consequence feedback that teaches rather than just evaluates. It also requires deep client context: the right industry jargon, the realistic workplace pressure, the specific decision framing that resonates with the learner. Claude drafts the decision tree structure and branch consequences from your inputs. Your job is to provide enough context that the scenario feels real.
Write a decision-tree scenario for the following workplace situation. Target audience: [JOB TITLE + EXPERIENCE LEVEL].
Situation: [DESCRIBE THE WORKPLACE TRIGGER — e.g., "A customer service rep receives a complaint from a customer who wants a refund outside the standard policy window."]
Industry context: [CLIENT INDUSTRY — or write [VERIFY INDUSTRY CONTEXT WITH CLIENT]]
Jargon level: [entry-level / practitioner / expert]
The scenario should:
1. Open with a realistic trigger paragraph (3–5 sentences, first person or second person — your call based on the situation)
2. Present a decision point with exactly 3 choices:
- One clearly correct choice
- One partially correct choice (defensible but not optimal)
- One clearly wrong choice (represents a real mistake learners make — not a caricature)
3. For each branch, write consequence feedback that includes: what happens immediately, what the downstream impact is, and what the learner should take away (2–3 sentences each)
Flag any consequence that involves a compliance implication with [LEGAL/COMPLIANCE REVIEW NEEDED].
Flag any branch where the "right" answer depends on client-specific policy with [VERIFY POLICY WITH CLIENT].
Hard rule: Do not invent regulatory consequences, legal outcomes, or company-specific policies I haven't provided. Use bracketed placeholders for any system name, product name, or policy reference.
What you get: A complete branching scenario ready to map into your authoring tool. The three-choice structure is deliberate — two choices (right/wrong) don't require real judgment; three choices with a "partially correct" option force learners to reason rather than guess. The consequence feedback is written to be dropped directly into Storyline or Rise feedback layers with minimal editing. [LEGAL/COMPLIANCE REVIEW NEEDED] flags are not optional — consequence language in compliance training that hasn't been reviewed by legal is a liability problem, not just an accuracy one.
5. Facilitator Guide
Instructor-led training produces the most complex single document in an ID's workflow: the facilitator guide. A good facilitator guide isn't just talking points — it's session overview, materials checklist, detailed timing, discussion questions with expected responses, activity instructions, and a parking lot for participant questions. Writing it from scratch takes hours. Claude drafts a complete facilitator guide from your session outline, activities, and time budget.
Write a facilitator guide for a [X-hour] instructor-led session on [topic]. The audience is [JOB TITLE + EXPERIENCE LEVEL].
Include the following sections:
1. Session Overview: purpose, learning objectives, target audience, prerequisites
2. Materials Checklist: everything the facilitator needs before the session starts (slide deck, handouts, props, tech requirements — use [CONFIRM MATERIALS WITH PRODUCTION] for anything requiring physical preparation)
3. Timing Breakdown: a detailed agenda with activity name, type (lecture / discussion / exercise / debrief), and duration
4. Facilitator Talking Points: section-by-section delivery notes — not a word-for-word script, but structured guidance for each segment
5. Discussion Questions: 2–3 questions per major section, each with a sample correct response and a note on common incorrect responses
6. Parking Lot / FAQ: 5–8 questions participants commonly ask, with recommended facilitator responses
7. Contingency Notes: what to do if the session runs long, if a discussion goes off track, or if technical issues arise
Flag anything requiring product or policy accuracy with [VERIFY WITH SME/POLICY].
Flag any discussion question where the expected response depends on client-specific context with [CONFIRM ANSWER WITH CLIENT].
Hard rule: Do not invent product features, policy details, or compliance requirements I haven't provided. Use bracketed placeholders for any specific system, policy, or regulatory reference.
What you get: A production-ready facilitator guide your facilitator can walk in with. The discussion questions with expected responses section is the hardest part to write without client context — the [CONFIRM ANSWER WITH CLIENT] flags tell your facilitator exactly where they need to check with the client team before delivering. Timing is allocated across activities, not just listed as a total — this prevents experienced facilitators from compressing activities to stay on schedule. For L&D professionals managing the ILT program calendar, see our post on Claude AI for Learning & Development Professionals for how this feeds into program planning.
6. Learner Job Aid / Quick Reference Card
The job aid is the one deliverable that gets used after training ends — it's the thing on the learner's desk or bookmarked on their phone when they're doing the actual task six weeks later. A good job aid is dense with useful information and scannable in under 30 seconds. A bad job aid reproduces the course outline in smaller font. Claude drafts job aids that are structured for actual on-the-job use: numbered steps or decision nodes, a common-mistake callout, and an escalation note.
Create a one-page job aid for [task/process] that [JOB TITLE] will use on the job after completing training.
Format: Choose the most appropriate format based on the task — numbered checklist if the task follows a fixed sequence, decision flowchart if the task involves conditional judgment.
Include:
1. A clear, action-oriented heading (the task the learner is performing)
2. 8–12 steps or decision nodes, each described in plain language
3. One callout box labeled "Most Common Mistake" — describe the error and how to avoid it
4. A "When to Escalate" note at the bottom — one brief paragraph on when the learner should involve a manager, specialist, or system administrator
5. Version/date line at the bottom (use [INSERT VERSION] and [INSERT DATE] as placeholders)
Reading level: [e.g., 8th grade / professional / technical]
Industry context: [CLIENT INDUSTRY — or [VERIFY CONTEXT WITH CLIENT]]
Flag any step that references a specific system UI, screen, or button with [VERIFY AGAINST CURRENT UI/SYSTEM VERSION].
Flag any step that involves a compliance or regulatory action with [VERIFY COMPLIANCE STEP WITH SME].
Hard rule: Do not invent system names, screen labels, or process steps I haven't provided. Use bracketed placeholders for all system-specific references.
What you get: A one-page job aid that's actually usable — not a condensed version of the slide deck. [VERIFY AGAINST CURRENT UI/SYSTEM VERSION] flags on every system reference are critical: software UI changes constantly, and a job aid that references a button that no longer exists fails the learner at exactly the moment they need it most. The [INSERT VERSION] placeholder at the bottom creates the version control habit — job aids without version numbers become the document nobody trusts. For parallel approaches to structured reference content in other professional contexts, see how teachers and educators use Claude for learner-facing materials.
Why Claude Over ChatGPT for Instructional Design Work
For general productivity, the choice between AI tools is mostly personal preference. For instructional design specifically, four things make Claude the better production tool:
Context window for long-form course content. A complete course — outline, all module scripts, assessment items, facilitator guide, job aids — is easily 20,000–30,000 words of structured content. Claude's context window is large enough to hold a full course in a single session, which means you can draft module 3 while Claude still has the context from module 1. ChatGPT loses earlier content as sessions grow, which means re-prompting context repeatedly across a multi-module project. For a full tool comparison, see Claude vs ChatGPT for work.
Projects for course-level consistency. Claude Projects let you load your client intake form, audience analysis, learning objectives, brand voice guide, and SME notes once — and every deliverable you draft in that project pulls from the same context. Module scripts use the same terminology. Assessment items reference the same learning objectives. Job aids match the same reading level. Without Projects, you re-prompt context at the start of every session. With Projects, you describe the course once and every draft is already aligned. This is the biggest practical workflow advantage for instructional designers working on multi-deliverable projects.
Structured output fidelity. Claude follows complex formatting instructions reliably across long documents. Bloom's taxonomy labels stay on every assessment item through a 30-question item bank. [VERIFY WITH SME] flags stay consistently formatted through a 10,000-word script. On-screen callout formatting doesn't drift between module 2 and module 7. For instructional documents that go through multiple rounds of review — and that will eventually be formatted in an authoring tool — structural consistency prevents rework. Marketing managers use the same formatting discipline for multi-format campaign briefs, but the instructional design context is especially demanding because inconsistency in assessment items is a validity problem, not just an aesthetic one.
Conservative behavior with flagging. Claude flags when it's extrapolating beyond the information you provided — rather than filling gaps with plausible-sounding content. For instructional design, this matters more than in almost any other context: a narration script that goes to SME review and voice recording with fabricated facts in it doesn't just create a revision cycle, it creates a delay. Claude's discipline to flag rather than invent is what makes its output safe to send to SMEs without a full accuracy audit first.
4 Practical Tips for Instructional Designers
1. One project per course, loaded with your intake form and objectives. Before you draft a single deliverable, create a Claude Project and paste in your client intake form, your audience analysis, your approved learning objectives, and any style or voice guidelines the client provided. Every subsequent prompt in that project outputs aligned to those documents without re-prompting context. A 10-module course is not 10 separate conversations — it's one project with 10 drafting sessions.
2. Use [VERIFY WITH SME] as your QA workflow, not just a flag. Don't strip the flags from Claude's output before sending to your SME. Send the document with every [VERIFY WITH SME] flag visible and ask your SME to address each one directly. This is cleaner than a general "please review for accuracy" request, and it produces a documented record of what was verified and by whom. When the client asks "was this checked with the SME?" you have line-by-line evidence.
3. Prompt for Bloom's labels on every assessment item, every time. It takes one sentence in your prompt — "include a Bloom's taxonomy level label (remember / understand / apply / analyze) for each item" — and it gives you something genuinely useful: a reviewable map between your learning objectives and your assessment items. Clients and L&D stakeholders who care about alignment can see it. It also forces Claude to write at the right cognitive level rather than defaulting to recall questions for everything.
4. Script → review → record. Never skip the middle step. Claude's narration scripts read professionally. They are also first drafts built from the context you provided, which means they may contain plausible-but-wrong technical claims, examples that don't fit the client's specific context, or procedural details that don't match the current system version. The script reading well is not evidence it's accurate. SME review is not a step you skip because Claude did a good job — it's the step that catches what Claude couldn't know. Plausible is not the same as accurate, and in instructional content, the difference matters.
Related Tools and Resources
If you're exploring how AI supports adjacent professional work:
- For L&D program strategy, training needs analysis, and vendor management (the work above the course-build level), see Claude AI for Learning & Development Professionals
- For technical writers handling documentation, knowledge bases, and user-facing content with similar structured drafting challenges, Claude AI for Technical Writers covers the same document-volume problem from a different angle
- For content strategy and long-form professional writing workflows, see Claude AI for Content Creation
- For the direct tool comparison that informs which AI to use for structured professional documents, see Claude vs ChatGPT: Which AI Is Better for Work?
If you're ready to stop staring at blank course templates, The Complete Claude Playbook gives you the exact prompting workflows to go from intake form to first draft in hours, not days.
Related Posts
- Claude AI for Learning & Development Professionals — Program strategy, needs analysis, and learning culture work — the layer above the course build.
- Claude AI for Teachers and Educators — Parallel approaches to learner-facing content, lesson planning, and documentation.
- Claude AI for Content Creation — Long-form writing, voice consistency, and structured content at scale.
- Claude vs ChatGPT: Which AI Is Better for Work? — An honest tool comparison for structured professional documents.