Automating Instructional Design FAQ

This FAQ addresses common questions about the Automating Instructional Design course, covering everything from getting started to advanced topics.

Getting Started

What is this course about?

This course teaches educators and training professionals how to transform learning objectives into interactive educational simulations called MicroSims using AI-assisted tools. You'll master the complete lifecycle of MicroSim development—from analyzing pedagogical goals through deployment and learner assessment—using Claude Code skills and visualization libraries.

The central challenge addressed is bridging the semantic gap between abstract learning outcomes and concrete interactive experiences. A learning objective like "Students will understand the relationship between supply and demand" contains implicit assumptions about visualization, interaction, and assessment that must be made explicit before any simulation can be built.

Example: Converting the abstract concept of "exponential growth" into an interactive simulation where learners adjust growth rates and see real-time population curves.

Who is this course designed for?

This course is designed for working professionals who create educational content:

K-12 teachers seeking interactive curriculum supplements
Corporate training specialists developing employee programs
Higher education faculty creating course simulations
Instructional designers at educational technology companies
Curriculum developers building standards-aligned materials
Subject matter experts making their knowledge more accessible

No programming background is required. The course teaches you to work with AI tools that generate code, focusing on specification, evaluation, and iteration rather than implementation.

What prerequisites do I need?

You need only basic computer literacy—no programming experience required. The course teaches you to specify what simulations should do, not how to code them. You should be comfortable with:

Using web browsers and basic applications
Writing clear, descriptive text
Thinking systematically about learning goals

If you can write a detailed lesson plan, you have the skills to succeed in this course.

How long does this course take to complete?

The course offers two completion paths:

Self-paced: Approximately 60-80 hours total, progressing through 12 modules at your own speed
Instructor-led: 3-4 hours per week for 12 weeks, with guided activities and peer feedback

Each module includes readings, hands-on activities, and a MicroSim project, so actual time varies based on the complexity of your subject area.

What tools and software do I need?

All required tools are provided:

Claude Code with MicroSim generation skills
Access to the MicroSim template library
A modern web browser with developer tools

You'll also benefit from having 5-10 learning objectives from your own teaching context to use as practice material throughout the course.

How is this different from learning to code?

This course explicitly does not teach programming. Instead, you learn to:

Specify what simulations should look like and how they should behave
Evaluate whether generated simulations meet learning objectives
Iterate on designs through structured refinement conversations with AI

The instructional designer's role shifts from implementation to specification and quality assurance. You describe what you want; AI generates the code.

What will I be able to do after completing this course?

Graduates can:

Produce MicroSims that effectively support specific learning objectives
Evaluate educational simulations using research-based criteria
Adapt simulation complexity for any audience from kindergarten to graduate school
Collaborate with AI tools effectively in instructional design
Build and maintain a personal library of reusable simulations
Apply universal design principles for accessible learning experiences
Conduct user testing and iterate based on learner feedback

How do I access the course materials?

The course is delivered as an intelligent textbook hosted at https://dmccreary.github.io/automating-instructional-design/. All 12 modules, practice activities, and example MicroSims are freely accessible. You'll need Claude Code access for the hands-on generation activities.

What is a MicroSim?

A MicroSim (Micro Simulation) is a small, focused interactive simulation designed to teach a specific concept or skill through exploration and visualization. Unlike comprehensive simulations that model entire systems, MicroSims target atomic concepts that can be understood in 5-15 minutes of interaction.

Example: An interactive supply-and-demand curve where learners adjust price and quantity sliders to see equilibrium points change in real-time.

What makes a learning objective "simulation-ready"?

Not all learning objectives benefit from interactive simulation. Simulation-ready objectives typically involve:

Dynamic relationships that change over time
Multiple variables that interact with each other
Abstract concepts that benefit from visualization
Cause-effect relationships that learners can explore
Common misconceptions that can be revealed through exploration

Objectives focused purely on factual recall or procedural steps may be better served by other instructional methods.

Can I use MicroSims I create in my own courses?

Yes. All MicroSims you create during this course are yours to use in your teaching. The course also teaches you how to deploy MicroSims to learning management systems, embed them in course materials, and share them with other educators under appropriate licenses.

Core Concepts

What is Bloom's Taxonomy and why does it matter?

Bloom's Taxonomy is a hierarchical classification system for cognitive complexity levels. The 2001 revision by Anderson and Krathwohl identifies six levels, using verbs to emphasize active learning:

Remember — Retrieve facts from memory
Understand — Construct meaning from information
Apply — Use procedures in given situations
Analyze — Break material into parts and detect relationships
Evaluate — Make judgments based on criteria
Create — Put elements together to form novel wholes

This matters for MicroSim design because different cognitive levels require different types of interactions. A "Remember" objective might need a matching exercise; a "Create" objective needs an open-ended design tool.

Example: An objective at the Apply level—"Calculate standard deviation for a data set"—requires an interactive calculator simulation, while an Analyze objective—"Compare sorting algorithms"—needs side-by-side visualization.

How do I decompose compound learning objectives?

Compound objectives combine multiple skills that should be taught and assessed separately. To decompose them:

Identify action verbs — Each verb represents a separate skill
List prerequisite concepts — What must learners know first?
Map dependencies — Which skills build on others?
Create atomic objectives — One measurable skill per statement

Example: "Design and implement a RESTful API with authentication" becomes: - Explain REST principles (Understand) - Design API endpoint structure (Create) - Implement basic API endpoints (Apply) - Explain authentication methods (Understand) - Implement authentication (Apply) - Integrate authentication with API (Apply)

What are the main visualization paradigms for MicroSims?

The course covers seven primary visualization paradigms:

Paradigm	Best For	Library
Animation	Motion, physics, dynamic systems, cause-effect	p5.js
Network	Relationships, hierarchies, dependencies	vis-network
Timeline	Sequences, history, processes	vis-timeline
Chart	Comparisons, trends, distributions	Chart.js, Plotly
Map	Geography, spatial relationships	Leaflet
Diagram	Flowcharts, state machines	Mermaid
Set	Classification, overlap, logic	Venn.js

Choosing the right paradigm depends on the concept's characteristics—whether it involves change over time, relationships between entities, or categorical membership.

What is Cognitive Load Theory?

Cognitive Load Theory explains how the cognitive demands of instruction affect learning, based on working memory limitations. It identifies three types of load:

Intrinsic load — The inherent complexity of the material itself
Extraneous load — Wasted effort from poor instructional design
Germane load — Productive effort building mental schemas

Good MicroSim design minimizes extraneous load (reducing visual clutter, avoiding split attention) while maximizing germane load (engaging learners in meaningful processing). Intrinsic load is managed through sequencing and scaffolding.

Example: A cluttered interface with labels far from the elements they describe creates extraneous load. Moving labels directly onto elements reduces split attention and frees cognitive resources for learning.

What is the "split attention effect"?

The split attention effect occurs when learners must mentally integrate information from physically or temporally separated sources. This increases cognitive load and impairs learning.

In MicroSims, split attention happens when: - Labels are placed in legends instead of on diagram elements - Instructions appear in one location while actions happen in another - Text explanations are separated from the visualizations they describe

Solution: Integrate related information spatially. Place labels directly on elements. Show instructions adjacent to where actions occur.

How do I identify concepts that are "simulation-ready"?

Simulation-ready concepts share these characteristics:

Dynamic behavior — The concept involves change or process
Controllable variables — Learners can manipulate inputs
Observable outcomes — Changes produce visible results
Exploration value — Trying different values reveals insights
Misconception potential — Incorrect intuitions can be tested

Not simulation-ready: Memorizing vocabulary, following fixed procedures, understanding static facts.

Simulation-ready: Exploring how interest rates affect loan payments, testing how mass affects acceleration, discovering equilibrium in supply-demand.

What is a learning graph?

A learning graph is a directed graph where nodes represent concepts and edges represent prerequisite dependencies. If concept B depends on concept A, there's an edge from A to B.

Learning graphs help instructional designers: - Sequence content appropriately - Identify prerequisite gaps - Find bottleneck concepts (many dependencies) - Create personalized learning paths

The course's learning graph contains 200 concepts across 12 categories, from Foundation Concepts to Capstone activities.

How does progressive disclosure work in MicroSims?

Progressive disclosure reveals information and complexity gradually rather than all at once. This reduces initial cognitive load while allowing access to advanced features when learners are ready.

Implementation strategies: - Start with simple defaults, offer "advanced options" toggle - Unlock features after learners demonstrate mastery - Use layered interfaces (basic → intermediate → advanced views) - Provide optional hints that can be expanded

