Von der kognitiven Architektur zum KI-gestützten Scaffolding

KI in der Lehre: Refresher

Andrew Ellis

Virtuelle Akademie, Berner Fachhochschule

2026-03-12

Drei Kurse, drei Perspektiven

Wir bieten drei aufbauende Kurse zu KI in der Lehre an:

Beginner

Was ist KI?

• Ein Sprachmodell ist eine Textvorhersagemaschine
• Es kann jeden Dialog simulieren, auch Expertendialoge

Intermediate

Wie funktioniert Lernen?

• Wir können nur wenig gleichzeitig im Arbeitsgedächtnis behalten
• Lernen heisst: Wissen selbst aufbauen und vernetzen
• Gutes Aufgabendesign unterstützt diesen Prozess

Advanced

Wie gestalten wir Aufgaben?

• KI-Tools lassen sich lernwissenschaftlich fundiert gestalten
• Das Ziel: die kognitive Arbeit bleibt bei den Lernenden

Diese Präsentation führt durch alle drei Perspektiven: Technologie, Lernwissenschaft, Werkzeugdesign.

“Wir haben drei Kurse entwickelt, und heute gehen wir durch alle drei Perspektiven.”

• Zuerst: Was kann KI?
• Dann der Kern: Wie funktioniert Lernen?
• Zum Schluss: Wie gestalten wir Tools?

Überleitung: Was kann ein Sprachmodell eigentlich?

Was ist ein Sprachmodell?

Der Mechanismus ist einfach: ein Sprachmodell sagt das Text vorher, Wort für Wort.

Klinischer Bericht

“Schreibe eine Differentialdiagnose für…”

→ ein strukturierter Bericht mit Fachterminologie

Musterlösung

“Löse diese Gleichung Schritt für Schritt”

→ eine detaillierte Lösung

Um solche Texte zu erzeugen, muss das Modell enormes Wissen erworben haben.

Der Output ist aber oft schwer zu beurteilen und erfordert Fachwissen.

Vertiefte Einführung: BFH Beginner-Kurs

“Ein Sprachmodell macht im Grunde nur eines: es sagt das nächste Wort vorher.”

• Zwei Beispiele: klinischer Bericht, Musterlösung
• Der Output liest sich wie Expertentext, egal ob er stimmt

Überleitung: Warum ist das fürs Lernen relevant? Dazu brauchen wir die CLT.

Cognitive Load Theory in 60 Sekunden

Die Cognitive Load Theory (Sweller 2025) erklärt, wie das Arbeitsgedächtnis beim Lernen beansprucht wird.

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

  const boxes = [
    { x: 30, w: 200, label: "Sensorischer Input", sub: "Umwelt", color: "#94a3b8", fontColor: "#222" },
    { x: 330, w: 240, label: "Arbeitsgedächtnis", sub: "~4 Elemente · 15–30 Sek.", color: "#E69F00", fontColor: "#222" },
    { x: 670, w: 200, label: "Langzeitgedächtnis", sub: "Schemata · unbegrenzt", color: "#0072B2", fontColor: "#fff" }
  ];

  const r = 10, bh = 70, by = 30;

  boxes.forEach(b => {
    svg.append("rect").attr("x", b.x).attr("y", by).attr("width", b.w).attr("height", bh)
      .attr("rx", r).attr("fill", b.color);
    svg.append("text").attr("x", b.x + b.w/2).attr("y", by + 28)
      .attr("text-anchor", "middle").attr("font-size", 14).attr("font-weight", "bold").attr("fill", b.fontColor).text(b.label);
    svg.append("text").attr("x", b.x + b.w/2).attr("y", by + 48)
      .attr("text-anchor", "middle").attr("font-size", 11).attr("fill", b.fontColor).attr("opacity", 0.85).text(b.sub);
  });

  // Arrows
  svg.append("defs").append("marker").attr("id", "arr-bn")
    .attr("viewBox", "0 0 10 10").attr("refX", 9).attr("refY", 5)
    .attr("markerWidth", 7).attr("markerHeight", 7).attr("orient", "auto")
    .append("path").attr("d", "M 0 0 L 10 5 L 0 10 Z").attr("fill", "#666");

  // Forward arrows
  svg.append("line").attr("x1", 230).attr("y1", by + bh/2 - 4).attr("x2", 325).attr("y2", by + bh/2 - 4)
    .attr("stroke", "#666").attr("stroke-width", 1.5).attr("marker-end", "url(#arr-bn)");
  svg.append("text").attr("x", 278).attr("y", by + bh/2 - 12)
    .attr("text-anchor", "middle").attr("font-size", 10).attr("fill", "#666").text("Aufmerksamkeit");

  svg.append("line").attr("x1", 570).attr("y1", by + bh/2 - 4).attr("x2", 665).attr("y2", by + bh/2 - 4)
    .attr("stroke", "#666").attr("stroke-width", 1.5).attr("marker-end", "url(#arr-bn)");
  svg.append("text").attr("x", 618).attr("y", by + bh/2 - 12)
    .attr("text-anchor", "middle").attr("font-size", 10).attr("fill", "#666").text("Schemabildung");

  // Backward arrow (dashed)
  svg.append("line").attr("x1", 665).attr("y1", by + bh/2 + 10).attr("x2", 575).attr("y2", by + bh/2 + 10)
    .attr("stroke", "#666").attr("stroke-width", 1.5).attr("stroke-dasharray", "4,3").attr("marker-end", "url(#arr-bn)");
  svg.append("text").attr("x", 618).attr("y", by + bh/2 + 26)
    .attr("text-anchor", "middle").attr("font-size", 10).attr("fill", "#666").text("Abruf");

  return svg.node();
}

