Weiterbildungs- und College-Credits durch KI-Fortbildung für Lehrkräfte erwerben

Weiterbildungs- und College-Credits durch KI-Fortbildung für Lehrkräfte

Ein Abschlusszertifikat ist kein Credit. Diese eine Unterscheidung erklärt, warum so viele Lehrkräfte eine KI-Fortbildungsreihe mit einem Ordner voller PDFs beenden und trotzdem die einzige Frage nicht beantworten können, die ihr Schulbezirk, ihre Lizenzbehörde oder ihr Registrar stellen wird: Wofür zählt das?

Das Bildungsteam von Google hat einen Weg für Lehrkräfte veröffentlicht, die möchten, dass ihre KI-Fortbildung auf Weiterbildung und College-Credits angerechnet wird; beschrieben im Google-Blog unter https://blog.google/products-and-platforms/products/education/college-credit-ai-educator-series. Dieser Artikel behandelt diese Seite als autoritativen Ausgangspunkt, erklärt, wie die Umwandlung in Credits im Allgemeinen funktioniert, und führt dann durch ein kleines, lokal installiertes Ledger, das Ihr Nachweispaket prüfungsbereit hält, bevor Sie es brauchen.

Was die Quelle belegt — und was nicht

Die verifizierte Primärquelle ist Googles eigene Bildungsblog-Seite, die beschreibt, wie Lehrkräfte Weiterbildungs- und College-Credits für KI-Fortbildung für Lehrkräfte erhalten können. Das ist der Umfang der hier verfügbaren Belege.

Was die Seite nicht belegt — jedenfalls nicht in einer Form, die dieser Artikel verantwortungsvoll behaupten kann —, umfasst konkrete Gesamtzahlen von Credit-Stunden, Höhe von Studiengebühren oder Gebühren, die Identität der Partnerinstitutionen, die Credits vergeben, von Bundesstaat zu Bundesstaat unterschiedliche Anerkennungsregeln oder Anmeldefristen. Das sind genau die Details, die sich am häufigsten ändern und die sich je nach Zuständigkeitsbereich am stärksten unterscheiden. Lesen Sie sie direkt auf der Quellseite und bei der Credit-vergebenden Institution nach, bevor Sie irgendetwas bezahlen oder Ihrer Schulleitung eine Zahl versprechen.

Die praktische Konsequenz: Betrachten Sie die Google-Seite als Eingangstür, nicht als Vertrag. Ihre Berechtigung, Ihre Kosten und Ihr Ergebnis im Transcript werden vom Credit-Anbieter und von Ihrer eigenen Landes- oder Schulbezirksrichtlinie geregelt.

Drei Währungen, drei unterschiedliche Genehmigungen

„Credit“ ist nicht ein einziges Ding. In der Praxis begegnen Lehrkräfte drei unterschiedlichen Währungen, und eine einzelne Fortbildungsreihe kann sich je nach Anbieter in einige, alle oder keine davon umwandeln lassen.

Weiterbildungseinheiten (Continuing Education Units, CEUs) werden typischerweise von einem Fortbildungsanbieter oder einer akkreditierten Institution vergeben und dienen dazu, Anforderungen für die Lizenzverlängerung oder Gehaltsstufen zu erfüllen. Sie sind meist am einfachsten zu erhalten und am wenigsten übertragbar. Viele US-amerikanische Anbieter verwenden die Konvention von ungefähr zehn Kontaktstunden pro CEU, aber diese Konvention ist nicht universell, und die Quellseite garantiert sie nicht für eine bestimmte Fortbildungsreihe. Lassen Sie sich die Formel des Anbieters schriftlich bestätigen.

Graduate Credit wird von einer Universität vergeben, oft über eine erziehungswissenschaftliche Fakultät, und erfordert im Allgemeinen sowohl die Fortbildungsstunden als auch eine zusätzliche Leistung — eine Reflexionsarbeit, ein Portfolio oder ein angewandtes Unterrichtsprojekt. Graduate Credit ist teurer und besser übertragbar.

