0.1. Was sind LLMs

Ein Large Language Model (LLM) ist ein statistisches Modell für Sprache. Es wurde mit sehr großen Mengen an Text (und oft auch Code) trainiert. Seine zentrale Fähigkeit ist nicht „Denken“ im menschlichen Sinn, sondern das Vorhersagen des jeweils nächsten Stücks Text.

Aus dieser einen Fähigkeit entsteht erstaunlich viel: Erklärungen, Zusammenfassungen, Übersetzungen, Programmcode, Entwürfe und Dialoge. Genau deshalb wirken LLMs intelligent – und genau deshalb machen sie auch charakteristische Fehler.

Large Language Model lässt sich in drei Teile zerlegen:

• Language: Das Modell arbeitet mit Sprache. Dazu gehören natürliche Sprache ebenso wie Quellcode, Markup, Konfigurationsdateien oder Tabellen in Textform.
• Model: Es handelt sich um ein gelerntes Modell, nicht um ein regelbasiertes Expertensystem. Niemand hat dem System Satz für Satz beigebracht, wie Java oder Deutsch „richtig“ geht. Stattdessen hat es aus Beispielen Wahrscheinlichkeiten gelernt.
• Large: Die Modelle sind groß – sowohl in der Menge der Trainingsdaten als auch in der Zahl der internen Parameter. Diese Größe ist ein wichtiger Grund dafür, dass heutige Systeme so vielseitig wirken.

Bekannte Beispiele sind ChatGPT, Claude, Gemini oder auch frei verfügbare Modelle wie Llama. Die Produkte unterscheiden sich in Qualität, Tempo, Kontextgröße und Ausstattung. Die grundlegende Arbeitsweise ist aber vergleichbar.

Ein LLM erzeugt Text schrittweise. Es bekommt eine Eingabe (den Prompt) und schätzt dann, welches nächste Textstück am wahrscheinlichsten folgt. Dieses Stück wird angehängt, danach kommt das nächste, und so weiter.

Das klingt simpel, reicht in der Praxis aber aus, um lange, zusammenhängende Antworten zu erzeugen. Wenn der bisherige Text wie eine Java-Klasse aussieht, wird als Nächstes eher eine Methode oder eine schließende Klammer folgen als ein Kochrezept. Wenn der Text wie eine Erklärung klingt, setzt das Modell die Erklärung fort.

Wichtig ist die Richtung: Das Modell setzt fort, was bereits da ist. Es sucht nicht in einer Wissensdatenbank nach der einen richtigen Antwort. Es erzeugt den Text, der in dieser Situation am plausibelsten wirkt.

Deshalb hängt die Qualität einer Antwort stark vom Prompt ab. Klare Aufgabe, sinnvoller Kontext und Beispiele verschieben, was „plausibel“ ist. Unklare oder widersprüchliche Vorgaben tun das ebenfalls – nur eben in die falsche Richtung.

Intern arbeitet ein LLM nicht mit Wörtern, sondern mit Tokens. Ein Token ist ein kurzes Textstück: ein Wort, ein Wortteil, ein Satzzeichen, ein Stück Quellcode.

Aus dem Satz int anzahl = 5; werden intern mehrere Tokens. Das Modell „sieht“ also keine Buchstabenkette so, wie ein Mensch sie liest, sondern eine Folge solcher Bausteine.

Das hat praktische Folgen:

• Es gibt eine Obergrenze, wie viele Tokens das Modell auf einmal berücksichtigen kann. Das ist das Kontextfenster.
• Längere Gespräche, große Dateien oder viele angehängte Dokumente füllen dieses Fenster. Was nicht mehr hineinpasst, fällt für die aktuelle Antwort faktisch weg.
• Kosten und Geschwindigkeit hängen oft an der Tokenmenge, nicht an der Zahl der Wörter.

Für die Arbeit mit LLMs reicht es, Tokens als die interne Zähleinheit zu verstehen. Die genaue Zerlegung muss man nicht kennen.

Ein LLM wird nicht programmiert wie eine normale Anwendung. Es wird trainiert.

Zuerst kommt in der Regel ein Vortraining auf sehr großen Textmengen aus dem Internet, aus Büchern, Dokumentationen und oft auch öffentlichen Code-Repositories. Dabei lernt das Modell Muster: Grammatik, Fakten, die in den Daten häufig vorkommen, typische Programmierstile, gängige Erklärungen.

Danach folgen meist weitere Schritte, damit das Modell nützlich wird:

