Prinzipien guter Lehre

Evidenzbasierte Strategien für das Instruktionsdesign

Andrew Ellis

11 März, 2026

Gedächtnis-Aktivierung nach der Mittagspause (1/2)

Schreibe drei zentrale Konzepte vom Vormittag auf, ohne nachzuschauen.

Einstieg: “Willkommen zurück. Bevor wir weitermachen, ein kurzes Experiment.”

Kernbotschaft: Ohne Nachschlagen aufschreiben. Es geht nicht um Vollständigkeit, sondern um den Abrufversuch selbst. Timer starten, Stille aushalten.

Überleitung: “Vergleicht jetzt mit eurem Nachbarn.”

Gedächtnis-Aktivierung nach der Mittagspause (2/2)

Vergleiche mit deinem Nachbarn. Wo gibt es Überschneidungen, wo Lücken?

Ihr habt gerade Retrieval Practice angewendet. Heute Nachmittag schauen wir uns an, wie solche Prinzipien ins Instruktionsdesign einfliessen.

Einstieg: “Was habt ihr bemerkt? Überschneidungen? Überraschende Lücken?”

Kernbotschaft: Kurz Beobachtungen sammeln. Dann Fragment aufdecken: Was ihr gerade gemacht habt, hat einen Namen. Das war Retrieval Practice. Wir schauen uns heute an, warum das funktioniert und wie man es systematisch einsetzt.

Überleitung: “Fangen wir an mit dem Instruktionsdesign auf Basis der CLT.”

CLT-basiertes Instruktionsdesign

Worked Example Effect

Anfänger lernen mehr aus durchgearbeiteten Beispielen als aus eigenständigem Problemlösen (Sweller 1988).

Warum?

• Problemlösen bei Anfängern = ineffiziente Suchprozesse (Means-Ends Analysis)
• Hohe extrinsische Last, wenig Kapazität für Schemabildung
• Worked Examples zeigen Lösungswege direkt und entlasten das Arbeitsgedächtnis

Fading: Der Übergang

Phase	Format
Anfang	Vollständig durchgearbeitetes Beispiel
Mitte	Lückenhafte Beispiele (Completion Problems)
Ende	Eigenständiges Problemlösen

Expertise Reversal Effect: Fading passt die Unterstützung an den wachsenden Wissensstand an.

Einstieg: “Der erste CLT-Effekt: Worked Examples. Denkt an eure eigene Lehre. Gebt ihr Studierenden fertige Lösungswege oder lasst ihr sie direkt selbst probieren?”

Kernbotschaft: Anfänger profitieren von fertigen Lösungswegen, weil Problemlösen ohne Schemata das Arbeitsgedächtnis überlastet. Entscheidend ist das Fading: von vollständig durchgearbeitet zu selbstständig. Fragment: Expertise Reversal heisst, was für Anfänger hilft, kann Fortgeschrittene bremsen.

Überleitung: “Nächster Effekt: Wie wir Informationen räumlich anordnen.”

Split-Attention Effect

Wenn Lernende Text und Diagramm getrennt verarbeiten müssen, entsteht unnötige kognitive Last (Tarmizi und Sweller 1988).

viewof format_toggle = {
  const div = html`<div style="display:flex;align-items:center;gap:16px;font-size:0.7em;">
    <label style="cursor:pointer;">
      <input type="radio" name="fmt" value="split" checked style="accent-color:#D55E00;"> Split
    </label>
    <label style="cursor:pointer;">
      <input type="radio" name="fmt" value="integrated" style="accent-color:#0072B2;"> Integriert
    </label>
  </div>`;
  const radios = div.querySelectorAll("input");
  radios.forEach(r => r.oninput = () => {
    div.value = r.value;
    div.dispatchEvent(new Event("input", {bubbles: true}));
  });
  div.value = "split";
  return div;
}

