Marco Patzelt
Back to Overview
4. März 2026

Warum Prompt Engineering nicht skaliert (und was stattdessen funktioniert)

Prompt Engineering behandelt KI wie eine Jobbeschreibung. Produktionssysteme brauchen Umgebungsdesign — Kontext-Injektion, Code-Generierung und Verifikation.

Das Vertrauensproblem

Die gesamte KI-Branche hat die letzten zwei Jahre damit verbracht, sich auf das Modell zu fixieren. Bessere Gewichte. Größere Kontextfenster. Mehr Parameter. Und dann kopieren wir "Du bist ein Senior Financial Analyst" in einen System-Prompt und wundern uns, warum es sich Sachen ausdenkt.

Das ist kein KI-Problem. Das ist ein Denkproblem.

Man kann jemandem keinen Jobtitel geben und Expertise erwarten. Nicht bei einem Menschen. Nicht bei einer Maschine. Wenn ich jetzt zu dir komme und sage "du bist ein Senior SEO-Berater" — was wirst du tun? Du hast keine Kundendaten. Keinen Zugang zu Analytics. Keine Tools. Keinen Kontext über das Geschäft. Du würdest raten. Du würdest selbstbewusst klingen. Du würdest falsch liegen.

Genau das bauen wir gerade. Selbstbewusste Ratemaschinen.

Der Fehler war nie das Modell. Der Fehler war, dass wir vergessen haben, was einen Profi zum Profi macht. Es ist nicht der Titel. Es ist die Umgebung.

Warum Prompting kein Engineering ist

Engineering erfordert Reproduzierbarkeit. Ich schreibe eine Funktion, ich teste sie, ich weiß was sie macht. Jedes Mal. Das ist der Vertrag.

Prompts haben diesen Vertrag nicht. Ein Prompt ist eine Variable — keine Funktion. Ändere ein Wort und der gesamte Output verschiebt sich. Nicht vorhersagbar. Nicht reproduzierbar. Einfach anders.

Ich habe Teams wochenlang einen System-Prompt tunen sehen, der für 10 Anwendungsfälle funktioniert, nur um festzustellen, dass er beim 11. bricht. Also patchen sie den Prompt. Jetzt bricht Fall 7. Sie patchen wieder. Fall 3 hat eine Regression. Das ist kein Engineering. Das ist Whack-a-Mole mit einem Sprachmodell.

Es gibt keine Konvergenz. Kein Type-System. Keinen Compiler der sagt "das wird fehlschlagen." Du deployest es und hoffst. So will ich keine Produktionssysteme bauen.

Die Branche hat sogar einen Begriff dafür geprägt: Prompt Drift. Dein Prompt funktioniert am Montag. Der Modellanbieter aktualisiert etwas auf seiner Seite. Am Mittwoch sehen deine Outputs anders aus. Du hast nichts geändert. Der Boden hat sich unter dir verschoben. Und du hast null Diagnose-Tools um herauszufinden warum.

Die drei Fehlermodi bei Skalierung

Fehlermodus 1: Inkonsistenz

Gleicher Prompt, gleiches Modell, gleicher Input — jedes Mal ein anderer Output. Nicht dramatisch anders. Subtil anders. Und subtile Unterschiede sind die schlimmste Art in der Produktion, weil sie durch QA kommen und dann in Produktion brechen.

Es gibt keine Versionskontrolle für "gute Prompts." Du kannst den Text versionieren, klar. Aber du kannst das Verhalten nicht versionieren. Der Prompt ist identisch. Das Verhalten nicht. Das ist ein fundamentales Problem, das kein noch so gutes Prompt Engineering löst.

Fehlermodus 2: Kontext-Explosion

Jeder Edge Case wird gleich behandelt: mehr Instruktionen zum Prompt. "Behandle auch diesen Fall." "Vergiss nicht dieses Szenario." "Wenn der User X sagt, mach stattdessen Y."

