Expertise und das Lernparadox

Wie Wissen aufgebaut wird und warum es sich schwierig anfühlt

Andrew Ellis

11 März, 2026

Warum existieren Schulen?

Wir unterscheiden zwischen (Geary 2008; Sweller 2023):

	Biologisch primär	Biologisch sekundär
Erwerb	Entwickelt sich natürlich	Erfordert bewusste Anstrengung
Instruktion	Keine formale Instruktion nötig	Kulturelle Errungenschaften, die gelehrt werden müssen
Komplexität	Oft sehr komplex, aber mühelos erworben	Kann einfach sein, erfordert trotzdem Aufwand
Beispiele	Sprechen, Gesichtserkennung, soziale Interaktion	Lesen, Schreiben, Mathematik, Programmieren

Allgemeine Problemlösestrategien (z.B. Mittel-Ziel-Analyse) sind biologisch primär: Sie werden automatisch erworben und lassen sich nicht lehren (Sweller 2025). Akademische Fähigkeiten hingegen profitieren stark von expliziter Anleitung (Kirschner, Sweller, und Clark 2006).

Transition in: Wir starten mit einer grundlegenden Frage: Warum braucht es überhaupt Schulen?

Key: Nicht alles Wissen muss gelehrt werden. Sprechen lernen Kinder von allein, Lesen nicht. Dieser Unterschied erklärt, warum Bildungsinstitutionen existieren.

Transition out: Aber warum genau ist sekundäres Wissen so viel schwieriger? Das hat mit unserem Arbeitsgedächtnis zu tun.

Sprechen vs. Lesen

Warum lernen wir mühelos sprechen, aber nicht mühelos lesen?

Sekundäres Wissen muss durch das Arbeitsgedächtnis verarbeitet werden (Sweller 2025). Das Arbeitsgedächtnis hat strenge Grenzen.

Primäres Wissen umgeht diese Grenzen, weil wir für dessen Erwerb evolvierte Mechanismen haben.

Bildungsinstitutionen existieren genau deshalb: Sie setzen biologisch primäre Fähigkeiten (Zuhören, Imitieren, Kommunizieren) gezielt ein, um biologisch sekundäres Wissen aufzubauen (Sweller 2025).

Transition in: Warum ist Lesen so viel schwieriger als Sprechen, obwohl beides Sprache ist?

Key: Sekundäres Wissen muss durch das Arbeitsgedächtnis, und das hat enge Grenzen. Primäres Wissen umgeht diesen Flaschenhals. Schulen nutzen primäre Fähigkeiten (Zuhören, Imitieren) als Vehikel für sekundäres Wissen.

Transition out: Aber wenn alle dasselbe begrenzte Arbeitsgedächtnis haben, warum können Experten dann so viel mehr?

Gleiche Hardware, unterschiedliche Software

Wenn alle dasselbe begrenzte Arbeitsgedächtnis haben, warum können manche Menschen trotzdem komplexe Probleme mühelos lösen?

Dimension	Anfänger	Experten
Sehen	Einzelne Teile	Bedeutungsvolle Muster
Verarbeiten	Schritt-für-Schritt	Automatische Prozeduren
Wissen	Isolierte Fakten	Vernetzte Schemata

Experten haben besser organisierte Wissensstrukturen (Schemata), die Anfänger erst aufbauen müssen. Die kognitive Architektur ist bei allen Menschen gleich (Sweller 2023).

Transition in: Also: gleiche Hardware, aber unterschiedliche Software. Was macht den Unterschied?

Key: Experten sehen Muster statt Einzelteile, verarbeiten automatisch statt Schritt für Schritt, und haben vernetztes statt isoliertes Wissen. Schachbeispiel: Experten erinnern sinnvolle Stellungen besser, aber nicht zufällige.

Transition out: Schauen wir uns den Unterschied interaktiv an.

Gleiche Hardware, unterschiedliche Software