Extrinsische Belastung

Unnötige Belastung durch schlechtes Design.

→ Reduzieren!

Intrinsische Belastung

Bestimmt durch Material und Vorwissen.

→ Steuern durch Aufgabendesign

Lernrelevante Verarbeitung

Produktive Denkarbeit, die Schemata aufbaut.

→ Maximieren!

“Die Cognitive Load Theory erklärt, warum unser Arbeitsgedächtnis der Engpass beim Lernen ist.”

• Oben: Grundmodell (Input → Arbeitsgedächtnis → Schemata). Keine Technologie umgeht diesen Engpass.
• Aktion: Klick zeigt drei Lastarten:
  • Extrinsisch = schlechtes Design → reduzieren
  • Intrinsisch = Material + Vorwissen → steuern
  • Lernrelevant = produktive Denkarbeit → maximieren

Überleitung: Wie überwindet man diesen Engpass? Durch Vorwissen.

Expertise = vernetzte Schemata

Wie überwindet man den Engpass? Durch Vorwissen.

Wissen wird im Langzeitgedächtnis zu Schemata organisiert: Einzelelemente werden zu einer Einheit komprimieren.

schemas_width = 700
schemas_height = 380
schemas_font_size = "13px"

novice_expert_schemas = {
  const w = schemas_width;
  const h = schemas_height;
  const fs = schemas_font_size;

  const colNeg = "#D55E00";
  const colPos = "#0072B2";
  const colNeutral = "#64748b";
  const colCross = "#B8821A";

  const labels = [
    "Fakt A", "Fakt B", "Fakt C",
    "Regel 1", "Regel 2", "Regel 3",
    "Def. X", "Def. Y", "Def. Z"
  ];
  const clusters = [0, 0, 0, 1, 1, 1, 2, 2, 2];

  const novicePos = [
    [0.12, 0.22], [0.38, 0.12], [0.65, 0.20],
    [0.18, 0.50], [0.45, 0.48], [0.72, 0.55],
    [0.08, 0.80], [0.42, 0.82], [0.70, 0.78]
  ];

  const expertPos = [
    [0.15, 0.22], [0.30, 0.22], [0.225, 0.40],
    [0.60, 0.22], [0.75, 0.22], [0.675, 0.40],
    [0.33, 0.72], [0.48, 0.72], [0.405, 0.88]
  ];

  const intraEdges = [
    [0, 1], [1, 2], [0, 2],
    [3, 4], [4, 5], [3, 5],
    [6, 7], [7, 8], [6, 8]
  ];

  const crossEdges = [[1, 3], [2, 6], [5, 7]];

  const clusterBoxes = [
    { x: 0.08, y: 0.12, w: 0.30, h: 0.38, label: "Schema 1" },
    { x: 0.53, y: 0.12, w: 0.30, h: 0.38, label: "Schema 2" },
    { x: 0.26, y: 0.62, w: 0.30, h: 0.36, label: "Schema 3" }
  ];

  const mx = 40, my = 30;
  const cw = w - 2 * mx;
  const ch = h - 2 * my;
  const toX = (nx) => mx + nx * cw;
  const toY = (ny) => my + ny * ch;

  const svg = d3.create("svg")
    .attr("width", w).attr("height", h)
    .attr("viewBox", `0 0 ${w} ${h}`)
    .style("background", "transparent")
    .style("cursor", "pointer")
    .style("user-select", "none");

  const clusterGs = svg.selectAll("g.cluster-bg")
    .data(clusterBoxes).join("g").attr("class", "cluster-bg");

  clusterGs.append("rect")
    .attr("x", d => toX(d.x)).attr("y", d => toY(d.y))
    .attr("width", d => d.w * cw).attr("height", d => d.h * ch)
    .attr("rx", 4).attr("fill", colPos).attr("fill-opacity", 0)
    .attr("stroke", colPos).attr("stroke-opacity", 0)
    .attr("stroke-width", 1.5).attr("stroke-dasharray", "6,4");

  clusterGs.append("text")
    .attr("x", d => toX(d.x + d.w / 2)).attr("y", d => toY(d.y) - 6)
    .attr("text-anchor", "middle").style("font-size", "12px")
    .style("fill", colPos).style("font-style", "italic").style("opacity", 0)
    .text(d => d.label);

  const intraLines = svg.selectAll("line.intra")
    .data(intraEdges).join("line").attr("class", "intra")
    .attr("x1", d => toX(novicePos[d[0]][0])).attr("y1", d => toY(novicePos[d[0]][1]))
    .attr("x2", d => toX(novicePos[d[1]][0])).attr("y2", d => toY(novicePos[d[1]][1]))
    .attr("stroke", colPos).attr("stroke-width", 2).attr("stroke-opacity", 0);

  const crossLines = svg.selectAll("line.cross")
    .data(crossEdges).join("line").attr("class", "cross")
    .attr("x1", d => toX(novicePos[d[0]][0])).attr("y1", d => toY(novicePos[d[0]][1]))
    .attr("x2", d => toX(novicePos[d[1]][0])).attr("y2", d => toY(novicePos[d[1]][1]))
    .attr("stroke", colCross).attr("stroke-width", 1.5).attr("stroke-opacity", 0)
    .attr("stroke-dasharray", "4,3");

  const nodeR = 28;
  const nodeGs = svg.selectAll("g.node")
    .data(labels.map((l, i) => ({ label: l, i })))
    .join("g").attr("class", "node")
    .attr("transform", d => `translate(${toX(novicePos[d.i][0])},${toY(novicePos[d.i][1])})`);

  nodeGs.append("rect")
    .attr("x", -nodeR).attr("y", -14).attr("width", nodeR * 2).attr("height", 28)
    .attr("rx", 4).attr("fill", colNeg).attr("fill-opacity", 0.8);

  nodeGs.append("text")
    .attr("text-anchor", "middle").attr("dy", "0.35em")
    .style("font-size", "12px").style("font-weight", "bold").style("fill", "white")
    .text(d => d.label);

  const subtitle = svg.append("text")
    .attr("x", w / 2).attr("y", h - 8)
    .attr("text-anchor", "middle").style("font-size", fs).style("fill", colNeutral)
    .text("Isolierte Fakten \u2014 klicken zum Vernetzen");

  let expert = false;

  svg.on("click", () => {
    expert = !expert;
    const dur = 1000;
    const ease = d3.easeCubicInOut;

    nodeGs.transition().duration(dur).ease(ease)
      .attr("transform", d => {
        const pos = expert ? expertPos[d.i] : novicePos[d.i];
        return `translate(${toX(pos[0])},${toY(pos[1])})`;
      });

    nodeGs.select("rect").transition().duration(dur).ease(ease)
      .attr("fill", expert ? colPos : colNeg);

    intraLines.transition().duration(dur).ease(ease)
      .attr("x1", d => toX((expert ? expertPos : novicePos)[d[0]][0]))
      .attr("y1", d => toY((expert ? expertPos : novicePos)[d[0]][1]))
      .attr("x2", d => toX((expert ? expertPos : novicePos)[d[1]][0]))
      .attr("y2", d => toY((expert ? expertPos : novicePos)[d[1]][1]))
      .attr("stroke-opacity", expert ? 0.6 : 0);

    crossLines.transition().duration(dur).ease(ease)
      .attr("x1", d => toX((expert ? expertPos : novicePos)[d[0]][0]))
      .attr("y1", d => toY((expert ? expertPos : novicePos)[d[0]][1]))
      .attr("x2", d => toX((expert ? expertPos : novicePos)[d[1]][0]))
      .attr("y2", d => toY((expert ? expertPos : novicePos)[d[1]][1]))
      .attr("stroke-opacity", expert ? 0.4 : 0);

    clusterGs.select("rect").transition().duration(dur).ease(ease)
      .attr("fill-opacity", expert ? 0.06 : 0)
      .attr("stroke-opacity", expert ? 0.5 : 0);

    clusterGs.select("text").transition().duration(dur).ease(ease)
      .style("opacity", expert ? 1 : 0);

    subtitle.transition().duration(300).style("opacity", 0)
      .transition().delay(expert ? 600 : 0).duration(300).style("opacity", 1)
      .text(expert
        ? "Vernetzte Schemata \u2014 klicken zum Aufl\u00f6sen"
        : "Isolierte Fakten \u2014 klicken zum Vernetzen");
  });

  return svg.node();
}