split_attention_fig = {
  const w = 960;
  const h = 340;
  const fs = 14;
  const fsSmall = 12;
  const integrated = format_toggle === "integrated";

  const svg = d3.create("svg")
    .attr("viewBox", `0 0 ${w} ${h}`)
    .attr("width", "100%")
    .attr("height", "100%")
    .style("font-family", "Space Grotesk, sans-serif")
    .style("background", "transparent")
    .style("max-height", "340px");

  // Triangle geometry — compact vertical layout
  const triCx = integrated ? w / 2 : w * 0.25;
  const triCy = integrated ? h * 0.45 : h * 0.48;
  const sz = 105;

  const A = { x: triCx, y: triCy - sz };
  const B = { x: triCx - sz * 0.9, y: triCy + sz * 0.6 };
  const C = { x: triCx + sz * 0.9, y: triCy + sz * 0.6 };

  // Triangle
  svg.append("polygon")
    .attr("points", `${A.x},${A.y} ${B.x},${B.y} ${C.x},${C.y}`)
    .attr("fill", "none")
    .attr("stroke", "#1A1714")
    .attr("stroke-width", 2);

  // Angle arc at A
  const arcR = 22;
  const angAB = Math.atan2(B.y - A.y, B.x - A.x);
  const angAC = Math.atan2(C.y - A.y, C.x - A.x);
  svg.append("path")
    .attr("d", `M ${A.x + arcR * Math.cos(angAB)} ${A.y + arcR * Math.sin(angAB)} A ${arcR} ${arcR} 0 0 1 ${A.x + arcR * Math.cos(angAC)} ${A.y + arcR * Math.sin(angAC)}`)
    .attr("fill", "none").attr("stroke", "#A63D2F").attr("stroke-width", 1.5);

  // Arcs at B and C
  const arcS = 16;
  const bA1 = Math.atan2(A.y - B.y, A.x - B.x);
  const bA2 = Math.atan2(C.y - B.y, C.x - B.x);
  svg.append("path")
    .attr("d", `M ${B.x + arcS * Math.cos(bA2)} ${B.y + arcS * Math.sin(bA2)} A ${arcS} ${arcS} 0 0 1 ${B.x + arcS * Math.cos(bA1)} ${B.y + arcS * Math.sin(bA1)}`)
    .attr("fill", "none").attr("stroke", "#1E3A5F").attr("stroke-width", 1.5);
  const cA1 = Math.atan2(B.y - C.y, B.x - C.x);
  const cA2 = Math.atan2(A.y - C.y, A.x - C.x);
  svg.append("path")
    .attr("d", `M ${C.x + arcS * Math.cos(cA2)} ${C.y + arcS * Math.sin(cA2)} A ${arcS} ${arcS} 0 0 1 ${C.x + arcS * Math.cos(cA1)} ${C.y + arcS * Math.sin(cA1)}`)
    .attr("fill", "none").attr("stroke", "#1E3A5F").attr("stroke-width", 1.5);

  // Vertex labels — positioned outside the triangle
  svg.append("text").attr("x", A.x).attr("y", A.y - 12).attr("text-anchor", "middle").attr("font-size", fs).attr("font-weight", "bold").text("A");
  svg.append("text").attr("x", B.x - 14).attr("y", B.y + 16).attr("text-anchor", "middle").attr("font-size", fs).attr("font-weight", "bold").text("B");
  svg.append("text").attr("x", C.x + 14).attr("y", C.y + 16).attr("text-anchor", "middle").attr("font-size", fs).attr("font-weight", "bold").text("C");

  // Angle label at A — inside the triangle below the arc
  svg.append("text").attr("x", A.x).attr("y", A.y + 38).attr("text-anchor", "middle").attr("font-size", fs).attr("fill", "#A63D2F").attr("font-weight", "600").text("68°");

  // Side label — offset to the left of side AB
  const abNorm = Math.atan2(B.y - A.y, B.x - A.x) + Math.PI / 2;
  svg.append("text")
    .attr("x", (A.x + B.x) / 2 + 18 * Math.cos(abNorm))
    .attr("y", (A.y + B.y) / 2 + 18 * Math.sin(abNorm))
    .attr("text-anchor", "middle")
    .attr("font-size", fsSmall)
    .attr("fill", "#555")
    .attr("transform", `rotate(${angAB * 180 / Math.PI}, ${(A.x + B.x) / 2 + 18 * Math.cos(abNorm)}, ${(A.y + B.y) / 2 + 18 * Math.sin(abNorm)})`)
    .text("AB = AC");

  // Tick marks for equal sides
  const tickLen = 7;
  const abMid = { x: (A.x + B.x) / 2, y: (A.y + B.y) / 2 };
  const abAng = Math.atan2(B.y - A.y, B.x - A.x) + Math.PI / 2;
  svg.append("line").attr("x1", abMid.x + tickLen * Math.cos(abAng)).attr("y1", abMid.y + tickLen * Math.sin(abAng)).attr("x2", abMid.x - tickLen * Math.cos(abAng)).attr("y2", abMid.y - tickLen * Math.sin(abAng)).attr("stroke", "#1A1714").attr("stroke-width", 1.5);
  const acMid = { x: (A.x + C.x) / 2, y: (A.y + C.y) / 2 };
  const acAng = Math.atan2(C.y - A.y, C.x - A.x) + Math.PI / 2;
  svg.append("line").attr("x1", acMid.x + tickLen * Math.cos(acAng)).attr("y1", acMid.y + tickLen * Math.sin(acAng)).attr("x2", acMid.x - tickLen * Math.cos(acAng)).attr("y2", acMid.y - tickLen * Math.sin(acAng)).attr("stroke", "#1A1714").attr("stroke-width", 1.5);

  if (integrated) {
    // INTEGRATED FORMAT
    // "Gesucht" above triangle
    svg.append("text").attr("x", triCx).attr("y", A.y - 30).attr("text-anchor", "middle").attr("font-size", fs).attr("fill", "#1E3A5F").attr("font-weight", "500").text("Gesucht: Winkel B und C");

    // Answer labels near B and C angles — outside, below the vertex labels
    svg.append("text").attr("x", B.x + 22).attr("y", B.y - 8).attr("text-anchor", "start").attr("font-size", fs).attr("fill", "#1E3A5F").attr("font-weight", "600").text("56°");
    svg.append("text").attr("x", C.x - 22).attr("y", C.y - 8).attr("text-anchor", "end").attr("font-size", fs).attr("fill", "#1E3A5F").attr("font-weight", "600").text("56°");

    // Solution steps below triangle — compact two-line summary
    const stepY = B.y + 36;
    svg.append("text").attr("x", triCx).attr("y", stepY).attr("text-anchor", "middle").attr("font-size", fsSmall).attr("fill", "#555").attr("font-weight", "500").text("AB = AC  →  gleichschenkliges Dreieck  →  Winkel B = Winkel C");
    svg.append("text").attr("x", triCx).attr("y", stepY + 20).attr("text-anchor", "middle").attr("font-size", fsSmall).attr("fill", "#A63D2F").attr("font-weight", "600").text("B = C = (180° − 68°) / 2 = 56°");

  } else {
    // SPLIT FORMAT
    // Solution box to the right
    const boxX = w * 0.50;
    const boxY = 10;
    const boxW = w * 0.46;
    const boxH = h - 20;

    svg.append("rect").attr("x", boxX).attr("y", boxY).attr("width", boxW).attr("height", boxH).attr("fill", "#f8f6f0").attr("stroke", "#ccc").attr("stroke-width", 1).attr("rx", 2);

    svg.append("text").attr("x", boxX + boxW / 2).attr("y", boxY + 22).attr("text-anchor", "middle").attr("font-size", fs).attr("font-weight", "bold").text("Lösungsschritte");

    const steps = [
      { text: "Schritt 1:", bold: true },
      { text: "Erkenne, dass AB = AC" },
      { text: "(gleichschenkliges Dreieck)." },
      { text: "" },
      { text: "Schritt 2:", bold: true },
      { text: "In einem gleichschenkligen Dreieck" },
      { text: "sind die Basiswinkel gleich: ∠B = ∠C." },
      { text: "" },
      { text: "Schritt 3:", bold: true },
      { text: "Winkelsumme im Dreieck = 180°." },
      { text: "∠B = ∠C = (180° − 68°) / 2" },
      { text: "∠B = ∠C = 56°", color: "#A63D2F", bold: true },
    ];

    steps.forEach((s, i) => {
      svg.append("text")
        .attr("x", boxX + 14)
        .attr("y", boxY + 44 + i * 16)
        .attr("font-size", fsSmall - 1)
        .attr("fill", s.color || "#1A1714")
        .attr("font-weight", s.bold ? "600" : "400")
        .text(s.text);
    });

    // Dashed arrows showing eye movement between triangle and box
    svg.append("defs").append("marker")
      .attr("id", "arrowhead")
      .attr("viewBox", "0 0 10 10")
      .attr("refX", 9).attr("refY", 5)
      .attr("markerWidth", 6).attr("markerHeight", 6)
      .attr("orient", "auto")
      .append("path").attr("d", "M 0 0 L 10 5 L 0 10 Z").attr("fill", "#D55E00");

    const arrowX1 = triCx + sz * 0.9 + 20;
    const arrowX2 = boxX - 12;
    const arrowY = h * 0.48;

    svg.append("line").attr("x1", arrowX1).attr("y1", arrowY - 6).attr("x2", arrowX2).attr("y2", arrowY - 6).attr("stroke", "#D55E00").attr("stroke-width", 1.5).attr("stroke-dasharray", "5,4").attr("marker-end", "url(#arrowhead)");
    svg.append("line").attr("x1", arrowX2).attr("y1", arrowY + 10).attr("x2", arrowX1).attr("y2", arrowY + 10).attr("stroke", "#D55E00").attr("stroke-width", 1.5).attr("stroke-dasharray", "5,4").attr("marker-end", "url(#arrowhead)");

    svg.append("text").attr("x", (arrowX1 + arrowX2) / 2).attr("y", arrowY - 16).attr("text-anchor", "middle").attr("font-size", fsSmall - 1).attr("fill", "#D55E00").attr("font-weight", "600").text("Blickbewegung");
  }

  return svg.node();
}

