An instructional designer can now go from an empty desktop folder to a working, LMS-ready training course without opening Articulate Storyline or Articulate Rise. In one worked example, Claude Code, Anthropic's AI coding assistant, scaffolded an eight-page compliance course on "Standards of Conduct," revised its interface from annotated screenshots, and wrapped the result as a SCORM 1.2 zip file that reported completion and a quiz score correctly in SCORM Cloud. The whole run took less than an hour. The process is not hands-off, though: the human sets the architecture, judges every screen, and makes the packaging decisions the AI cannot make alone.
Setting up the workspace and picking a model
The project started with nothing more than a new folder named "Course 101" on the desktop. Claude Code was pointed at that folder as its local workspace and granted write access through its "Trust workspace" prompt. Claude Code also supports cloud and remote setups, and a repository on GitHub adds version control, branching and rollbacks, but a local folder is enough to begin.
Two choices matter before the first prompt:
| Setting | Choice for the first build | Reasoning |
|---|---|---|
| Model | Opus (the picker also listed Fable 5.1, Sonnet and Haiku options) | A strong foundation is worth the higher credit cost |
| Effort level | Extra (options run Fast, High, Extra, Ultracode) | More reasoning on the initial scaffold |
The trade-off is usage. Claude Code's Settings > Usage panel shows the current 5-hour session allowance and the weekly limit; at the point it was checked, 29 percent of the session had been consumed. A sensible pattern is to spend Opus credits on the architecture and then drop to Sonnet for small fixes and styling tweaks.
A storyboard or Word document helps the model infer slide structure, but it is optional. Without one, Claude Code generates sample content on its own.
The first prompt: a slide-based player
Before writing a prompt, the course architecture has to be decided. Two common patterns exist: long-scrolling pages in the style of Articulate Rise, and discrete slide-by-slide screens closer to a presentation. The slide approach was chosen here on the judgment that scrolling courses can read like a dry textbook, while individual slides keep a learner on one idea at a time.
Claude Design, Anthropic's design prototyping interface, is useful for a different stage. It drafts themes, buttons and the HTML and CSS foundation well, but it cannot handle SCORM packaging, complex logic or dynamic interactions. A typical workflow builds the visual prototype in Claude Design first, then carries the design tokens and style guide into Claude Code for the application logic. This example skipped the design phase, which is visible in the plainer look of the first build.
The initial prompt asked for:
- An eLearning module on "Standards of Conduct"
- A persistent top player showing the course title and description
- A slide-out drawer menu listing page titles
- Bottom navigation with Back and Next buttons
- Placeholder stock photography from Pexels or Unsplash to match a corporate conduct theme
Direct one component at a time
The most important method here is how the prompts are sized. Pasting an entire curriculum into one giant prompt tends to backfire: large language models skip or ignore detailed requirements when overloaded, and enormous prompts burn through session limits quickly because the cost tracks computational effort.

▲ Directing one component per prompt
The alternative treats the instructional designer as a director. The first prompt produces the macro scaffolding: the player, the menu, the navigation. Later prompts each target one component, such as checking a menu click state or fixing a navigation button. Small, granular edits preserve quota and make problems easier to pinpoint. Follow-up changes also run noticeably faster than the initial build, because the architecture already exists.
What the first build produced
Claude Code finished the scaffold and launched a local preview at localhost:4321. Its terminal logs showed that it detected layout collisions, corrected overflowing metadata text and validated responsive layouts across viewports on its own.
The eight generated page templates were:
- Intro slide with a "Start course" button
- Learning objectives with side-by-side images
- Four-pillar conduct overview
- Tabbed workplace scenarios
- Branching scenario question (one example involved sold-out concert tickets offered by a vendor whose contract is up for renewal)
- Knowledge check with immediate feedback
- Accordion process checklist
- Summary review slide
The build also included a Resources drawer with downloadable PDF job aids. The metadata bar listed an estimated duration of 15 minutes.
Several things needed human judgment. Claude Code had sorted the menu into tabs labeled "All pages," "Introduction," "Content Page," "Scenario," "Knowledge Check" and "Summary." Technically clever, but filtering a course menu by page type may confuse learners and break the linear flow. The title slide had both a large "Start course" button and a footer Next button, a duplication that can confuse learners. Some cards had hover effects that made them look clickable when they had no click action, which is the kind of misleading cue that frustrates users. None of these are bugs the AI would flag; they are design calls.
Refining with screenshots and annotations
Claude Code's preview browser includes an annotation toolbar in the top-right corner, with a pen, arrow markers, selection boxes, a color palette and an "Add to chat" button. Drawing a red circle around an element and sending it to the chat gives the model exact visual context for a fix. A separate element selector lets you click a button or region to capture its precise DOM selector into the prompt, which removes ambiguity about which element you mean.