“Wie überwindet man diesen Engpass? Durch Vorwissen, das zu Schemata organisiert wird.”

• Aktion: Grafik anklicken (isolierte Fakten → vernetzte Schemata)
• Ein Schema = viele Elemente als eine Einheit → weniger Belastung fürs Arbeitsgedächtnis
• Aber: Schemata aufbauen erfordert eigene Denkarbeit

Überleitung: Was passiert, wenn wir extrinsische Last reduzieren?

Extrinsische Last senken = Kapazität für Lernen

Weniger unnötige Belastung bedeutet mehr Platz für lernrelevante Verarbeitung.

viewof cl_controls = {
  const div = html`<div style="display:flex;align-items:center;gap:10px;font-size:16px;">
    <span style="white-space:nowrap;">Extrinsische Belastung: <strong>60%</strong></span>
    <input type="range" min="5" max="70" step="5" value="60" style="width:250px;accent-color:#D55E00;">
  </div>`;

  const slider = div.querySelector("input[type=range]");
  const label = div.querySelector("strong");

  function emit() {
    div.value = +slider.value;
    div.dispatchEvent(new Event("input", { bubbles: true }));
  }

  slider.oninput = () => {
    label.textContent = slider.value + "%";
    emit();
  };

  div.value = 60;
  return div;
}