Faustregel: Wenn Lernende ihre Augen bewegen müssen, um zusammengehörende Informationen zu verbinden, ist das Design suboptimal.

Einstieg: “Kennt ihr das? Ein Diagramm auf der einen Seite, die Erklärung auf der anderen.”

Kernbotschaft: Interaktive Grafik zeigen. Wenn Lernende zwischen Text und Bild hin- und herspringen müssen, geht kognitive Kapazität für die mentale Integration verloren. Faustregel aufdecken: Augenbewegung = Warnsignal.

Überleitung: “Das war der visuelle Kanal. Was passiert, wenn wir den auditiven Kanal dazunehmen?”

Modalitätseffekt

Zwei Kanäle arbeiten parallel:

auditiv + visuell

+ > +

Einstieg: “Split-Attention war ein räumliches Problem. Jetzt geht es um Kanäle.”

Kernbotschaft: Zwei unabhängige Subsysteme: Phonologische Schleife (auditiv) und visuell-räumlicher Notizblock. Die arbeiten parallel, ohne sich zu belasten. Fragment aufdecken: Bild + Sprache schlägt Bild + Text. Beide Kanäle nutzen, aber mit unterschiedlicher Information.

Überleitung: “Was passiert, wenn man denselben Kanal doppelt belegt?”