• Feinabstimmung auf Dialoge, Anweisungen und Aufgaben („Beantworte die Frage“, „Schreibe eine Funktion“, „Erkläre den Fehler“).
• Häufig auch eine Ausrichtung an gewünschtem Verhalten: hilfreich, höflich, vorsichtig bei gefährlichen Themen, eher strukturierte Antworten statt beliebig fortgesetzter Texte.

Was danach im Modell steckt, ist kein nachschlagbares Archiv. Es sind verdichtete statistische Zusammenhänge. Häufige, gut belegte Muster sitzen fest. Seltene Details, aktuelle Ereignisse nach dem Trainingsstichtag oder sehr spezielle Fachfragen sitzen unsicher oder fehlen ganz.

Viele Produkte ergänzen das Modell deshalb um Werkzeuge: Suche, Dateizugriff, Code-Ausführung, Anbindung an eine Wissensbasis. Das ändert die Nutzung erheblich. Das Kernmodell selbst bleibt trotzdem ein Textfortsetzer.

Ein LLM hat in der einzelnen Anfrage nur das, was im Kontext liegt:

• den Systemhinweis oder die Grundanweisung
• den bisherigen Gesprächsverlauf
• den aktuellen Prompt
• zusätzlich übergebene Dateien, Codeausschnitte oder Suchergebnisse

Es erinnert sich nicht von sich aus an gestern, an andere Projekte oder an „die ganze Codebasis“. Wenn ein Produkt das so wirkt, liegt das an gespeicherten Chats, Indexen, Regeln oder extra angebundenen Daten – nicht daran, dass das Modell ein dauerhaftes Gedächtnis hätte.

Deshalb ist es in der Praxis oft wichtiger, den richtigen Kontext zu liefern, als möglichst viele Einzelheiten der Syntax selbst zu kennen. Das Modell kann Boilerplate und API-Aufrufe oft selbst erzeugen. Es kann aber nicht wissen, welche Fachregel in diesem Projekt gilt, wenn niemand sie ihm gibt.

LLMs wirken klug, weil Sprache und Denken für uns eng zusammenhängen. Wer eine gute Erklärung, einen sinnvollen Plan oder lauffähigen Code formuliert, dem unterstellen wir Verständnis.

Ein LLM kann genau das: Muster aus unzähligen Erklärungen und Programmen so kombinieren, dass eine neue, oft brauchbare Formulierung entsteht. Es kann Zwischenschritte aufschreiben, Alternativen gegenüberstellen und Einwände vorwegnehmen. Manche Systeme sind zusätzlich darauf trainiert, länger „nachzudenken“, also erst eine interne Kette von Zwischenschritten zu erzeugen und dann die Antwort.

Das ist leistungsfähig. Es ist aber kein Garant für Wahrheit. Das Modell optimiert auf plausible Fortsetzung, nicht auf nachgewiesene Korrektheit. Ein selbstsicherer Ton sagt wenig darüber, ob die Aussage stimmt.

LLMs sind besonders gut, wenn Sprache, Muster und vorhandener Kontext reichen:

• Formulieren, Umformulieren, Zusammenfassen
• Code erzeugen, umbauen und erklären
• Boilerplate, Tests, Dokumentation und wiederkehrende Strukturen
• Ideen sammeln, Alternativen skizzieren, Checklisten erstellen
• Fremden Code oder fremde Texte schneller zugänglich machen

Genau das verschiebt in der Softwareentwicklung die Gewichte. Viele Details, die man früher nachschlagen oder auswendig kennen musste, kann das Modell übernehmen. Die Arbeit des Menschen verlagert sich stärker auf Ziel, Kontext, Architektur, Prüfung und Verantwortung.

Einige Grenzen folgen direkt aus der Arbeitsweise:

• Halluzinationen: Das Modell kann Dinge erfinden, die korrekt klingen: APIs, die es nicht gibt, Methoden mit falschen Parametern, Quellen, die nie existierten.
• Keine zuverlässige Weltprüfung: Ohne angebundene Werkzeuge führt das Modell den Code nicht wirklich aus und prüft Fakten nicht gegen die Realität.
• Kein belastbares Langzeitgedächtnis: Was nicht im Kontext steht, ist für die aktuelle Antwort nicht vorhanden.
• Trainingsstichtag: Reines Modellwissen endet irgendwann. Neuere Bibliotheken, geänderte APIs oder aktuelle Ereignisse fehlen, solange sie nicht über Tools oder den Prompt nachgeliefert werden.
• Unsicherheit bei Seltenem: Je spezieller, neuer oder widersprüchlicher ein Thema ist, desto eher rät das Modell.
• Kein eigenes Ziel: Das Modell will nichts erreichen. Es setzt den Prompt fort. Steuerung, Prioritäten und Verantwortung bleiben beim Menschen.