cognitive_load_chart = {
  const w = 700;
  const h = 480;

  const intrinsic = 30;
  const ext = Math.min(cl_controls, 100 - intrinsic);
  const learning = Math.max(0, 100 - ext - intrinsic);

  const colors = {
    "Extrinsische Belastung": "#D55E00",
    "Intrinsische Belastung": "#64748b",
    "Lernrelevante Verarbeitung": "#0072B2",
  };

  const data = [
    {type: "Extrinsische Belastung", value: ext, order: 3},
    {type: "Lernrelevante Verarbeitung", value: learning, order: 2},
    {type: "Intrinsische Belastung", value: intrinsic, order: 1},
  ].filter(d => d.value > 0);

  const marks = [
    Plot.barY(data, Plot.stackY({
      x: d => "",
      y: "value",
      fill: "type",
      order: "order",
      tip: true,
      title: d => `${d.type}: ${d.value}%`
    })),
    Plot.ruleY([100], {stroke: "#1A1714", strokeDasharray: "6,4", strokeWidth: 1.5}),
  ];

  if (learning > 8) {
    marks.push(
      Plot.text([{y: intrinsic + learning / 2}],
        {x: d => "", y: "y", text: [`${learning}%`], fill: "white", fontWeight: "bold", fontSize: 16})
    );
  }

  return Plot.plot({
    width: w,
    height: h,
    marginLeft: 60,
    marginBottom: 30,
    marginTop: 30,
    style: {fontSize: "18px", background: "transparent"},
    x: { label: null, padding: 0.7 },
    y: {
      label: "Arbeitsgedächtniskapazität",
      domain: [0, 105],
      ticks: [0, 25, 50, 75, 100],
      tickFormat: d => d + "%"
    },
    color: {
      domain: ["Lernrelevante Verarbeitung", "Intrinsische Belastung", "Extrinsische Belastung"],
      range: [colors["Lernrelevante Verarbeitung"], colors["Intrinsische Belastung"], colors["Extrinsische Belastung"]],
      legend: true
    },
    marks
  });
}