▲ Annotated feedback and responsive layout checks
The revision pass went component by component:
- Menu: Remove the page-type filter tabs entirely so learners see a clean sequential list.
- Header bar: Remove borders and outlines around the Resources and menu buttons, replace the text buttons with icons (a folder icon for Resources), and swap the CSS gradient for a flat, solid dark blue. Gradient navigation bars can look like software from about ten years ago. After the change, the menu and Resources panels toggled independently and closed when the other opened.
- Bottom navigation: Turn the Next and Back text buttons into circular buttons with directional arrows. Icon-only controls need no translation when a course is localized, and they do not get crushed on narrow mobile screens. Hover tooltips can still carry descriptive text for accessibility.
- Call to action: Using the element selector on the "Start the course" button, move it to the right side of the row holding the course metadata badges and restyle it as a rounded pill.
- Learning Objectives slide: Rebuild it as a 50/50 split on desktop, with the image full-bleed across the left half and vertically centered text on the right. On mobile, the image stacks on top and the text scrolls beneath.
The split layout was then checked in Chrome's responsive viewport mode across desktop, tablet and phone widths. The image snapped to the top on narrower screens and the content scrolled below it. This step is worth making a habit: every desktop layout change should be verified in mobile and tablet emulators.
One skill stands out in all of this. Knowing the exact design vocabulary, such as "pill shape," "rounded rectangle" or "full-bleed split," lets a designer direct the model far more efficiently. It is not required to get started, but it may be the single most valuable thing an instructional designer can learn for this kind of work.
Packaging to SCORM 1.2 with a skill
SCORM is the standard that lets a learning management system (LMS) launch a course and receive completion and score data. Instead of writing LMS integration scripts by hand, the course was wrapped with an Anthropic skill, invoked in the Claude Code prompt with the command anthropic.skills:scorm-cmi5-wrapper. The request asked for a SCORM 1.2 package that tracks page visits, sends completion once all pages are viewed, and passes quiz interaction results and the aggregate score to the LMS.
The skill then asked a series of configuration questions in the terminal. The choices made were:
| Option | Selection |
|---|---|
| What counts toward the score | Knowledge Check only |
| Attempt reported | First attempt |
| Status handling | "Completed, score alongside (Recommended)" |
The last choice exists because SCORM 1.2 has a single status field, so a course must decide whether to report "completed" or "passed." SCORM 2004 supports both statuses at once. Depending on how a given LMS interprets completed versus passed, SCORM 1.2 can produce reporting quirks, so this is a decision to make deliberately, ideally with the target LMS in mind.
The project's README.md acts as persistent memory across prompts. Storing project conventions and guidelines there means the agent retains those constraints in later sessions.
Testing in SCORM Cloud
Claude Code produced standards-of-conduct-scorm12.zip in the project root, alongside index.html, the assets folder and README.md. The zip was uploaded to SCORM Cloud, Rustici Software's testing platform, after clearing an older sandbox registration. Launching the course, working through the tabs and scenario screens, answering the knowledge check correctly and closing the window produced the expected telemetry: an overall status of Complete and a score of 100.00 percent, in a 38-second run.
For comparison, a fully finished onboarding course built the same way, "Welcome to Acme 101," shows how far the approach can go: an English and Spanish language switcher, lesson progress tracking in the drawer menu, audio narration with playback controls, single-select and multi-select knowledge checks, drag-and-drop sorting, completion-gated accordions, tabbed team profile cards and flip-card grids, all in a layout that reflows from desktop to phone.
Reuse: separate content from the player
The language switcher in that reference course works because all course copy lives in an external JSON file, so swapping the language means swapping text, not rebuilding the interface. The same idea enables templating. Once lesson copy and media references are pulled into JSON, the HTML and CSS player becomes a reusable shell: duplicate the project, replace the JSON payload, and a new course appears without rewriting interface code.
What to take from this
Claude Code can carry a corporate training course from an empty folder to a SCORM 1.2 package in one sitting, but the quality depends on how the human directs it. The practical pattern looks like this:
- Create a dedicated local folder, trust the workspace, and start with Opus at Extra effort for the scaffold; switch to a cheaper model for small edits.
- Decide the architecture yourself (slide-based versus scrolling) and ask for the shell first: player bar, drawer menu, navigation.
- Review each generated screen for learner-experience problems the AI will not notice, such as duplicate controls, confusing menu filters and misleading hover states.
- Use annotated screenshots and the element selector to request one change at a time, and check every layout change on tablet and phone viewports.
- Prefer icon-only navigation and JSON-stored text if the course will ever be translated.
- Run the SCORM wrapper skill, choose the scoring and status options with your LMS in mind, and verify the package in SCORM Cloud before shipping.
The result of this one example was a working, interactive module with 100 percent score reporting in under an hour. Treat that as a single case rather than a guarantee, and expect to spend most of your own time where it counts: judging what the learner will actually see.