Undergraduate Credit erscheint seltener in Kontexten der beruflichen Fortbildung, taucht aber in Wegen zum Studienabschluss und in Anträgen auf Anerkennung vorherigen Lernens auf, bei denen ein Portfolio an den Lernergebnissen eines Kurses gemessen wird statt an Anwesenheitszeit.

Diese Dreiteilung ist allgemeine Praxis, keine aus der Quelle abgeleitete Behauptung. Ihr Wert ist diagnostisch: Wenn Ihnen jemand sagt, eine Fortbildung „zählt für Credit“, sollte Ihre nächste Frage sein, welche Währung, von wem ausgegeben und von welcher Stelle anerkannt.

Voraussetzungen

Bevor Sie irgendetwas installieren, bestätigen Sie, dass Sie die Dokumentationsanforderungen erfüllen können. Das unten beschriebene Tooling ist ein Ledger; es kann keine Belege herstellen, die Sie nie gesammelt haben.

• Eine abgeschlossene Fortbildungskomponente. Die von der Quellseite referenzierte KI-Fortbildungsreihe für Lehrkräfte oder ein gleichwertiges Programm, das Sie bereits abgeschlossen haben.
• Anbieterdokumentation. Ein Abschlusszertifikat sowie ein Syllabus oder Programm, das Kontaktstunden ausdrücklich angibt. Ein Programm ohne Stundenangaben ist der häufigste Grund, aus dem eine Einreichung abgelehnt wird.
• Eine Akkreditierungs- oder Genehmigungserklärung. Ein Dokument, das zeigt, dass der Anbieter berechtigt ist, die von Ihnen beanspruchte Credit-Art auszugeben.
• Ein Praxisartefakt. Ein Unterrichtsplan, eine überarbeitete Unterrichtseinheit oder eine Unterrichtsbewertung, die zeigt, dass Sie die Fortbildung angewendet haben. Prüfer für Graduate Credit fragen fast immer danach.
• Institutionelle Regeln. Die Fortbildungsrichtlinie Ihres Schulbezirks, die Anforderungen Ihres Bundesstaats zur Lizenzverlängerung und — wenn Sie College-Credit anstreben — das Antragsformat des Registrar oder der Stelle für vorheriges Lernen.
• Lokale technische Voraussetzungen. Python 3.10 oder neuer, pip, Git und ungefähr 50 MB Speicherplatz. Windows, macOS oder Linux funktionieren alle.

Schritt-für-Schritt-Installation

Das Ziel ist ein einzelnes Verzeichnis, das Ihre Datensätze enthält, sie validiert und eine einreichungsfertige Zusammenfassung rendert. Arbeiten Sie die Schritte der Reihe nach durch.

Bestätigen Sie zunächst, dass Ihre Python-Version neu genug für die unten verwendete Type-Hint-Syntax ist.

python3 --version

Erstellen Sie das Projektverzeichnis und seine Unterverzeichnisse mit einem Befehl, damit Datensätze, Vorlagen und generierte Ausgabe getrennt bleiben.

mkdir -p ai-credit-ledger/{records,templates,output} && cd ai-credit-ledger

Initialisieren Sie ein Git-Repository, damit jede Änderung an Ihrem Ledger versioniert und mit Zeitstempel versehen wird — nützlich, falls ein Prüfer hinterfragt, wann ein Datensatz hinzugefügt wurde.

git init && git branch -M main

Erstellen Sie eine virtuelle Umgebung, um die zwei Abhängigkeiten zu isolieren, die Sie gleich installieren werden.

python3 -m venv .venv

Aktivieren Sie die Umgebung unter macOS oder Linux mit dem soeben erstellten Shell-Skript.

source .venv/bin/activate

Unter Windows PowerShell verwendet der entsprechende Aktivierungsbefehl einen anderen Pfad.