“Schauen wir uns an, was passiert, wenn wir die extrinsische Last verändern.”

• Aktion: Slider bewegen (von hoch nach niedrig)
• Hohe extrinsische Last → kaum Platz für Lernen
• Last senken → sofort Kapazität frei (blaue Fläche = lernrelevante Verarbeitung)

Überleitung: Welche konkreten Quellen hat extrinsische Last?

Extrinsische Last reduzieren

Extrinsische Last entsteht durch unnötige Komplexität im Aufgabendesign.

Typische Quellen extrinsischer Last

• Information auf mehrere Quellen verteilt (Split-Attention)
• Unklare oder mehrdeutige Aufgabenstellungen
• Irrelevante Zusatzinformationen

Gegenstrategien

• Zusammengehörige Information integrieren
• Aufgaben klar und eindeutig formulieren
• Nur zeigen, was gerade gebraucht wird

Jede Reduktion extrinsischer Last schafft Kapazität für lernrelevante Verarbeitung.

“Neben Schemata können wir auch durch besseres Aufgabendesign extrinsische Last reduzieren.”

• Links: typische Quellen (Split-Attention = Paradebeispiel)
• Rechts: Gegenstrategien
• Jede Reduktion schafft Kapazität für lernrelevante Verarbeitung

Überleitung: Aber nicht nur Design zählt: auch das Vorwissen bestimmt die Last.

Vorwissen bestimmt das Aufgabendesign

Dieselbe Aufgabe hat unterschiedliche intrinsische Last für verschiedene Lernende.

Aufgabe: Löse nach \(x\) auf: \[-1(-x - 7) = 14x - 6\]

Für Anfänger:innen

Hohe Komplexität:

• Was bedeutet das Minuszeichen vor der Klammer?
• Wie verteile ich?
• Wie bringe ich \(x\) auf eine Seite?
• Welche Rechenregeln gelten?

Für Fortgeschrittene

Niedrige Komplexität:

• “Klammer auflösen” → ein Schema
• “Terme zusammenfassen” → ein Schema
• “Nach \(x\) auflösen” → ein Schema

Dieselbe Aufgabe, aber verschiedene kognitive Kosten.

“Dieselbe Gleichung kann für verschiedene Lernende völlig unterschiedliche kognitive Kosten haben.”

• Links (Anfänger): jedes Element einzeln im Arbeitsgedächtnis
• Rechts (Fortgeschrittene): eingeübte Schritte, kaum Belastung
• Konsequenz: ein Übungsblatt für alle ist für die meisten falsch

Überleitung: Was tun, wenn die intrinsische Last zu hoch ist? Scaffolding.

Scaffolding steuert die intrinsische Last

Wenn die intrinsische Last zu hoch ist, brauchen Lernende Scaffolding.

Vom Beispiel zum Problem (Fading)

Schritt	Format
1	Worked Example: Vollständig durchgearbeitet
2	Completion Problem: Teilweise gelöst, Lücken füllen
3	Hinweis-gestützt: Nur strategische Hinweise
4	Eigenständig: Ohne Unterstützung

Jede Stufe reduziert die Unterstützung und erhöht die kognitive Eigenleistung.

Beispiel: Gleichung lösen

Stufe 2 (Completion):

\(-1(-x - 7) = 14x - 6\)

Schritt 1: Klammer auflösen → \(\underline{\quad\quad\quad\quad}\)

Schritt 2: \(x\) isolieren → \(7 + 6 = 14x - x\) → \(13 = 13x\)

Schritt 3: Vereinfachen → \(x = 1\)

“Wenn die intrinsische Last zu hoch ist, brauchen Lernende gezielte Unterstützung: Scaffolding.”

• Links: Fading-Sequenz (Worked Example → eigenständig)
• Rechts: konkretes Beispiel (Stufe 2 lässt eine Lücke)
• Unterstützung wird schrittweise abgebaut

Überleitung: Kann ein KI-Tool das auch? Schauen wir uns an, was passiert.

Wie bringe ich ein KI-Tool dazu, pädagogisch sinnvoll zu helfen?

Was ein Chatbot ohne Anleitung tut

“Löse \(-1(-x - 7) = 14x - 6\)”