Example: A physics simulation starts with only mass and velocity controls. After learners explore basic motion, air resistance and friction options become available.

What is the difference between intrinsic and extraneous cognitive load?

Intrinsic load is determined by: - The inherent complexity of the material - Element interactivity (how many elements must be processed simultaneously) - Learner's prior knowledge

You can't eliminate intrinsic load—calculus is inherently more complex than addition. But you can manage it through sequencing and prerequisite building.

Extraneous load is caused by: - Poor instructional design - Visual clutter - Split attention - Unnecessary complexity in the interface

Extraneous load wastes cognitive resources and should always be minimized.

What are action verbs and why are they important?

Action verbs in learning objectives describe observable, measurable behaviors that demonstrate learning. They're important because:

They make objectives assessable
They align with specific Bloom's Taxonomy levels
They guide the design of appropriate activities and assessments

Weak verbs: Understand, appreciate, know, learn, become familiar with

Strong verbs: Calculate, compare, design, evaluate, classify, construct, demonstrate

Example: "Students will understand photosynthesis" is vague. "Students will diagram the inputs and outputs of photosynthesis" is measurable.

How do misconceptions affect MicroSim design?

Misconceptions are incorrect beliefs that learners bring to instruction. They matter for MicroSim design because:

Simulations can inadvertently reinforce misconceptions if designed poorly
Well-designed simulations can reveal and correct misconceptions
Prediction prompts make learner thinking visible

Design strategy: Include edge cases and scenarios where intuitive but incorrect beliefs produce surprising results. Let learners predict outcomes before running simulations.

Example: Many students believe heavier objects fall faster. A MicroSim that only shows objects falling in sequence might reinforce this. A well-designed MicroSim lets learners adjust mass and see that acceleration is constant (in vacuum), directly addressing the misconception.

What is a specification document?

A specification document is a detailed written description of what a MicroSim should contain, how it should behave, and what it should teach. It serves as the "blueprint" that AI uses to generate code.

A complete specification includes: - Learning objective and target audience - Visual layout and elements - Interaction behaviors and constraints - Parameter ranges and default values - Edge cases and error handling - Success criteria

The quality of your specification directly determines the quality of the generated MicroSim.

What is "intent preservation" in AI-assisted design?

Intent preservation means ensuring that your pedagogical purpose survives the translation from specification to generated output. AI systems may interpret instructions differently than intended.

To preserve intent: - Be specific rather than vague ("blue circle, 50px diameter" not "colorful shape") - Include concrete examples - Specify what should NOT happen - Review generated output against original objectives - Iterate with refinement prompts when needed

What is the difference between formative and summative assessment?

Formative assessment occurs during learning to provide feedback and guide improvement. In this course: - Module reflection journals - Peer feedback on specifications - Self-evaluation using rubrics

Summative assessment evaluates learning at the end. In this course: - Portfolio project demonstrating complete MicroSim development cycle - Eight deliverables evaluated against published criteria

MicroSims can support both—embedded formative feedback during interaction, and data collection for summative evaluation.

Technical Details

What JavaScript libraries are used for MicroSims?

The course covers seven primary libraries:

Library	Purpose	Strengths
p5.js	Animations, physics, creative coding	Easy learning curve, excellent for motion
vis-network	Network graphs, dependencies	Interactive node-edge visualization
vis-timeline	Timelines, scheduling	Range-based temporal data
Chart.js	Charts, graphs	Clean defaults, responsive
Plotly	Advanced charts, 3D	Publication quality, scientific
Leaflet	Maps, geography	Tile-based, mobile-friendly
Mermaid	Diagrams from text	Flowcharts, sequence diagrams

You don't need to learn these libraries—the AI generates appropriate code. But understanding their capabilities helps you write better specifications.

How do I choose between Chart.js and Plotly?

Choose Chart.js when: - You need standard chart types (bar, line, pie, scatter) - Clean, responsive defaults matter - The audience is general

Choose Plotly when: - You need 3D visualizations - Scientific/publication quality is required - You need advanced interactivity (zoom, pan, hover details) - The audience is technical/research-oriented

For most educational contexts, Chart.js is sufficient and simpler.

What makes p5.js good for educational animations?

p5.js excels at educational animations because:

Immediate mode rendering — Easy to create frame-by-frame animations
Simple coordinate system — Intuitive x/y positioning
Built-in physics helpers — Vectors, forces, collisions
Interactive input — Mouse, touch, keyboard events
Setup/draw pattern — Clear separation of initialization and animation