Für die Praxis heißt das: Ein LLM ist ein sehr starker Assistent, aber kein Ersatz für Verständnis und Kontrolle. Besonders bei Code gilt: Lesen, prüfen, testen.

Wer mit LLMs arbeitet, braucht weniger ein vollständiges Bild der inneren Mathematik. Entscheidend sind ein paar Haltungen:

• Das Modell setzt Text fort. Gute Vorgaben erzeugen bessere Fortsetzungen.
• Kontext ist die eigentliche Steuerung: Ziel, Randbedingungen, vorhandener Code, gewünschtes Format.
• Details wie Syntax und Boilerplate werden unwichtiger, weil das Modell sie oft selbst liefert.
• Wichtiger werden die Fragen, die das Modell nicht allein klären kann: Was soll entstehen? Welche Architektur passt? Was darf es nicht tun? Wie erkenne ich, dass die Antwort falsch ist?

Diese Verschiebung ist der Grund, warum ich die Inhalte dieser Webseite umstrukturieren und stärker auf die Arbeit mit KI ausrichten möchte.

Die Aussagen oben sind bewusst an Originalarbeiten und Herstellerdokumentationen angelehnt, nicht an Blog-Zusammenfassungen. Die meisten Quellen sind Englisch – das sind die Dokumente, in denen die Labore selbst beschreiben, wie die Systeme funktionieren.

Formulierungen wie „nicht Denken“ sind eine didaktische Vereinfachung. Gemeint ist die technische Kernoperation: das Modell erzeugt das jeweils nächste Textstück. Ob man das philosophisch „Denken“ nennen will, ist eine andere Debatte.

Note

Wer nur eine Quelle lesen will: Shanahan erklärt die Kernidee am klarsten. Wer die Technik sehen will: GPT-2 und GPT-3. Wer Grenzen braucht: den GPT-4-Bericht.

• Murray Shanahan: Talking About Large Language Models (2023) (extern)
  Die beste lesbare Primärquelle zur Kernaussage dieses Textes. Shanahan beschreibt LLMs als generative statistische Modelle über Tokens: Die eigentliche Frage an das Modell lautet nicht „Was ist wahr?“, sondern „Wie geht dieser Text wahrscheinlich weiter?“. Er erklärt auch, warum flüssige Sprache uns Verständnis unterstellen lässt.

• OpenAI: Better language models and their implications (2019) (extern)
  Zugängliche Darstellung von GPT-2. OpenAI formuliert die Lernaufgabe ausdrücklich als: das nächste Wort vorhersagen, gegeben die bisherigen Wörter. Derselbe Mechanismus zeigt ohne extra Aufgabentraining Ansätze von Übersetzung, Fragenbeantwortung, Leseverständnis und Zusammenfassung.

• Radford et al.: Language Models are Unsupervised Multitask Learners (GPT-2, 2019) (extern)
  Das zugehörige Paper. Es belegt, dass aus der einen Vorhersageaufgabe viele Sprachleistungen entstehen können, wenn Modell und Daten groß genug sind.

• Brown et al.: Language Models are Few-Shot Learners (GPT-3, 2020) (extern)
  Zeigt, was „Large“ konkret heißt: ein autoregressives Modell mit 175 Milliarden Parametern, trainiert auf sehr großen Textmengen. Aufgaben und Beispiele stehen im Prompt; die Gewichte werden dafür nicht extra angepasst. Das bestätigt sowohl die Skalierung als auch die starke Abhängigkeit vom Prompt.

• OpenAI Help: Understanding and counting tokens (extern)
  Offizielle Erklärung: Modelle verarbeiten Text als Tokens (Zeichen, Wortteile, ganze Wörter, Satzzeichen). Tokenzahl ist nicht Wortzahl. Darüber werden Nutzung und Abrechnung gezählt.

• OpenAI API: Key concepts (extern)
  Prompt und erzeugte Ausgabe müssen zusammen in die maximale Kontextlänge passen. Das ist genau das Kontextfenster aus dem Text.

• Anthropic: Context windows (extern)
  Herstellerdokumentation zum Kontextfenster: Was in der Anfrage liegt, zählt; bei langen Gesprächen füllt sich das Fenster; ältere Teile müssen gekürzt oder zusammengefasst werden, sonst fallen sie weg.