Redundanzeffekt

Folientext + Vorlesen = doppelte Verarbeitung

Entweder Text auf der Folie oder gesprochene Erklärung

Einstieg: “Modalität sagt: beide Kanäle nutzen. Aber was, wenn beide Kanäle dasselbe sagen?”

Kernbotschaft: Folientext vorlesen ist der häufigste Fehler. Das Gehirn muss die redundante Quelle aktiv unterdrücken, das kostet kognitive Last ohne Mehrwert. Konsequenz: Entweder Text auf der Folie oder gesprochene Erklärung, nie beides mit demselben Inhalt.

Überleitung: “Vier CLT-Effekte. Jetzt schauen wir, ob ihr sie in eurem eigenen Material erkennt.”

Aktivität: Instruktionsdesign analysieren

Identifiziere in deinem eigenen Lehrmaterial ein Beispiel für Split-Attention oder Redundanz.

Was könntest du konkret ändern?

Diese Aktivität machen wir im Anschluss an die Präsentation (10 Min, Partnerarbeit).

Einstieg: “Bevor wir weitergehen: Merkt euch diese Aufgabe. Wir machen sie nach der Präsentation.”

Kernbotschaft: Kurz die Aufgabe vorstellen, nicht jetzt durchführen. Die Teilnehmenden sollen während der nächsten Folien schon an ihr eigenes Material denken.

