cloudpedagogy

The CloudPedagogy Course Engine is an open-source, command-line system that compiles a single, structured course specification into interactive course websites, PDFs, and governance-ready artefacts.

It is designed for educators, researchers, learning designers, and institutions that need consistency, traceability, and accountability in how learning materials are authored, published, reviewed, and maintained over time.

---

What it does

The Course Engine turns authored source materials into reproducible learning artefacts.

From one source of truth, it can generate:

• 🌐 Interactive static course websites
• 📄 Single-page HTML handouts
• 📘 Print-ready PDF outputs
• 🧾 Structured Markdown export packages
• 📦 Governance and audit packs (facts-only, non-evaluative)

All outputs remain aligned because they are compiled from the same source, not maintained separately.

Update the source → rebuild → everything regenerates consistently.

There is no duplication, no manual reformatting, and no drift between “web”, “PDF”, and archived versions over time.

---

Automatically generated interactive course websites

Interactive course websites are automatically generated from a single, structured specification (course.yml) and Markdown or Quarto lesson sources provided by the author.

There is no separate website authoring step.

The website is a compiled output, regenerated deterministically whenever the source content changes.

Each site is:

• multi-page and fully navigable
• static (safe to host anywhere, including institutional servers or S3)
• entirely derived from the authored source content
• reproducible at any point in time

This makes course websites easy to publish, archive, review, and regenerate without web development expertise.

---

A single source of truth

At the centre of every course is a single file:

course.yml

This file declares:

• course structure (modules, lessons)
• metadata and versioning
• optional design intent
• optional AI scoping boundaries
• optional framework and capability alignment

Lessons themselves are authored as:

• Markdown (.md), or
• Quarto (.qmd) files

All lesson sources are tracked, and provenance is recorded automatically during the build.

---

Explainability and inspection (built in)

Every build produces a machine-readable manifest.json that records:

• exactly what was built
• from which sources
• with which declared intent
• under which structural assumptions

You can inspect this using:

course-engine explain dist/my-course

Two explain modes

• Source explain (from course.yml)
• Strict, pre-normalisation, author-focused
• Artefact explain (from built outputs)
• Canonical, manifest-backed, governance-authoritative

This separation supports both authoring workflows and QA / governance review without conflating the two.

---

Governance snapshots (v1.21+)

From v1.21 onward, the Course Engine supports deterministic governance snapshots.

A snapshot is a facts-only, diff-friendly record of course state, suitable for:

• CI pipelines
• change tracking
• audit evidence
• governance review

course-engine snapshot dist/my-course --format json

Snapshots:

• do not build or render content
• do not enforce policies
• emit stable hashes and declared metadata only

They complement explain by providing a machine-friendly state record.

---

Governance packs

The Course Engine can generate governance packs from an existing build:

course-engine pack dist/my-course --profile audit

Governance packs may include:

• factual summaries
• explain outputs (text + JSON)
• manifests
• capability reports

They are designed for:

• QA and review committees
• accreditation evidence
• institutional handover
• long-term archiving

All contents are deterministic and non-evaluative.

---

What makes this different

There are adjacent tools, but nothing that combines all of the following in one coherent, working system:

Rather than treating learning materials as documents or UI artefacts, the Course Engine treats them as versioned, inspectable specifications that can be compiled into artefacts — much like software is compiled from source code.

---

Designed for people, not automation theatre

The Course Engine prioritises:

• determinism over “smart” automation
• transparency over hidden logic
• human judgement over enforced pedagogy

It records facts, not verdicts.

The engine makes structure, intent, and declared alignment visible — but it does not evaluate teaching quality, impose frameworks, or replace institutional governance.

---

Who it’s for

For educators and learning designers

• Write once in Markdown
• Regenerate websites and PDFs automatically
• Keep content aligned across formats
• Record design intent without affecting delivery
• No web development knowledge required

For researchers

• Publish structured learning resources reproducibly
• Archive static course sites alongside research outputs
• Track evolution of material over time
• Support transparent AI positioning and methodology

For QA, governance, and leadership

• Inspect declared alignment and intent
• Compare course states across versions
• Generate defensible evidence without manual reconstruction
• Separate human judgement from technical enforcement

---

Open source by design

The Course Engine is released as open-source infrastructure under the MIT License.

This is intentional.

Governance tools must be:

• inspectable
• auditable
• explainable
• trustworthy

Frameworks, interpretations, and training materials are provided separately under the CloudPedagogy programme.

---

See it in action

🔗 GitHub repository
https://github.com/cloudpedagogy/cloudpedagogy-course-engine

🌐 Live demo: interactive course site

This demo site was automatically generated from a single, structured course source

(a Scenario Planning and Environmental Scanning.docx), using the CloudPedagogy Course Engine.

The site is a compiled output — not manually authored — and includes

build provenance and governance metadata recorded at generation time.

→ View live demo

---

Ongoing development

The Course Engine is evolving carefully and deliberately.

Future development focuses on:

• stronger internal consistency checks
• clearer governance profiles
• deeper auditability — not feature sprawl
  Development is open and transparent.
  End users and institutions can follow progress, releases, and design decisions via the GitHub repository.

The goal is long-term institutional reliability, not short-term novelty.

---

Build once.

Regenerate everywhere.

Govern with clarity.