Example uses: Projectile motion, wave interference, particle systems, sorting algorithm visualization.

When should I use vis-network vs. Mermaid for diagrams?

Use vis-network when: - Users need to interact with the graph (drag, zoom, click) - The graph structure changes dynamically - You want physics-based layouts - Relationships are the main focus

Use Mermaid when: - You need static diagram export - The diagram follows standard patterns (flowchart, sequence, state) - Text-based source is important - Quick prototyping is needed

How do I make MicroSims responsive to different screen sizes?

Responsive design ensures MicroSims work on desktops, tablets, and phones. Key techniques:

Use relative sizing — Percentages and viewport units, not fixed pixels
Call updateCanvasSize() — Always first in p5.js setup() function
Test at multiple sizes — Desktop, tablet, phone orientations
Simplify on small screens — Hide optional elements, enlarge touch targets
Respect aspect ratios — Some visualizations need minimum dimensions

The MicroSim generator skill handles most responsiveness automatically, but you should test generated output.

What is the structure of a MicroSim file package?

Each MicroSim in the template library contains:

docs/sims/[sim-name]/
├── index.md          # MkDocs page embedding the sim
├── main.html         # Standalone HTML file
├── [sim-name].js     # JavaScript implementation
└── local.css         # Scoped styles

The index.md file embeds the simulation using an iframe. The main.html file can be used standalone or for testing.

How do I embed a MicroSim in MkDocs?

Add an iframe to your markdown file:

<iframe src="./main.html" width="100%" height="450px" scrolling="no"></iframe>

Key points: - Never use a style attribute on iframe elements - Always add scrolling="no" - Use relative paths for portability - Test at the full local URL including repository name

What file formats does the MicroSim generator produce?

The microsim-generator skill produces:

HTML — Complete standalone file with embedded CSS/JS
JavaScript — Separate .js file for larger simulations
CSS — Scoped styles in local.css
Markdown — index.md for MkDocs embedding
Metadata — Optional JSON with learning objective and parameters

How do I test MicroSims locally?

Run the MkDocs development server:

1	`mkdocs serve`

Access at: http://127.0.0.1:8000/automating-instructional-design/

Navigate to your simulation's page. The iframe will load the main.html file. Use browser developer tools (F12) to debug JavaScript issues.

What is version control for MicroSims?

Version control tracks changes to MicroSim files over time, enabling:

History — See what changed and when
Rollback — Revert problematic changes
Collaboration — Multiple designers working together
Documentation — Commit messages explain changes

While the course doesn't teach Git in detail, it introduces version control concepts for maintaining MicroSim libraries.

Common Challenges

My specification is producing unexpected results. What should I check?

Common specification issues:

Ambiguity — "Make it interactive" vs. "Add a slider controlling temperature from 0-100°C"
Missing defaults — What values should parameters start at?
Undefined edge cases — What happens at minimum/maximum values?
Implicit assumptions — Color meanings, units, scales
Conflicting requirements — "Simple but comprehensive"

Solution: Write specifications as if explaining to someone who has never seen your subject area. Include concrete examples and explicit defaults.

The generated MicroSim doesn't match my learning objective. How do I fix this?

This is a pedagogical alignment issue. Check:

Objective clarity — Is your learning objective specific and measurable?
Interaction match — Does the interaction actually teach the skill?
Cognitive level — Does the simulation require the right level of thinking?
Feedback presence — Does the learner know when they've succeeded?

Solution: Use refinement prompts to adjust. "The current simulation shows X, but learners need to practice Y. Change the interaction so that..."

My MicroSim works on desktop but not mobile. What's wrong?

Common mobile issues:

Touch targets too small — Minimum 44x44 pixels
Hover-dependent features — No hover on touchscreens
Fixed pixel sizes — Use responsive units
Landscape assumptions — Test portrait orientation
Performance — Complex animations may lag

Solution: Test early on mobile devices. Specify mobile requirements in your specification. Use progressive disclosure to hide complexity on small screens.

Learners are confused by my MicroSim. How do I simplify it?

Signs of cognitive overload:

Learners don't know where to start
They miss important features
They make random changes without purpose
They give up quickly

Simplification strategies: 1. Reduce visible controls (progressive disclosure) 2. Add guided scenarios or tutorials 3. Increase visual contrast for important elements 4. Remove decorative elements 5. Add explicit instructions near interaction points