Überleitung: “Jetzt wechseln wir die Perspektive: von der Gestaltung von Materialien zu Strategien, die Lernende selbst anwenden können.”

Evidenzbasierte Lernstrategien

Retrieval Practice (Testing Effect)

Abrufen ist nicht nur Prüfung, sondern der zentrale Lernmechanismus (Roediger und Butler 2011).

Befund	Was es bedeutet
Abruf > Wiederholung	Abrufpraxis verbessert Behalten stärker als erneutes Studieren
Transferfördernd	Abruf aus dem Gedächtnis fördert flexibles Anwenden

Einstieg: “Erinnert euch an die Aktivität eben. Das war Retrieval Practice. Jetzt die Forschung dazu.”

Kernbotschaft: Abruf ist nicht Prüfung, sondern der stärkste Lernmechanismus. Abruf schlägt erneutes Lesen. Umsetzung: Quizzes, Brain Dumps, Peer-Teaching, Low-Stakes Testing. Scheitern beim Abruf ist produktiv, es zeigt Lücken.

Überleitung: “Aber warum brauchen wir überhaupt Abrufübungen? Weil wir vergessen.”

Vergessen ist normal

ojs_width = 800
ojs_height = 420
ojs_font_size = "15px"
ojs_slider_width = "300px"

viewof n_retrievals = {
  const size = typeof ojs_font_size !== "undefined" ? ojs_font_size : "15px";
  const slider_width = typeof ojs_slider_width !== "undefined" ? ojs_slider_width : "300px";
  const div = html`<div style="display:flex;align-items:center;gap:12px;font-size:${size};">
    <span style="white-space:nowrap;">Anzahl Abrufübungen: <strong>0</strong></span>
    <input type="range" min="0" max="6" step="1" value="0" style="width:${slider_width};accent-color:#0072B2;">
  </div>`;
  const input = div.querySelector("input");
  const label = div.querySelector("strong");
  input.oninput = () => {
    label.textContent = input.value;
    div.value = +input.value;
    div.dispatchEvent(new Event("input", {bubbles: true}));
  };
  div.value = 0;
  return div;
}

forgetting_chart = {
  const w = typeof ojs_width !== "undefined" ? ojs_width : 700;
  const h = typeof ojs_height !== "undefined" ? ojs_height : 380;
  const fs = typeof ojs_font_size !== "undefined" ? ojs_font_size : "13px";

  const decay_initial = 0.15;
  const slowdown = 0.7;
  const boost = 0.95;
  const max_t = 21;
  const dt = 0.1;

  const base_times = [1, 3, 7, 14, 18, 20];
  const ret_times = base_times.slice(0, n_retrievals);

  const forget_data = [];
  for (let t = 0; t <= max_t; t += dt) {
    forget_data.push({t, r: Math.exp(-decay_initial * t) * 100, type: "Ohne Abrufübung"});
  }

  const spaced_data = [];
  let r = 100;
  let d = decay_initial;
  let ri = 0;
  const markers = [];
  for (let t = 0; t <= max_t; t += dt) {
    spaced_data.push({t, r, type: "Mit Abrufübung"});
    r = r * Math.exp(-d * dt);
    if (r < 0) r = 0;
    if (ri < ret_times.length && t >= ret_times[ri]) {
      markers.push({t: ret_times[ri], r: boost * 100});
      r = boost * 100;
      d *= slowdown;
      ri++;
    }
  }

  const final_retention = spaced_data[spaced_data.length - 1].r;

  return Plot.plot({
    width: w,
    height: h,
    marginLeft: 50,
    marginBottom: 45,
    style: {fontSize: fs, background: "transparent"},
    x: {label: "Tage", domain: [0, 22]},
    y: {label: "Behaltensleistung (%)", domain: [0, 105]},
    color: {
      domain: ["Ohne Abrufübung", "Mit Abrufübung"],
      range: ["#D55E00", "#0072B2"]
    },
    marks: [
      Plot.ruleY([0]),
      Plot.lineY(forget_data, {x: "t", y: "r", stroke: "type", strokeWidth: 2.5, strokeDasharray: "6,4"}),
      Plot.lineY(spaced_data, {x: "t", y: "r", stroke: "type", strokeWidth: 3}),
      Plot.dot(markers, {x: "t", y: "r", fill: "#B8821A", r: 7, stroke: "#1A1714", strokeWidth: 1.5}),
      Plot.text([{x: 21.5, y: final_retention}], {
        x: "x", y: "y",
        text: d => [`${Math.round(final_retention)}%`],
        fill: "#0072B2", fontWeight: "bold", fontSize: 14, dx: 5
      })
    ]
  });
}