Dein System-Prompt wächst von 200 Tokens auf 2.000 Tokens auf 20.000 Tokens. Token-Kosten pro Request explodieren. Und hier ist die Sache, über die niemand spricht: Die Modell-Performance degradiert mit längerem Kontext. Je mehr Instruktionen du reinpackst, desto wahrscheinlicher ignoriert das Modell einige davon. Du kämpfst gegen die Architektur statt mit ihr zu arbeiten.

Fehlermodus 3: Die Generalisierungsfalle

Ein Prompt der für Kundensupport getuned ist, bricht wenn du ihn für Datenanalyse nutzen willst. Also schreibst du einen weiteren Prompt. Und noch einen. Jetzt hast du 47 Prompts, jeder für einen spezifischen Use Case getuned, jeder separat gepflegt, jeder driftet unabhängig.

Du skalierst horizontal — mehr Prompts — statt vertikal — bessere Architektur. Das ist die falsche Achse. Jeder Prompt den du hinzufügst ist eine neue Wartungslast, ein neues Ding das brechen kann, eine neue Variable in einem System das bereits zu komplex ist.

Was wirklich skaliert: Architektur, nicht Prompts

Ein Senior-Berater kommt in ein Unternehmen und das Erste was er bekommt ist Zugang. Hier ist dein Login. Hier ist die Datenbank. Hier ist das CRM. Hier sind die Zahlen des letzten Quartals. Hier sind die internen Docs. Hier ist dein Schreibtisch, deine Monitore, deine Tools.

Newsletter

Wöchentliche Insights zu AI-Architektur. Kein Spam.

Erst dann liefert er Wert.

Wir haben das alles bei LLMs übersprungen. Wir haben ihnen einen Rollenspiel-Prompt gegeben und echte Arbeit erwartet. Das war die Erbsünde.

Was wenn das LLM nicht das Produkt ist? Was wenn es das Gehirn in einem Körper ist, den wir noch nicht gebaut haben?

Das Modell braucht kein besseres Training. Es braucht einen besseren Schreibtisch. Und dieser Schreibtisch ist Architektur.

Kontext-Injektion zur Laufzeit

Wissen nicht in Prompts hardcoden. Das Datenbankschema zur Laufzeit injizieren. Die Geschäftsregeln injizieren. Die Live-Daten injizieren. Die Constraints injizieren. Das Modell nicht bitten sich zu erinnern — ihm den Weltzustand jetzt geben, in diesem Moment, für genau dieses Problem.

Die Umgebung wird zum Prompt. Config-Datei aktualisieren, System passt sich sofort an. Kein Retraining. Kein Prompt-Tuning. Kein Regressions-Testing über 47 Use Cases.

Ich habe über diesen Wechsel von statischen Konfigurationen zu dynamischen Umgebungen geschrieben — die Idee, dass man die Welt um das Modell herum baut, anstatt die Welt in einem Prompt zu beschreiben.

Strukturierte Outputs: Code statt Text

Hör auf das LLM nach Antworten zu fragen. Frag es nach Code.

Ein LLM ist keine Datenbank die du abfragst. Es ist ein Just-in-Time-Compiler. Du gibst ihm Kontext und es kompiliert einen Ausführungsplan on the fly. SQL. Python. Was auch immer das Problem erfordert. Der Output ist kein Text. Es ist ein Programm. Und Programme können verifiziert werden.

Ich nenne das Code Augmented Generation. Nicht Retrieval Augmented Generation.

RAG sagt "finde Text der ähnlich aussieht und fasse ihn zusammen." Das ist semantische Ähnlichkeit die sich als Verständnis ausgibt. CAG sagt "hier ist das Schema, schreib eine Query, führe sie aus, beweise das Ergebnis." Eines rät. Das andere rechnet.

Verifikationsschleifen

Selbst ein einzelner Berechnungspfad reicht nicht. Denk daran wie ein echter Profi arbeitet. Er führt nicht eine Analyse durch und präsentiert sie als Wahrheit. Er prüft nach. Er gleicht ab. Er verifiziert seine eigene Arbeit bevor sie seinen Schreibtisch verlässt.