→ Sofort die vollständige Lösung, korrekt formatiert, flüssig formuliert.

• Keine Diagnose des Vorwissens
• Keine angepasste Unterstützung
• Keine Lücken zum Selbstdenken
• Kein Fading

Eine korrekte Lösung ist noch kein pädagogisch gestaltetes Worked Example.

Was mit der richtigen Anleitung möglich ist

Ein Chatbot kann CLT-Prinzipien umsetzen:

• Zuerst diagnostiziert, was Lernende schon können
• Scaffolding ans Vorwissen anpasst
• Lücken lässt, die zum Selbstdenken einladen
• Unterstützung schrittweise ausblendet (Fading)

Die lernrelevante Verarbeitung bleibt bei den Lernenden.

“Jetzt stellt sich die Frage: Was passiert, wenn wir ein KI-Tool einfach so auf diese Aufgabe loslassen?”

• Links: Chatbot ohne Anleitung → Lösung ja, Scaffolding nein
• Rechts: mit Anleitung → Diagnose, angepasstes Scaffolding, Fading
• Korrekte Lösung ≠ gutes Worked Example

Überleitung: Schauen wir uns ein konkretes Beispiel an.

Beispiel: Gleichungen lösen

Aufgabe: \(-1(-x - 7) = 14x - 6\)

Diese Aufgabe erfordert drei Teilkompetenzen:

Schritt 1

Distribuieren

\(-1 \cdot (-x) = x\)

\(-1 \cdot (-7) = 7\)

→ \(x + 7 = 14x - 6\)

Schritt 2

Terme zusammenfassen

\(7 + 6 = 14x - x\)

→ \(13 = 13x\)

Schritt 3

Variable isolieren

\(x = 1\)

Prüfung: \(-1(-1-7) = 14(1)-6\)

\(8 = 8\)

Ein CLT-informiertes Tool fragt: Welche dieser Teilkompetenzen beherrscht die Person bereits?

Diagnose	Scaffolding
Schritt beherrscht	Nur ein Hinweis, selbst lösen lassen
Schritt teilweise beherrscht	Completion Problem (Lücken ausfüllen)
Schritt nicht beherrscht	Worked Example, dann erneut versuchen

“Schauen wir uns ein konkretes Beispiel an: diese Gleichung erfordert drei Teilkompetenzen.”

• Aktion: Klick zeigt Diagnose-Tabelle
  • Beherrscht → nur Hinweis
  • Teilweise → Completion Problem (Lücken)
  • Nicht beherrscht → Worked Example
• Das ist Fading, angepasst ans Vorwissen

Überleitung: Fassen wir das Ganze zusammen.

Erkenntnisse

1. Extrinsische Last reduzieren: Alles entfernen, was nicht zum Lernen beiträgt.

2. Intrinsische Last ans Vorwissen anpassen: Unterstützung dort geben, wo sie gebraucht wird, und dort zurücknehmen, wo sie überflüssig ist.

3. Lernrelevante Verarbeitung fördern: KI-Tools so gestalten, dass die Denkarbeit bei den Lernenden bleibt.

“Fassen wir zusammen: drei Erkenntnisse, eine für jede Lastart.”

• Extrinsisch reduzieren
• Intrinsisch ans Vorwissen anpassen
• Lernrelevante Verarbeitung fördern, nicht auslagern

Überleitung: Jetzt interessiert mich eure Perspektive.

Diskussion

Mögliche Fragen als Einstieg:

• Wo in deinem Kurs nutzen Studierende KI als Abkürzung, und was geht dabei verloren?

• Welche deiner Aufgaben könnten mit besserem Scaffolding wirksamer werden?

• Woher weisst du, was deine Studierenden bereits können?

• Wie könnte ein KI-Tool aussehen, das auf dein Fach zugeschnitten ist?

“Jetzt interessiert mich eure Perspektive. Ich habe ein paar Fragen vorbereitet, aber wir können auch ganz offen diskutieren.”

• Eigene Erfahrung mit KI-Nutzung
• Aufgabendesign (auch ohne KI)
• Diagnostik (die CLT-Kernfrage)
• Ausblick auf fachspezifische Tools

Referenzen

Sweller, John. 2025. „An Integrated Human Cognitive Architecture“. Educational Psychology Review 37 (4): 108. https://doi.org/10.1007/s10648-025-10089-1.