My MicroSim reinforces a misconception instead of correcting it. What happened?

Misconception reinforcement occurs when:

The simulation only shows expected cases
Edge cases where intuition fails are missing
Learners never see their predictions contradicted
The visualization matches the misconception

Solution: Include prediction prompts before revealing outcomes. Add edge cases that expose incorrect thinking. Explicitly contrast correct and incorrect models.

Example: A seasons simulation that only shows Earth orbiting the sun might reinforce "distance causes seasons." Add the ability to compare Northern and Southern hemispheres simultaneously to reveal the axial tilt explanation.

The AI keeps generating similar but incorrect code. How do I break the pattern?

When iterations aren't improving:

Change approach — Describe the problem differently
Provide examples — Show what correct behavior looks like
Be more specific — Add constraints and requirements
Start fresh — Sometimes regenerating from scratch helps
Manual adjustment — For small fixes, edit code directly

Example prompt: "The previous attempts had [specific problem]. Instead of [incorrect approach], use [correct approach]. Here's an example of what the output should look like: [example]."

How do I handle parameter edge cases?

Edge cases are unusual or extreme parameter values. Common issues:

Division by zero
Negative values where only positive make sense
Values that break the visualization scale
Combinations that produce undefined behavior

Specification approach: Explicitly define behavior at boundaries. "When temperature reaches 0°C, display ice formation. When approaching 100°C, show steam bubbles. Do not allow negative temperatures."

My MicroSim is too slow. How do I improve performance?

Performance issues in MicroSims:

Too many animated elements — Reduce particle count, simplify physics
Unnecessary redraws — Only redraw when state changes
Large images — Compress or reduce resolution
Complex calculations per frame — Cache computed values

For AI generation, specify performance constraints: "Animation must maintain 30fps on mobile devices. Limit to 100 particles maximum."

Best Practices

How do I write effective MicroSim specifications?

An effective specification includes:

Clear learning objective — Specific, measurable, appropriate level
Target audience — Age, prior knowledge, context
Visual description — Layout, colors, elements, sizes
Interaction behaviors — What happens when users act
Parameter ranges — Minimum, maximum, default values
Success criteria — How do we know it works?
Edge cases — Unusual situations and how to handle them

Template: "Create a MicroSim that demonstrates [concept] for [audience]. The visualization should show [visual elements]. Users can [interactions]. Parameters include [ranges]. Success means [criteria]."

What's the right level of complexity for different audiences?

Audience	Complexity Guidelines
Early Childhood (K-2)	Large touch targets, simple cause-effect, minimal text, 1-2 controls
Elementary (3-5)	Guided exploration, reading support, 2-3 controls, scaffolded
Middle School (6-8)	Abstract concepts, multiple variables, hypothesis testing
High School (9-12)	Real-world data, edge cases, more parameters
Undergraduate	Theoretical foundations, mathematical relationships
Graduate	Research applications, parameter space exploration
Corporate	Job-relevant scenarios, time-efficient, immediately applicable

How do I balance engagement and learning?

Engagement should focus attention on learning, not distract from it.

Good engagement: - Interactive elements that reveal concept relationships - Immediate feedback on learner actions - Scenarios that connect to learner interests - Appropriate challenge level

Bad engagement: - Decorative animations unrelated to content - Game elements that overshadow learning - Complexity for its own sake - Features that entertain but don't teach

When should I use prediction prompts?

Prediction prompts are most valuable when:

Common misconceptions exist
Intuition often fails
The correct answer is surprising
Making predictions activates prior knowledge
You want to reveal learner thinking

Implementation: "Before running the simulation, pause and display: 'What do you predict will happen when [parameter] changes?' After prediction, show actual results with comparison to prediction."

How do I design for accessibility?

Accessibility ensures all learners can use your MicroSims:

Screen reader support — Semantic HTML, alt text, ARIA labels
Keyboard navigation — All controls accessible via keyboard
Color independence — Don't rely solely on color to convey meaning
Reduced motion — Respect prefers-reduced-motion setting
Sufficient contrast — 4.5:1 ratio for text, 3:1 for large text
Touch targets — Minimum 44x44 pixels

How do I evaluate if a MicroSim is effective?

Use the three-lens evaluation model:

Technical Lens: - Does it work without errors? - Is it responsive across devices? - Are there bugs or broken features?