Baue zwei unabhängige Berechnungspfade. Vergleiche Outputs. Delta unter Schwellwert? Verifiziert. Delta über Schwellwert? Das System verweigert die Antwort. Es wirft eine Exception statt zu halluzinieren.

Die Architektur bittet das Modell nicht ehrlich zu sein. Sie erzwingt Ehrlichkeit durch Engineering.

Von Variablen zu Systemen

Hier sehe ich die Branche wieder den falschen Weg einschlagen. Leute hören "Context Engineering" und denken es bedeutet bessere Kontextfenster zu schreiben. Tut es nicht. Es bedeutet die Infrastruktur zu bauen die Kontext-Injektion automatisch macht.

Prompts werden zu Daten, nicht zu Engineering. Du verwaltest sie wie Config-Dateien — YAML, JSON, Markdown. Die Architektur übernimmt die Logik. Die Prompts übernehmen die Spezifika. Du "engineerst" keine Config-Datei. Du konfigurierst ein System.

Und die Frameworks? LangChain hat Entwickler 200 Zeilen Abstraktions-Spaghetti schreiben lassen um einen einzigen Prompt zu senden. Dabei liefert das Gleiche in 4 Zeilen roher API-Calls. Das beste Framework für Agent-Entwicklung hat sich als kein Framework herausgestellt. Nur First Principles und Fetch.

Abstraktionsschichten verstecken das Denken. Wenn du bare metal arbeitest, verstehst du jedes Byte das durch dein System fließt. Volle Kontrolle ist der Burggraben. Nicht das Framework. Nicht das Prompt-Template. Das Verständnis.

Der Paradigmenwechsel

Das Modell wird immer probabilistisch sein. Das ist kein Fehler. Das ist es, was es flexibel genug macht um jedes Problem zu bewältigen das du ihm stellst.

Dein Job ist nicht das Modell deterministisch zu machen. Dein Job ist die Welt drum herum so zu bauen, dass sie probabilistische Intention in deterministische Ausführung verwandelt.

Kontext-Injektion statt Memory. Code-Generierung statt Text-Generierung. Harte Verifikation statt weichem Vertrauen.

Wir werden uns nie zur Zuverlässigkeit prompten. Die Antwort war immer die Umgebung.

Newsletter

Wöchentliche Insights zu AI-Architektur

Kein Spam. Jederzeit abbestellbar.

Häufig gestellte Fragen

Prompts sind Variablen, keine Funktionen. Ihnen fehlt Reproduzierbarkeit, sie leiden unter Drift und brechen bei wachsenden Edge Cases. Produktion braucht Architektur, nicht bessere Wörter.

Prompt Drift entsteht wenn Modell-Updates das Verhalten ändern ohne den Prompt zu ändern. Dein Prompt funktioniert Montag, Mittwoch sind die Outputs anders. Keine Diagnose-Tools verfügbar.

Prompt Engineering fokussiert auf Instruktionen. Context Engineering baut Systeme die zur Laufzeit Daten, Schema und Constraints injizieren — die Umgebung wird zum Prompt.

CAG behandelt das LLM als Just-in-Time-Compiler der ausführbaren Code statt Text ausgibt. Anders als RAG das über Ähnlichkeit rät, berechnet CAG verifizierte Ergebnisse via SQL oder Python.

Abstraktionsschichten verstecken das Denken. 200 Zeilen Framework-Code für einen Prompt vs 4 Zeilen rohe API-Calls. Bare Metal gibt volle Kontrolle über jedes Byte im System.

Umgebung bauen: Kontext zur Laufzeit injizieren, Code statt Text generieren, über duale Berechnungspfade verifizieren. Die Architektur erzwingt Ehrlichkeit durch Engineering.

Lass uns
vernetzen.

Ich bin immer offen für spannende Diskussionen über Frontend-Architektur, Performance und moderne Web-Stacks.

Schreib mir
Schreib mir