py -3 -m venv .venv; .\.venv\Scripts\Activate.ps1

Aktualisieren Sie pip, bevor Sie irgendetwas installieren; das vermeidet Auflösungsfehler bei älteren gebootstrappten Versionen.

python -m pip install --upgrade pip

Installieren Sie die zwei Bibliotheken, die das Ledger verwendet: PyYAML ist nicht erforderlich, aber Jinja2 rendert die HTML-Zusammenfassung und rich erzeugt lesbare Terminalausgabe für Validierungsfehler.

pip install jinja2 rich

Fixieren Sie die aufgelösten Versionen, damit Ihr Setup reproduzierbar ist, wenn Sie es auf einen Laptop des Schulbezirks verschieben.

pip freeze > requirements.txt

Erstellen Sie nun das Ledger-Skript selbst.

touch ledger.py

Öffnen Sie ledger.py und fügen Sie Folgendes ein. Es definiert eine Datensatzstruktur, validiert jeden Eintrag anhand einer Dokumentations-Checkliste und rendert eine Zusammenfassung.

#!/usr/bin/env python3
"""Track AI educator training hours and assemble a credit-ready evidence packet."""

from __future__ import annotations

import argparse
import csv
import sys
from dataclasses import dataclass, field
from datetime import date
from pathlib import Path

from jinja2 import Environment, FileSystemLoader
from rich.console import Console

ROOT = Path(__file__).resolve().parent
LOG_PATH = ROOT / "records" / "training-log.csv"
TEMPLATE_DIR = ROOT / "templates"
OUTPUT_PATH = ROOT / "output" / "credit-summary.html"

# Confirm your provider's convention before relying on this divisor.
CONTACT_HOURS_PER_CEU = 10.0
REQUIRED_DOCS = ("certificate", "syllabus", "agenda", "accreditation")

console = Console()


@dataclass
class Entry:
    completed_on: date
    title: str
    provider: str
    hours: float
    credit_type: str
    docs: list[str] = field(default_factory=list)

    @property
    def missing_docs(self) -> list[str]:
        return [d for d in REQUIRED_DOCS if d not in self.docs]

    @property
    def ceu(self) -> float:
        return self.hours / CONTACT_HOURS_PER_CEU if self.credit_type == "ceu" else 0.0


def load(path: Path) -> list[Entry]:
    if not path.exists():
        console.print(f"[red]Missing ledger file:[/red] {path}")
        sys.exit(2)
    entries: list[Entry] = []
    with path.open(newline="", encoding="utf-8") as handle:
        for row in csv.DictReader(handle):
            entries.append(
                Entry(
                    completed_on=date.fromisoformat(row["completed_on"].strip()),
                    title=row["title"].strip(),
                    provider=row["provider"].strip(),
                    hours=float(row["hours"]),
                    credit_type=row["credit_type"].strip().lower(),
                    docs=[d.strip().lower() for d in row["docs"].split("|") if d.strip()],
                )
            )
    return entries


def validate(entries: list[Entry]) -> int:
    failures = 0
    seen: set[tuple[str, str]] = set()
    for entry in entries:
        problems = []
        if entry.hours <= 0:
            problems.append("hours must be positive")
        if entry.missing_docs:
            problems.append(f"missing documents: {', '.join(entry.missing_docs)}")
        key = (entry.title.lower(), entry.provider.lower())
        if key in seen:
            problems.append("duplicate title/provider pair")
        seen.add(key)
        if problems:
            failures += 1
            console.print(f"[yellow]{entry.title}[/yellow] -> {'; '.join(problems)}")
        else:
            console.print(f"[green]OK[/green] {entry.title}")
    return failures