schemas_width = 960
schemas_height = 500
schemas_font_size = "15px"

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

  // Colors (Okabe-Ito)
  const colNeg = "#D55E00";   // negative/novice
  const colPos = "#0072B2";   // positive/expert
  const colNeutral = "#64748b";
  const colCross = "#B8821A"; // gold for cross-links

  // Node data: same 9 knowledge elements
  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];

  // Novice positions: scattered across the canvas
  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]
  ];

  // Expert positions: organized in 3 clusters
  const expertPos = [
    [0.15, 0.22], [0.30, 0.22], [0.225, 0.40],  // cluster 0 (top-left)
    [0.60, 0.22], [0.75, 0.22], [0.675, 0.40],  // cluster 1 (top-right)
    [0.33, 0.72], [0.48, 0.72], [0.405, 0.88]   // cluster 2 (bottom-center)
  ];

  // Intra-cluster edges (indices)
  const intraEdges = [
    [0, 1], [1, 2], [0, 2],
    [3, 4], [4, 5], [3, 5],
    [6, 7], [7, 8], [6, 8]
  ];

  // Cross-cluster edges
  const crossEdges = [
    [1, 3], [2, 6], [5, 7]
  ];

  // Cluster background rects (in normalized coords)
  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" }
  ];

  // Margins
  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;

  // SVG
  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");

  // Cluster backgrounds (hidden initially)
  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);

  // Intra-cluster edges
  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);

  // Cross-cluster edges
  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");

  // Nodes
  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);

  // Subtitle
  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");

  // Interaction state
  let expert = false;

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

    // Move nodes
    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])})`;
      });

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

    // Move and show/hide intra-edges
    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);

    // Cross-edges
    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);

    // Cluster backgrounds
    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
    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();
}

Transition in: Hier seht ihr den Unterschied zwischen Anfänger- und Expertenwissen visuell.

Key: Interaktive Darstellung: Anfänger haben isolierte Knoten, Experten vernetzte Schemata. Gleiche Information, aber anders organisiert. Die Organisation macht den Unterschied, nicht die Menge.

Transition out: Was bringt diese Organisation konkret? Sie ermöglicht Transfer.

Was organisierte Schemata ermöglichen

Gut vernetzte Schemata ermöglichen Transfer: Wissen auf neue, unbekannte Situationen anwenden.

	Anfänger (Oberflächenmerkmale)	Experten (Tiefenstruktur)
Physik	“Aufgabe mit Rampe”, “Aufgabe mit Feder”	“Energieerhaltung”, “Newtons zweites Gesetz”
Statistik	“Zwei Gruppen → t-Test”, “Drei Gruppen → ANOVA”	t-Test, ANOVA und Regression sind alles Spezialfälle des allgemeinen linearen Modells

Transfer ist das eigentliche Ziel von Hochschulbildung. Wir unterrichten nicht, damit Studierende bekannte Aufgaben lösen. Wir unterrichten, damit sie mit unbekannten Situationen umgehen können.

Transition in: Gut organisierte Schemata ermöglichen etwas Entscheidendes: Transfer.

Key: Anfänger sortieren nach Oberflächenmerkmalen (“Aufgabe mit Rampe”), Experten nach Tiefenstruktur (“Energieerhaltung”). Transfer ist das eigentliche Ziel der Hochschullehre, nicht das Lösen bekannter Aufgaben.

Transition out: Aber Vorsicht: Was Anfängern hilft, kann Experten sogar schaden.

Der Expertise Reversal Effect

Was Anfängern hilft, schadet Experten, und umgekehrt (Kalyuga 2009)

viewof expertise_level = {
  const div = html`<div style="display:flex;align-items:center;gap:12px;font-size:13px;">
    <span style="white-space:nowrap;">Expertise-Level: <strong>Anfänger</strong></span>
    <input type="range" min="0" max="10" step="0.5" value="2" style="width:250px;accent-color:#0072B2;">
  </div>`;
  const input = div.querySelector("input");
  const label = div.querySelector("strong");
  const levelName = (v) => v <= 3 ? "Anfänger" : v <= 7 ? "Mittel" : "Experte";
  input.oninput = () => {
    label.textContent = levelName(+input.value);
    div.value = +input.value;
    div.dispatchEvent(new Event("input", {bubbles: true}));
  };
  div.value = 2;
  return div;
}

expertise_chart = {
  const w = 700;
  const h = 280;
  const fs = "13px";

  // Symmetric sigmoid curves crossing at x=5
  const sigmoid = (x, midpoint, steepness) => 1 / (1 + Math.exp(-steepness * (x - midpoint)));
  const worked = (x) => 85 - 55 * sigmoid(x, 5, 1.0);
  const problem = (x) => 30 + 55 * sigmoid(x, 5, 1.0);
  const crossing_x = 5;

  // Build line data
  const line_data = [];
  for (let x = 0; x <= 10; x += 0.2) {
    line_data.push({x, y: worked(x), method: "Worked Examples"});
    line_data.push({x, y: problem(x), method: "Problemlösen"});
  }

  const ex = expertise_level;
  const we = worked(ex);
  const ps = problem(ex);
  const diff = Math.abs(we - ps);

  // Dynamic labels near each dot — integrates table content
  const weLabel = diff < 3 ? "" : we > ps
    ? "Entlastet Arbeitsgedächtnis" : "Redundante Information";
  const psLabel = diff < 3 ? "" : ps > we
    ? "Verfeinert Schemata" : "Überfordert Arbeitsgedächtnis";

  // Top annotation
  const annotation = diff < 3
    ? "Umschlagpunkt: beide Methoden gleich effektiv"
    : we > ps ? "Anleitung hilft" : "Anleitung schadet";

  return Plot.plot({
    width: w,
    height: h,
    marginLeft: 55,
    marginBottom: 50,
    marginTop: 30,
    marginRight: 150,
    style: {fontSize: fs, background: "transparent"},
    x: {
      label: "Expertise-Level",
      domain: [0, 10],
      ticks: [0, 5, 10],
      tickFormat: d => d === 0 ? "Anfänger" : d === 5 ? "Mittel" : "Experte"
    },
    y: {
      label: "Lernergebnis",
      domain: [20, 95],
      ticks: [25, 85],
      tickFormat: d => d === 25 ? "Niedrig" : "Hoch"
    },
    color: {
      domain: ["Worked Examples", "Problemlösen"],
      range: ["#0072B2", "#E69F00"],
      legend: false
    },
    marks: [
      // Curves
      Plot.lineY(line_data, {x: "x", y: "y", stroke: "method", strokeWidth: 2.5, curve: "natural"}),

      // Right-side legend labels at line endpoints
      Plot.text([{x: 10, y: worked(10)}], {
        x: "x", y: "y", text: ["Worked Examples"], fill: "#0072B2",
        fontSize: 12, fontWeight: "bold", textAnchor: "start", dx: 10
      }),
      Plot.text([{x: 10, y: problem(10)}], {
        x: "x", y: "y", text: ["Problemlösen"], fill: "#E69F00",
        fontSize: 12, fontWeight: "bold", textAnchor: "start", dx: 10
      }),

      // Crossover point
      Plot.dot([{x: crossing_x, y: worked(crossing_x)}], {
        x: "x", y: "y", r: 6, fill: "white", stroke: "#1A1714", strokeWidth: 2
      }),

      // Vertical cursor
      Plot.ruleX([ex], {stroke: "#1A1714", strokeDasharray: "4,3", strokeWidth: 1.5}),

      // Current dots
      Plot.dot([{x: ex, y: we}], {x: "x", y: "y", r: 7, fill: "#0072B2", stroke: "#1A1714", strokeWidth: 1.5}),
      Plot.dot([{x: ex, y: ps}], {x: "x", y: "y", r: 7, fill: "#E69F00", stroke: "#1A1714", strokeWidth: 1.5}),

      // Connecting line
      Plot.link([{x1: ex, y1: we, x2: ex, y2: ps}], {
        x1: "x1", y1: "y1", x2: "x2", y2: "y2",
        stroke: "#A63D2F", strokeWidth: 2.5, strokeDasharray: "3,2"
      }),

      // Dynamic dot labels (the table info)
      Plot.text([{x: ex, y: we}], {
        x: "x", y: "y", text: [weLabel], fill: "#0072B2",
        fontSize: 11, fontWeight: "600",
        dx: ex < 5 ? 10 : -10, textAnchor: ex < 5 ? "start" : "end", dy: -12
      }),
      Plot.text([{x: ex, y: ps}], {
        x: "x", y: "y", text: [psLabel], fill: "#E69F00",
        fontSize: 11, fontWeight: "600",
        dx: ex < 5 ? 10 : -10, textAnchor: ex < 5 ? "start" : "end", dy: 16
      }),

      // Top annotation
      Plot.text([{x: ex, y: 93}], {
        x: "x", y: "y",
        text: [annotation],
        fill: "#1A1714", fontWeight: "bold", fontSize: 13
      }),
    ]
  });
}

Transition in: Es gibt eine wichtige Komplikation: Der Expertise Reversal Effect.

Key: Starke Anleitung hilft Anfängern, behindert aber Experten (redundante Information erzeugt kognitive Belastung). Umgekehrt profitieren Experten von offenen Aufgaben, die Anfänger überfordern. Instruktion muss an den Wissensstand angepasst werden.

Transition out: Wie kommt man überhaupt von Anfänger zu Experte? Durch Knowledge Compilation.

Wie Expertise entwickelt wird

Knowledge Compilation (Anderson 1982, 2007)

Phase	Velofahren	Wissenstyp
Erste Versuche	“Lenker gerade, treten, Gleichgewicht halten…”	Deklarativ
Mit Übung	Regeln werden durch Feedback verdichtet	Kompilation
Nach Monaten	Automatisch, Kapazität frei für Verkehr und Routenplanung	Prozedural

Transition in: Wie entwickelt sich Expertise konkret? Anderson nennt es Knowledge Compilation.

Key: Drei Phasen: deklarativ (Regeln bewusst abrufen), Kompilation (Regeln verdichten), prozedural (automatisch). Velofahren-Beispiel: Am Anfang denkst du an jeden Schritt, am Ende fährst du automatisch und planst dabei die Route. Automatisierung setzt Arbeitsgedächtnis frei.

Transition out: Compilation braucht Übung. Aber welche Art von Übung ist am wirksamsten?

Welche Übungszyklen sind am wirksamsten?

Knowledge Compilation braucht Übungszyklen mit Feedback.

Aber nicht alle Übungsformen sind gleich wirksam.

Eine der wirksamsten: Abruf aus dem Gedächtnis (Retrieval Practice)

Probieren wir es aus.

Transition in: Also: Übung mit Feedback ist entscheidend. Aber nicht jede Übung ist gleich wirksam.

Key: Eine der wirksamsten Strategien ist Retrieval Practice: aktiver Abruf aus dem Gedächtnis. Nicht nochmal lesen, sondern versuchen, sich zu erinnern.

Transition out: Wir probieren es jetzt selbst aus. Kurze Aktivität.

Aktivität: Retrieval

Versuche aus dem Gedächtnis: Was ist der Expertise Reversal Effect in einem Satz?

Lücken sind willkommen. Sie zeigen, worauf du beim Weiterhören achten kannst.

Transition in: Jetzt seid ihr dran. Kurze Retrieval-Übung.

Key: Frage stellen, Timer starten, Stille aushalten. Lücken sind erwünscht, das ist der Punkt. Nicht auflösen, sondern kurz sammeln lassen.

Transition out: Warum funktioniert das eigentlich? Schauen wir uns die Mechanismen an.

Warum Abrufpraxis funktioniert

Abruf misst nicht nur Lernen, er erzeugt Lernen (Roediger und Butler 2011)

Mechanismus	Wirkung
Stärkt Abrufrouten	Jeder erfolgreiche Abruf macht die Erinnerung zugänglicher
Identifiziert Lücken	Scheitern beim Abruf zeigt, was man nicht weiss
Fördert Elaboration	Rekonstruktion aktiviert verwandtes Wissen und schafft neue Verbindungen im Netzwerk
Aktualisiert Kontext	Neue Abrufkontexte machen Wissen transferierbarer

Deshalb funktionieren die Gedächtnis-Aktivierungen im Workshop: Nicht die Anstrengung selbst, sondern die durch den Abruf ausgelösten Prozesse festigen das Gelernte.

Transition in: Ihr habt gerade Retrieval Practice gemacht. Warum ist das so wirksam?

Key: Vier Mechanismen: stärkt Abrufrouten, zeigt Lücken auf, fördert Elaboration, aktualisiert Kontext. Meta-Punkt: Die Aktivierungen im Workshop sind nicht Deko, sie nutzen genau diese Mechanismen.

Transition out: Aber Retrieval fühlt sich anstrengend an. Und genau das ist ein Problem, denn Studierende meiden Anstrengung.

Wenn wirksames Lernen sich falsch anfühlt

Studierende bevorzugen Strategien, die sich leicht anfühlen, obwohl die wirksamsten Strategien sich anstrengend anfühlen (Bjork 1994; Dunlosky u. a. 2013).

learning_illusion_chart = {
  const w = 650;
  const h = 350;

  // Dunlosky et al. (2013) utility ratings mapped to y-axis
  // x-axis: perceived effectiveness (spread out to avoid overlap)
  const data = [
    // High utility
    {strategy: "Abrufpraxis",     perceived: 20, actual: 90, utility: "Hoch"},
    {strategy: "Verteiltes Üben", perceived: 15, actual: 78, utility: "Hoch"},
    // Moderate utility
    {strategy: "Elaborative Nachfragen", perceived: 30, actual: 55, utility: "Mittel"},
    {strategy: "Selbsterklärung",        perceived: 45, actual: 48, utility: "Mittel"},
    {strategy: "Verschränktes Üben",     perceived: 25, actual: 42, utility: "Mittel"},
    // Low utility — spread x positions to avoid overlap
    {strategy: "Zusammenfassen",    perceived: 75, actual: 28, utility: "Niedrig"},
    {strategy: "Markieren",         perceived: 88, actual: 18, utility: "Niedrig"},
    {strategy: "Nachlesen",         perceived: 92, actual: 30, utility: "Niedrig"},
    {strategy: "Schlüsselwort-Mnemonic", perceived: 42, actual: 15, utility: "Niedrig"},
    {strategy: "Bildliche Vorstellung",  perceived: 60, actual: 20, utility: "Niedrig"},
  ];

  const colorMap = {"Hoch": "#0072B2", "Mittel": "#E69F00", "Niedrig": "#D55E00"};

  // Custom label offsets to avoid overlap
  const labelOffsets = {
    "Abrufpraxis":     {dx: 12, dy: 0, anchor: "start"},
    "Verteiltes Üben": {dx: 12, dy: 0, anchor: "start"},
    "Elaborative Nachfragen": {dx: 12, dy: -2, anchor: "start"},
    "Selbsterklärung":  {dx: 12, dy: 0, anchor: "start"},
    "Verschränktes Üben": {dx: 12, dy: 4, anchor: "start"},
    "Zusammenfassen":   {dx: 0, dy: -14, anchor: "middle"},
    "Markieren":        {dx: 0, dy: 16, anchor: "middle"},
    "Nachlesen":        {dx: -12, dy: -12, anchor: "end"},
    "Schlüsselwort-Mnemonic": {dx: 12, dy: 14, anchor: "start"},
    "Bildliche Vorstellung":  {dx: 0, dy: -14, anchor: "middle"},
  };

  return Plot.plot({
    width: w,
    height: h,
    marginLeft: 70,
    marginRight: 30,
    marginTop: 20,
    marginBottom: 55,
    style: {fontSize: "12px", background: "transparent"},
    x: {
      label: "Gefühlte Wirksamkeit (Beliebtheit bei Studierenden)",
      domain: [0, 100],
      ticks: [0, 50, 100],
      tickFormat: d => d === 0 ? "Niedrig" : d === 100 ? "Hoch" : ""
    },
    y: {
      label: "Tatsächliche Wirksamkeit (Dunlosky et al., 2013)",
      domain: [0, 100],
      ticks: [0, 50, 100],
      tickFormat: d => d === 0 ? "Niedrig" : d === 100 ? "Hoch" : ""
    },
    color: {
      domain: ["Hoch", "Mittel", "Niedrig"],
      range: ["#0072B2", "#E69F00", "#D55E00"],
      legend: false
    },
    marks: [
      // Diagonal reference line (feeling = reality)
      Plot.line([[0, 0], [100, 100]], {
        stroke: "#ddd", strokeWidth: 1.5, strokeDasharray: "6,4"
      }),

      // Strategy dots
      Plot.dot(data, {
        x: "perceived", y: "actual",
        r: 6, fill: "utility",
        stroke: "#1A1714", strokeWidth: 1
      }),

      // Labels with custom offsets
      ...data.map(d => {
        const o = labelOffsets[d.strategy];
        return Plot.text([d], {
          x: "perceived", y: "actual", text: [d.strategy],
          fontSize: 10, fontWeight: "600",
          fill: colorMap[d.utility],
          dx: o.dx, dy: o.dy, textAnchor: o.anchor
        });
      }),
    ]
  });
}

Wie sich Lernen anfühlt, ist kein verlässlicher Indikator dafür, wie viel tatsächlich gelernt wird.

Transition in: Hier kommt der Haken: Wirksames Lernen fühlt sich oft falsch an.

Key: Grafik zeigt den Widerspruch. Studierende bevorzugen Strategien, die sich leicht anfühlen (Wiederlesen, Markieren), obwohl die wirksamen Strategien sich anstrengend anfühlen (Retrieval, Spacing). Subjektives Gefühl und tatsächlicher Lernerfolg korrelieren schlecht.

Transition out: Das führt uns zum Lernparadox.

Das Lernparadox

Fühlt sich schwer an

• Frustration, Unsicherheit
• “Ich kann das nicht”

Aber: Tiefes Verständnis bildet sich, Schemata werden aufgebaut. Echtes Lernen.

Fühlt sich leicht an

• Erfolgsgefühl, Selbstvertrauen
• “Ich verstehe das”

Aber: Oberflächliche Verarbeitung, keine Schemabildung. Illusion des Lernens.

Unsere Metakognition täuscht uns: Wie sich Lernen anfühlt, ist kein verlässlicher Indikator dafür, wie viel tatsächlich gelernt wird.

Transition in: Das ist das Lernparadox auf den Punkt gebracht.

Key: Zwei Spalten, zwei Erfahrungen. Links: fühlt sich schwer an, ist aber echtes Lernen. Rechts: fühlt sich leicht an, ist aber Illusion. Pause machen, wirken lassen. Die Metakognition täuscht uns systematisch.

Transition out: Schauen wir uns das Gesamtbild an.

Das Lernparadox: Die Übersicht

viewof lernparadox_quadrant = {
  const div = html`<div style="display:flex;align-items:center;gap:8px;font-size:13px;">
    <button class="lp-btn" data-step="1" style="padding:4px 12px;border-radius:4px;border:1.5px solid #D55E00;background:#FFF5F0;cursor:pointer;font-size:12px;font-weight:600;color:#D55E00;">1. Illusion</button>
    <button class="lp-btn" data-step="2" style="padding:4px 12px;border-radius:4px;border:1.5px solid #0072B2;background:#F0F7FC;cursor:pointer;font-size:12px;font-weight:600;color:#0072B2;">2. Produktiv</button>
    <button class="lp-btn" data-step="3" style="padding:4px 12px;border-radius:4px;border:1.5px solid #999;background:#F5F5F5;cursor:pointer;font-size:12px;font-weight:600;color:#666;">3. Effizienz</button>
    <button class="lp-btn" data-step="4" style="padding:4px 12px;border-radius:4px;border:1.5px solid #999;background:#F5F5F5;cursor:pointer;font-size:12px;font-weight:600;color:#666;">4. Frustration</button>
    <a href="#" class="lp-reset" style="color:#888;font-size:11px;margin-left:4px;display:none;">Zurücksetzen</a>
  </div>`;
  const btns = div.querySelectorAll(".lp-btn");
  const reset = div.querySelector(".lp-reset");
  div.value = 0;

  let revealed = 0;
  btns.forEach((btn, i) => {
    if (i > 0) btn.style.opacity = "0.4";
    btn.onclick = () => {
      if (i <= revealed) return;
      revealed = i;
      div.value = i + 1;
      btn.style.opacity = "1";
      if (i + 1 < btns.length) btns[i + 1].style.opacity = "1";
      if (i > 0) reset.style.display = "";
      div.dispatchEvent(new Event("input", {bubbles: true}));
    };
  });
  // First button always clickable
  btns[0].onclick = () => {
    if (revealed >= 0 && div.value >= 1) return;
    revealed = 0;
    div.value = 1;
    btns[1].style.opacity = "1";
    div.dispatchEvent(new Event("input", {bubbles: true}));
  };

  reset.onclick = (e) => {
    e.preventDefault();
    revealed = 0;
    div.value = 0;
    btns.forEach((btn, i) => { btn.style.opacity = i === 0 ? "1" : "0.4"; });
    reset.style.display = "none";
    div.dispatchEvent(new Event("input", {bubbles: true}));
  };

  return div;
}

lernparadox_matrix = {
  const w = 580;
  const h = 400;
  const step = lernparadox_quadrant;

  const blue = "#0072B2";
  const terra = "#D55E00";
  const dark = "#1A1714";

  // Layout
  const ml = 90;   // margin left (axis label)
  const mr = 20;
  const mt = 20;
  const mb = 50;   // margin bottom (axis label)
  const gw = w - ml - mr;  // grid width
  const gh = h - mt - mb;  // grid height
  const cx = ml + gw / 2;  // center x
  const cy = mt + gh / 2;  // center y

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

  // Grid lines
  svg.append("line").attr("x1", ml).attr("y1", cy).attr("x2", ml + gw).attr("y2", cy)
    .attr("stroke", "#ccc").attr("stroke-width", 1);
  svg.append("line").attr("x1", cx).attr("y1", mt).attr("x2", cx).attr("y2", mt + gh)
    .attr("stroke", "#ccc").attr("stroke-width", 1);

  // Outer border
  svg.append("rect").attr("x", ml).attr("y", mt).attr("width", gw).attr("height", gh)
    .attr("fill", "none").attr("stroke", "#999").attr("stroke-width", 1.5);

  // Axis labels
  // X axis
  svg.append("text").attr("x", cx).attr("y", h - 8)
    .attr("text-anchor", "middle").attr("fill", dark)
    .attr("font-size", "13px").attr("font-weight", "600")
    .text("Subjektives Gefühl beim Lernen");
  svg.append("text").attr("x", ml + 10).attr("y", mt + gh + 22)
    .attr("text-anchor", "start").attr("fill", "#888")
    .attr("font-size", "11px").text("Schwierig");
  svg.append("text").attr("x", ml + gw - 10).attr("y", mt + gh + 22)
    .attr("text-anchor", "end").attr("fill", "#888")
    .attr("font-size", "11px").text("Leicht");

  // Y axis
  svg.append("text").attr("x", 14).attr("y", cy)
    .attr("text-anchor", "middle").attr("fill", dark)
    .attr("font-size", "13px").attr("font-weight", "600")
    .attr("transform", `rotate(-90, 14, ${cy})`)
    .text("Tatsächliches Lernen");
  svg.append("text").attr("x", ml - 10).attr("y", mt + gh - 5)
    .attr("text-anchor", "end").attr("fill", "#888")
    .attr("font-size", "11px").text("Wenig");
  svg.append("text").attr("x", ml - 10).attr("y", mt + 15)
    .attr("text-anchor", "end").attr("fill", "#888")
    .attr("font-size", "11px").text("Viel");

  // Quadrant definitions
  const quadrants = [
    // 1: Bottom-right — Illusion des Lernens
    {
      x: cx, y: cy, w: gw/2, h: gh/2,
      fill: "#D55E0018", title: "Illusion des\nLernens",
      titleColor: terra, annotation: "Metakognitive Falle",
      annotColor: terra, step: 1
    },
    // 2: Top-left — Produktive Anstrengung
    {
      x: ml, y: mt, w: gw/2, h: gh/2,
      fill: "#0072B218", title: "Produktive\nAnstrengung",
      titleColor: blue, annotation: "ZIEL",
      annotColor: blue, step: 2
    },
    // 3: Top-right — Experten-Effizienz
    {
      x: cx, y: mt, w: gw/2, h: gh/2,
      fill: "#0072B20C", title: "Experten-\nEffizienz",
      titleColor: "#5599BB", annotation: "OK für Fortgeschrittene",
      annotColor: "#888", step: 3
    },
    // 4: Bottom-left — Unproduktive Frustration
    {
      x: ml, y: cy, w: gw/2, h: gh/2,
      fill: "#D55E000C", title: "Unproduktive\nFrustration",
      titleColor: "#CC8866", annotation: "Vermeiden",
      annotColor: "#888", step: 4
    },
  ];

  for (const q of quadrants) {
    if (step < q.step) continue;

    const g = svg.append("g");

    // Background
    g.append("rect")
      .attr("x", q.x).attr("y", q.y)
      .attr("width", q.w).attr("height", q.h)
      .attr("fill", q.fill);

    // Title (centered in quadrant)
    const qcx = q.x + q.w / 2;
    const qcy = q.y + q.h / 2 - 10;
    const lines = q.title.split("\n");
    lines.forEach((line, i) => {
      g.append("text")
        .attr("x", qcx).attr("y", qcy + i * 22 - (lines.length - 1) * 11)
        .attr("text-anchor", "middle")
        .attr("fill", q.titleColor)
        .attr("font-size", "18px")
        .attr("font-weight", "bold")
        .text(line);
    });

    // Annotation (below title)
    g.append("text")
      .attr("x", qcx).attr("y", qcy + lines.length * 22 - (lines.length - 1) * 11 + 4)
      .attr("text-anchor", "middle")
      .attr("fill", q.annotColor)
      .attr("font-size", "11px")
      .attr("font-style", "italic")
      .text(q.annotation);
  }

  // Curve (shown after step 2: from top-left to bottom-right)
  if (step >= 2) {
    const curvePoints = [];
    for (let t = 0; t <= 1; t += 0.02) {
      // Sigmoid-like curve from top-left to bottom-right
      const px = ml + gw * 0.15 + gw * 0.7 * t;
      const py = mt + gh * 0.2 + gh * 0.6 * (1 / (1 + Math.exp(-6 * (t - 0.5))));
      curvePoints.push([px, py]);
    }
    const line = d3.line().curve(d3.curveBasis);
    svg.append("path")
      .attr("d", line(curvePoints))
      .attr("fill", "none")
      .attr("stroke", "#9A4665")
      .attr("stroke-width", 2.5)
      .attr("opacity", 0.7);
  }

  return svg.node();
}

Wir verwechseln Verarbeitungsflüssigkeit (wie leicht sich etwas anfühlt) mit Lernerfolg (Bjork 1994).

Produktive Anstrengung fühlt sich schwierig an, signalisiert aber, dass lernrelevante Prozesse aktiv sind.

Wenn es sich anstrengend anfühlt, ist das meistens ein gutes Zeichen.

Transition in: Hier das Gesamtbild mit der Grafik.

Key: Verarbeitungsflüssigkeit (wie leicht es sich anfühlt) ist nicht gleich Lernerfolg. Produktive Anstrengung signalisiert, dass lernrelevante Prozesse aktiv sind. Kernbotschaft: Wenn es sich anstrengend anfühlt, ist das meistens ein gutes Zeichen.

Transition out: Fassen wir zusammen, was wir jetzt wissen.

Was wir jetzt wissen

Biologisch sekundäres Wissen erfordert bewusste Anstrengung und explizite Instruktion

Lernen = Schemabildung im Langzeitgedächtnis

Fühlt sich anstrengend an (metakognitive Falle)

Ziel: Transfer, also Wissen auf neue Situationen anwenden können

Transition in: Zusammenfassung: vier Kernpunkte.

Key: Vier Take-aways: (1) Sekundäres Wissen braucht Anstrengung und Instruktion, (2) Lernen ist Schemabildung, (3) es fühlt sich anstrengend an, das ist normal, (4) das Ziel ist Transfer. Kurz durchgehen, nicht erklären, nur verankern.

Transition out: Mit diesem Fundament schauen wir uns jetzt an, was passiert, wenn KI ins Spiel kommt.

Bibliographie

Anderson, John R. 1982. „Acquisition of Cognitive Skill“. Psychological Review 89 (4): 369–406. https://doi.org/10.1037/0033-295X.89.4.369.

———. 2007. How Can the Human Mind Occur in the Physical Universe? Oxford University Press. https://doi.org/10.1093/acprof:oso/9780195324259.001.0001.

Bjork, Robert A. 1994. „Memory and Metamemory Considerations in the Training of Human Beings“. In Metacognition: Knowing about Knowing, 185–205. Cambridge, MA, US: The MIT Press. https://doi.org/10.7551/mitpress/4561.001.0001.

Dunlosky, John, Katherine A. Rawson, Elizabeth J. Marsh, Mitchell J. Nathan, und Daniel T. Willingham. 2013. „Improving Students’ Learning With Effective Learning Techniques“. Psychological Science in the Public Interest, Januar. https://doi.org/10.1177/1529100612453266.

Geary, David C. 2008. „An Evolutionarily Informed Education Science“. Educational Psychologist 43 (4): 179–95. https://doi.org/10.1080/00461520802392133.

Kalyuga, Slava. 2009. „The Expertise Reversal Effect“. In Managing Cognitive Load in Adaptive Multimedia Learning, 58–80. IGI Global Scientific Publishing. https://doi.org/10.4018/978-1-60566-048-6.ch003.

Kirschner, Paul A., John Sweller, und Richard E. Clark. 2006. „Why Minimal Guidance During Instruction Does Not Work: An Analysis of the Failure of Constructivist, Discovery, Problem-Based, Experiential, and Inquiry-Based Teaching“. Educational Psychologist 41 (2): 75–86. https://doi.org/10.1207/s15326985ep4102_1.

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. 2023. „The Development of Cognitive Load Theory: Replication Crises and Incorporation of Other Theories Can Lead to Theory Expansion“. Educational Psychology Review 35 (4): 95. https://doi.org/10.1007/s10648-023-09817-2.

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