Einstieg: “Vergessen ist kein Fehler, sondern der Normalzustand.”

Kernbotschaft: Interaktive Kurve zeigen. Ebbinghaus: Ohne Gegensteuern geht Gelerntes in Tagen verloren. Aber jeder Abruf flacht die Kurve ab. Entscheidend ist nicht ob, sondern wann und wie wir wieder abrufen.

Überleitung: “Die Kurve zeigt das Problem. Spacing und Interleaving sind die Antwort.”

Spacing und Interleaving

Die Vergessenskurve zeigt das Problem. Spacing und Interleaving sind die Antwort.

Spacing (Verteiltes Lernen)

Übung über die Zeit verteilen statt bündeln

• Vergessen + Wiederabruf = stärkere Konsolidierung
• Optimal: Intervall so lang, dass der Abruf Anstrengung erfordert, aber noch gelingt

Gegen die Intuition: fühlt sich schlechter an, ist aber besser.

Interleaving (Vermischtes Üben)

Aufgabentypen durchmischen statt blockweise üben

• Trainiert Diskriminierung: “Welche Strategie passt hier?”
• Fördert Transfer zwischen Konzepten
• Aufgabenwechsel erzwingt aktive Strategiewahl

Studierende bevorzugen Blocking, obwohl Interleaving effektiver ist.

Spacing und Interleaving fühlen sich ineffizienter an. Studierende bevorzugen die weniger effektive Strategie (geblockt, konzentriert). Das ist eine metakognitive Falle.

Einstieg: “Die Vergessenskurve zeigt das Problem. Hier kommen zwei Gegenstrategien.”

Kernbotschaft: Spacing: Übung verteilen, nicht bündeln. Vergessen + Wiederabruf stärkt die Spur. Interleaving: Aufgabentypen mischen, trainiert die Strategiewahl. Fragment: Beides fühlt sich schlechter an, ist aber besser. Studierende bevorzugen die ineffektivere Methode, das ist eine metakognitive Falle.

Überleitung: “Noch zwei Strategien, die das aktive Verarbeiten vertiefen.”

Elaboration und Generation

Elaborative Interrogation

“Warum macht das Sinn?”

• Erzwingt Verknüpfung mit Vorwissen
• Tiefere Verarbeitung als passives Lesen
• Besonders wirksam, wenn Lernende bereits Grundwissen haben

Generation Effect

Selbst produzieren vor dem Erhalten der Information

• Antwort generieren, bevor man die Lösung sieht
• Auch falsche Versuche verbessern das spätere Lernen
• Der Versuch aktiviert relevante Schemata

Einstieg: “Retrieval, Spacing, Interleaving fördern den Abruf. Jetzt zwei Strategien für die Verarbeitungstiefe.”

Kernbotschaft: Elaborative Interrogation: “Warum macht das Sinn?” erzwingt Verknüpfung mit Vorwissen. Generation Effect: Selbst eine Antwort produzieren, bevor man die Lösung sieht. Auch falsche Versuche helfen, weil der Versuch relevante Schemata aktiviert. Rückbezug: Die Einstiegsaktivität heute war genau das.

Überleitung: “Wir haben jetzt Strategien für Lernende gesehen. Wie können wir als Dozierende den Prozess strukturell unterstützen?”

Scaffolding und Fading

Scaffolding: Temporäre Unterstützung