def report(entries: list[Entry], output: Path) -> None:
    env = Environment(loader=FileSystemLoader(TEMPLATE_DIR), autoescape=True)
    template = env.get_template("summary.html.j2")
    total_hours = sum(e.hours for e in entries)
    total_ceu = sum(e.ceu for e in entries)
    output.parent.mkdir(parents=True, exist_ok=True)
    output.write_text(
        template.render(
            entries=entries,
            total_hours=total_hours,
            total_ceu=total_ceu,
            complete=all(not e.missing_docs for e in entries),
        ),
        encoding="utf-8",
    )
    console.print(f"[green]Wrote[/green] {output}")


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("command", choices=("validate", "report"))
    args = parser.parse_args()

    entries = load(LOG_PATH)
    if args.command == "validate":
        failures = validate(entries)
        return 1 if failures else 0
    report(entries, OUTPUT_PATH)
    return 0


if __name__ == "__main__":
    raise SystemExit(main())

Speichern Sie die Datei und erstellen Sie dann das Ledger mit seiner Kopfzeile.

printf 'completed_on,title,provider,hours,credit_type,docs\n' > records/training-log.csv

Erstellen Sie die HTML-Vorlage, die der Befehl report rendert.

touch templates/summary.html.j2

Fügen Sie diese Vorlage in die neue Datei ein. Sie gibt ein Vollständigkeits-Flag aus und dann eine Tabelle mit jedem Eintrag und seinem CEU-Äquivalent.

<!doctype html>
<html lang="en">
<head><meta charset="utf-8"><title>AI Training Credit Summary</title></head>
<body>
  <h1>AI Educator Training — Credit Summary</h1>
  <p>Total contact hours: <strong>{{ total_hours }}</strong> ·
     Estimated CEUs: <strong>{{ "%.2f"|format(total_ceu) }}</strong></p>
  <p>Documentation complete for all entries: <strong>{{ complete }}</strong></p>
  <table border="1" cellpadding="6">
    <tr><th>Date</th><th>Title</th><th>Provider</th><th>Hours</th>
        <th>Type</th><th>Documents</th></tr>
    {% for e in entries %}
    <tr>
      <td>{{ e.completed_on }}</td><td>{{ e.title }}</td><td>{{ e.provider }}</td>
      <td>{{ e.hours }}</td><td>{{ e.credit_type }}</td>
      <td>{{ e.docs|join(", ") }}{% if e.missing_docs %} — MISSING: {{ e.missing_docs|join(", ") }}{% endif %}</td>
    </tr>
    {% endfor %}
  </table>
</body>
</html>

Anwendungsbeispiele

Fügen Sie einen abgeschlossenen Fortbildungsdatensatz hinzu. Die Spalte docs verwendet durch Pipes getrennte Bezeichnungen, die den vier erforderlichen Dokumenttypen entsprechen.

echo '2026-01-15,AI Educator Series Module 1,Example Provider,6,ceu,certificate|syllabus|agenda' >> records/training-log.csv

Führen Sie die Validierung aus. Der Prozess endet mit Status 1, wenn ein Eintrag fehlschlägt, wodurch er in einem Skript vor der Einreichung verwendbar ist.

python ledger.py validate

Generieren Sie die HTML-Zusammenfassung aus denselben Datensätzen.

python ledger.py report

Öffnen Sie die generierte Datei in einem Browser. Unter macOS lautet der Befehl open; unter Linux verwenden Sie xdg-open; unter Windows verwenden Sie start.

open output/credit-summary.html

Ein realistischer Durchlauf deckt die Lücke sofort auf. Dem obigen Datensatz fehlt die Akkreditierungserklärung des Anbieters, daher gibt die Validierung diesen Eintrag gelb aus und nennt das fehlende Dokument. Das ist der Punkt: Sie finden das Loch in Ihrem Paket, während Sie den Anbieter noch per E-Mail erreichen können, nicht erst nach der Frist des Registrar.