• OpenAI: Prompting (extern)
  „The quality of your output often depends on how well you’re able to prompt the model.“ Klare Aufgabe, Beispiele und Struktur im Prompt verschieben, was das Modell als plausible Fortsetzung behandelt.

• Chen et al.: Evaluating Large Language Models Trained on Code (Codex, 2021) (extern)
  Belegt, dass Modelle nicht nur auf natürlicher Sprache, sondern auf öffentlichem Code (hier: GitHub) trainiert werden. Codex ist ein GPT, das auf Code nachtrainiert wurde; eine Produktionsvariante trieb GitHub Copilot.

• Ouyang et al.: Training language models to follow instructions with human feedback (InstructGPT, 2022) (extern)
  Die klassische Pipeline nach dem Vortraining: zuerst Feinabstimmung auf gewünschte Antworten, danach Ausrichtung mit menschlichem Feedback (RLHF). Größer allein macht ein Modell nicht automatisch hilfreicher oder ehrlicher.

• Touvron et al.: Llama 2: Open Foundation and Fine-Tuned Chat Models (2023) (extern)
  Offenes Gegenstück zu den geschlossenen Chat-Produkten: Vortraining, Dialog-Feinabstimmung und Sicherheitsausrichtung. Die grundlegende Arbeitsweise bleibt vergleichbar, auch wenn Qualität und Ausstattung differieren.

• Lewis et al.: Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks (RAG, 2020) (extern)
  Wichtige Präzisierung: In den Gewichten steckt Wissen, aber kein nachschlagbares Archiv, das man leicht aktualisieren könnte. RAG koppelt das generative Modell an einen externen Index. Das bestätigt sowohl „kein Lexikon im Modell“ als auch die spätere Produktidee, Suche und Wissensbasen anzubinden.

• OpenAI: Function calling (extern)
  Das Kernmodell führt Code nicht selbst aus und prüft die Welt nicht selbst. Es kann strukturierte Werkzeugaufrufe erzeugen; die Anwendung sucht, rechnet oder führt aus und gibt das Ergebnis zurück in den Kontext.

• Wei et al.: Chain-of-Thought Prompting Elicits Reasoning in Large Language Models (2022) (extern)
  Zwischenschritte aufzuschreiben verbessert bei hinreichend großen Modellen Rechen-, Alltags- und Symbolaufgaben. Das ist immer noch Textfortsetzung – nur mit einer längeren Kette vor der Antwort.

• OpenAI: Learning to reason with LLMs (o1, 2024) (extern)
  Manche Systeme werden darauf trainiert, länger „nachzudenken“: erst eine interne Kette von Schritten, dann die sichtbare Antwort. OpenAI beschreibt das ausdrücklich als Chain of Thought, die per Verstärkungslernen verbessert wird.

• OpenAI: GPT-4 (2023) (extern)
  First-Party-Bestätigung der Grenzen: Das Modell halluziniert, ist nicht vollständig zuverlässig, kann selbstsicher falsch liegen, kennt Ereignisse nach dem Trainingsstichtag nicht zuverlässig und lernt nicht dauerhaft aus dem Gespräch. OpenAI rät bei wichtigen Einsätzen zu menschlicher Prüfung.

• Ji et al.: Survey of Hallucination in Natural Language Generation (2023) (extern)
  Fachüberblick: Generative Modelle erzeugen flüssigen Text, der unbeabsichtigt erfundene Inhalte enthalten kann. Genau das ist mit Halluzinationen gemeint – inklusive erfundener Fakten und Quellen.

• Kandpal et al.: Large Language Models Struggle to Learn Long-Tail Knowledge (2023) (extern)
  Empirischer Beleg für „Unsicherheit bei Seltenem“: Je seltener ein Fakt im Trainingsmaterial vorkommt, desto unsicherer sitzt er im Modell. Retrieval hilft – reines Modellwissen skaliert hier schlecht.

Diese Texte gehen tiefer, als dieser Einführungsartikel muss:

• Vaswani et al.: Attention Is All You Need (2017) (extern) – die Transformer-Architektur hinter den heutigen Modellen.
• Kaplan et al.: Scaling Laws for Neural Language Models (2020) (extern) – warum Größe von Daten, Parametern und Rechenaufwand so stark wirkt.
• Bai et al.: Constitutional AI (Anthropic, 2022) (extern) – eine andere Ausrichtungsmethode neben RLHF: hilfreich und vorsichtig über Prinzipien statt nur über menschliche Bewertungen.
• Bender und Koller: Climbing towards NLU (2020) (extern) – die schärfere These, dass Form (Textstatistik) nicht automatisch Bedeutung ist. Shanahan baut darauf auf.