Skip to content

Index

LernWerkstatt is a web-based application for generating interactive learning units from an informally stated learning intent. Two free-text fields and optional source documents yield a self-contained course with chapters, lessons, exercises, a glossary and a final test — delivered as a single HTML file that runs without an internet connection. Generation passes through eight phases with two checkpoints at which the plan can be corrected before production begins. A deterministic verification layer separates model-generated content from independently checkable content.

At a glance

  • Generate a complete learning unit from a topic and your own prior knowledge — from topic planning to the finished file in a single tool.
  • Upload teaching material (PDF, Word, PowerPoint, HTML, Markdown, CSV, plain text) and have a unit built on those documents.
  • Draw on 18 building blocks — from text, tables and diagrams through quizzes, cloze exercises and flashcards to simulators with sliders.
  • Inspect and correct the plan before generation: which topics at what depth, in which order, building on one another.
  • Produce learning units in five languages (German, English, French, Spanish, Italian).
  • Pass on, print or use the result offline as a single HTML file — with full-text search, glossary tooltips and direct links.
  • Regenerate individual chapters without touching the rest of the unit.
  • Export the chapter texts additionally as a Word document.

Highlights

Unlike a direct LLM prompt or a thin script around an API, LernWerkstatt delivers a planned learning unit rather than a generated text. The following characteristics distinguish the application from simpler alternatives and directly affect the quality of the result:

  • Topics are derived, not dictated — The user does not supply an outline; the application derives it from prior knowledge and learning goal. A gap analysis determines which concepts are needed, which build on one another, and where new knowledge collides with existing beliefs. Where something stays unclear, it asks rather than guesses.
  • Depth of treatment follows the learning goal — Each concept receives one of four treatment classes (full derivation, compact, definition only, glossary only). This classification governs scope, model choice and exercise obligations. Someone asking about the purpose of a thing therefore does not receive a complete account of its mechanics.
  • A binding narrative thread as its own document — Before production, a concept graph is built with exactly one introduction site per concept, named prerequisites and points of reuse. It is checked for cycles and ordering violations and is editable. Every text section derives its assignment from it — what it introduces and what it must not anticipate.
  • 18 building blocks across four reliability stages — From deterministic JSON configuration (text, tables, quizzes, flashcards) through declarative grammars (Mermaid diagrams, Chart.js and Vega-Lite graphics, formulas as MathML) to verified computational functions (simulators) and sandboxed widgets. The rule "lowest sufficient stage" is anchored in the prompt and checkable in the validator.
  • Simulators with trial execution — For relationships better explored than read, a pure computational function with declared parameters is produced. Before delivery it is trial-run in a sandbox with a time limit; infinite loops and unevaluable code surface there rather than on the learner's screen.
  • Source documents as authority, with provenance — Uploaded documents determine the terminology used and serve as the reference for fact checking, which covers table cells and chart values as well. With an embedder and reranker, a coverage analysis maps supporting passages to each concept and conversely surfaces material missing from the plan. Every concept carries a provenance note: from the documents, or from the model's general knowledge.
  • Terminology control across chapter boundaries — A register separates established terms from newly appearing candidates; only established terms become binding for later chapters. What is checked is whatever the text treats as a term — glossary entries, concept names, definition patterns — not every capitalised word. Self-coined terms are verified against the documents and replaced.
  • A deterministic verification layer without model calls — Before release, a validator checks schema, block contracts, quiz logic (exactly one correct answer in single choice, no duplicates), uniqueness of matching pairs, consistency of chart data, cloze answers readable from the surrounding sentence, interaction density and language breaks. Models are consulted only where judgement is required.
  • Repair and degrade rather than block — Format errors are fixed deterministically before anything is checked. Whatever remains broken is replaced by its own description as text instead of failing a complete unit; the report states what was substituted. Failed sub-steps produce fallback plans rather than an abort.
  • Delivery without third-party requests — Chart.js, Mermaid and Vega-Lite are embedded in the file, and formulas are set as MathML at build time. The learner's browser contacts no external service. Full-text search, direct links, a filterable glossary, print formatting and consistent ARIA markup are included.
  • Production independent of the browser window — Runs take up to an hour and continue server-side when the window is closed. Resumption is fine-grained: not only completed chapters are saved but also the output of individual text sections and every finished lesson.
  • Connection to in-house models — The application addresses OpenAI-compatible endpoints for two separate model roles, plus optional embedder and reranker. Learning content and uploaded documents need not leave your own infrastructure.