Pedagogical Lens: - Does it target the stated learning objective? - Is the cognitive level appropriate? - Do interactions support understanding?

User Experience Lens: - Is it intuitive to use? - Is it accessible to all learners? - Is engagement appropriate (not distracting)?

What makes a good user testing session?

Effective user testing includes:

Clear goals — What questions are you trying to answer?
Representative users — Match your target audience
Think-aloud protocol — Ask users to verbalize their thoughts
Observation focus — Watch what they do, not just what they say
Non-leading questions — "What are you trying to do?" not "Did you find it easy?"
Ethical considerations — Informed consent, especially with minors

How do I prioritize changes after user testing?

Categorize findings:

Priority	Criteria	Action
Critical	Blocks learning, causes errors	Fix immediately
High	Confuses most users, misaligns with objective	Fix before release
Medium	Affects some users, reduces effectiveness	Fix in next iteration
Low	Nice to have, edge cases	Defer or document

Focus on patterns across multiple users rather than individual preferences.

How do I maintain MicroSims over time?

Maintenance planning includes:

Regular testing — Check functionality quarterly
Library updates — JavaScript libraries need version updates
Content currency — Update data and examples as needed
Feedback monitoring — Collect and respond to user reports
Documentation — Record changes and rationale
Backup — Version control and backup storage

Advanced Topics

How do I create MicroSims that adapt to learner performance?

Adaptive MicroSims adjust difficulty based on learner success:

Track performance — Monitor correct/incorrect responses
Define difficulty levels — What changes between levels?
Set thresholds — When to increase/decrease difficulty
Provide feedback — Let learners know about adjustments
Allow override — Let learners choose their level

Example: A math simulation starts with single-digit multiplication. After 5 correct answers, it introduces two-digit numbers. After 3 consecutive errors, it returns to simpler problems with hints.

How can I use MicroSims for assessment?

MicroSims can support assessment through:

Embedded questions — Predict-then-test interactions
Performance tracking — Log parameter choices and outcomes
Time-on-task — Measure engagement and struggle points
Path analysis — What sequence did learners follow?
Final state capture — What did learners create or configure?

Integration with LMS systems enables grade reporting and learning analytics dashboards.

How do I design for multiple learning modalities?

Universal Design for Learning (UDL) suggests multiple means of:

Engagement: - Choice in how to explore - Relevance to learner interests - Self-regulation support

Representation: - Visual, auditory, and text options - Vocabulary support - Highlighting patterns

Action/Expression: - Multiple ways to interact - Scaffolded complexity - Feedback in multiple formats

How do I integrate MicroSims with learning management systems?

LMS integration options:

Embedding — iframe in LMS content pages
LTI — Learning Tools Interoperability for deeper integration
xAPI — Experience API for detailed activity tracking
SCORM — Legacy standard for completion tracking

For most uses, simple embedding with manual completion marking is sufficient. Advanced tracking requires additional development beyond this course scope.

How do I handle localization and translation?

Multilingual MicroSim strategies:

Separate content from code — Use JSON data files for text
Design for text expansion — Other languages may be longer
Use icons alongside text — Universal symbols help comprehension
Consider reading direction — RTL languages need layout adjustments
Test with native speakers — Translation affects comprehension

How do I create a MicroSim library for my organization?

Building an organizational library:

Establish standards — Consistent file structure, documentation
Create templates — Starting points for common types
Build a catalog — Searchable index by subject, level, type
Define workflows — Review, approval, publication processes
Enable sharing — Licensing, attribution, modification rights
Track usage — Analytics on which MicroSims are used most

What emerging technologies might affect MicroSim design?

Future considerations:

AI integration — More sophisticated generation and adaptation
Voice interfaces — Audio control and feedback
AR/VR — Immersive 3D simulations
Haptic feedback — Touch-based learning on mobile devices
Real-time collaboration — Multiple learners interacting simultaneously

This course provides foundations that transfer to emerging platforms, focusing on pedagogical principles rather than specific technologies.

How do I contribute MicroSims to the community?

Sharing your work:

Document thoroughly — Learning objectives, usage instructions
Choose a license — Creative Commons for educational content
Test accessibility — Ensure broad usability
Publish openly — GitHub, educational repositories
Respond to feedback — Maintain and improve shared resources

The educational technology community benefits from open sharing of effective MicroSims.