Scaffolding = strukturierte Hilfestellungen, die das Arbeitsgedächtnis entlasten, ohne die kognitive Arbeit zu übernehmen.

Arten von Scaffolding

• Prozesshinweise: “Was für ein Aufgabentyp ist das?”
• Teilschritte: Komplexe Aufgabe in Teilaufgaben zerlegen
• Vorlagen: Struktur vorgeben, Inhalt selbst erarbeiten
• Worked Examples: Lösungswege demonstrieren

Wann Scaffolding nötig ist

• Hohe Elementinteraktivität
• Niedriges Vorwissen
• Neue Aufgabentypen

Wann Scaffolding schadet

• Wenn es die kognitive Arbeit ersetzt statt unterstützt

Einstieg: “Scaffolding kennt ihr vielleicht aus der Baubranche: ein Gerüst, das man wieder abbaut.”

Kernbotschaft: Scaffolding entlastet das Arbeitsgedächtnis, ohne die kognitive Arbeit zu übernehmen. Vier Arten durchgehen. Entscheidende Unterscheidung: Scaffolding unterstützt, es ersetzt nicht. Wenn es die Denkarbeit übernimmt, schadet es.

Überleitung: “Scaffolding aufbauen ist einfach. Die Kunst ist das Abbauen.”

Fading: Unterstützung zurücknehmen

Scaffolding ist nur dann effektiv, wenn es graduell abgebaut wird.

Phase	Unterstützung	Lernprozess
Anfang	Hoch (Worked Examples, Prozesshinweise)	Schemata aufbauen
Mitte	Mittel (Completion Problems, Hinweise auf Nachfrage)	Schemata verfeinern
Ende	Niedrig (eigenständige Aufgaben)	Schemata anwenden

Die Brücke zu KI

KI kann scaffolden, aber sie kann auch die Arbeit übernehmen. Der Unterschied zwischen Scaffolding und Outsourcing ist: Bleibt die kognitive Arbeit bei den Studierenden? Darüber sprechen wir im nächsten Block.

Einstieg: “Scaffolding aufbauen kann jeder. Die Kunst ist, es systematisch abzubauen.”

Kernbotschaft: Fragments nacheinander aufdecken. Tabelle zeigt den Dreischritt: hoch, mittel, niedrig. Dann die Brücke zu KI aufdecken: KI kann scaffolden, aber auch die Arbeit übernehmen. Die zentrale Frage: Bleibt die kognitive Arbeit bei den Studierenden? Das ist der Cliffhanger für den nächsten Block.

Überleitung: “Fassen wir zusammen, was wir jetzt haben.”

Was wir jetzt wissen

CLT-Effekte: Worked Examples, Split-Attention, Redundanz, Modalität

Lernstrategien: Retrieval Practice, Spacing, Interleaving, Elaboration, Generation

Scaffolding: Temporäre Unterstützung mit geplantem Fading

Jetzt: Was passiert, wenn KI ins Spiel kommt?

Einstieg: “Kurzer Überblick, was wir jetzt im Werkzeugkasten haben.”

Kernbotschaft: Drei Säulen zusammenfassen: CLT-Effekte, Lernstrategien, Scaffolding. Dann Fragment aufdecken: Jetzt kommt die spannende Frage, was passiert mit all dem, wenn KI ins Spiel kommt?

Überleitung: Pause für die Aktivität (Instruktionsdesign analysieren), dann weiter mit dem KI-Block.

Bibliographie

Roediger, Henry L., und Andrew C. Butler. 2011. „The Critical Role of Retrieval Practice in Long-Term Retention“. Trends in Cognitive Sciences 15 (1): 20–27. https://doi.org/10.1016/j.tics.2010.09.003.

Sweller, John. 1988. „Cognitive Load during Problem Solving: Effects on Learning“. Cognitive Science 12 (2): 257–85. https://doi.org/10.1016/0364-0213(88)90023-7.

Tarmizi, Rohani A., und John Sweller. 1988. „Guidance during Mathematical Problem Solving“. Journal of Educational Psychology 80 (4): 424–36. https://doi.org/10.1037/0022-0663.80.4.424.