Für Graduate Credit kombinieren Sie die Ledger-Ausgabe mit einer kurzen Darstellung. Prüfer möchten eine schlichte Aussage darüber, was Sie gelernt haben, was Sie in Ihrem Klassenzimmer geändert haben und wie die Änderung bewertet wurde. Halten Sie sie auf einer Seite und fügen Sie das Artefakt bei. Die HTML-Zusammenfassung ist der Index; die Darstellung ist das Argument.

Dokumentation, die eine Prüfung übersteht

Drei Gewohnheiten unterscheiden Pakete, die genehmigt werden, von Paketen, die zurückgewiesen werden.

Benennen Sie Dateien mit dem Datum und dem Anspruch, den sie stützen — 2026-01-15_certificate_ai-educator-module-1.pdf — statt IMG_4471.pdf. Prüfer bearbeiten Dutzende Einreichungen.

Bringen Sie Stunden mit einer Quelle in Übereinstimmung. Wenn der Syllabus sechs Kontaktstunden angibt und Ihr Ledger sechs sagt, ist die Prüfung trivial. Wenn sie voneinander abweichen, haben Sie einen Streitfall geschaffen, den Sie wahrscheinlich verlieren.

Halten Sie die Akkreditierungserklärung aktuell. Anbieter ändern gelegentlich ihre Berechtigung zur Ausgabe einer bestimmten Credit-Art oder verlieren sie. Eine Erklärung aus dem Jahr Ihrer Anmeldung wird möglicherweise nicht für eine später eingereichte Einreichung akzeptiert, und es lohnt sich, dies direkt beim Anbieter zu bestätigen.

Häufige Fehlerquellen

Das häufigste Problem ist, ein Abschlusszertifikat als ausreichend zu behandeln. Es dokumentiert die Teilnahme, nicht die Kontaktstunden, und es nennt selten die Credit-Art.

Das zweite ist die Annahme von Übertragbarkeit. CEUs, die in einem Bundesstaat oder von einem Schulbezirk genehmigt wurden, werden anderswo nicht automatisch anerkannt, und nichts auf der Quellseite setzt lokale Regeln außer Kraft.

Das dritte ist rückwirkendes Timing. Viele Credit-Wege verlangen, dass Sie Credit innerhalb eines festgelegten Zeitfensters nach Abschluss der Fortbildung beantragen. Wenn Sie eine Reihe abschließen und die Unterlagen erst ein Jahr später einreichen, liegen Sie möglicherweise außerhalb dieses Fensters.

Offene Fragen und Grenzen

Dieser Artikel kann Ihnen nicht sagen, was der Google-Weg kostet, wie viele Credits er einbringt, welche Institution sie ausgibt oder ob Ihr Bundesstaat sie anerkennt. Diese Fakten liegen beim Anbieter und Ihrer Lizenzbehörde, und sie ändern sich. Das hier beschriebene Ledger organisiert, was auch immer diese Antworten sein mögen; es ersetzt sie nicht.

Dokumentation garantiert auch keine Genehmigung. Credit-Entscheidungen sind Ermessensentscheidungen, die von einem Registrar, einem staatlichen Gremium oder einem Schulbezirksausschuss getroffen werden, der Kriterien anwendet, die Sie möglicherweise nicht sehen. Starke Belege erhöhen Ihre Chancen. Sie ersetzen nicht die Entscheidungsinstanz.

Fazit

Die Distanz zwischen dem Abschluss einer KI-Fortbildung für Lehrkräfte und dem Besitz eines Credits ist ein Dokumentationsproblem, und Dokumentationsprobleme sind im Voraus lösbar. Beginnen Sie mit der Google-Bildungsseite für den Weg selbst, bestätigen Sie Credit-Art und Anbieter bei der ausgebenden Institution und sammeln Sie die vier Dokumente — Zertifikat, Syllabus oder Programm, Akkreditierungserklärung und Artefakt — unterwegs statt im Nachhinein. Führen Sie dann ein lokales Ledger wie das obige, sodass Sie beim Öffnen des Einreichungsfensters einen Bericht exportieren, statt ein Semester zu rekonstruieren.