Prompt-Schulden: Warum starke KI-Modelle an alten Anweisungen scheitern
Kurz gefasst
Prompt-Schulden sind dauerhafte Anweisungen, die für frühere Modelle geschrieben wurden und neue Modelle übersteuern. Entfernen Sie trainierte Selbstverständlichkeiten, formulieren Sie 90-Prozent-Regeln als Bedingungen und testen Sie die gekürzte Fassung gegen typische Aufgaben. Sicherheitsgrenzen und persönlicher Kontext bleiben.
Mit KI diskutierenClaude ↗ChatGPT ↗
In der Softwareentwicklung gibt es den Begriff „technische Schulden“. Gemeint sind Kompromisse im Code, die zugunsten der Geschwindigkeit eingegangen werden und später korrigiert werden müssen. Technische Schulden sammeln Zinsen an, wenn auf kompromissbehaftetem Code Neues aufgebaut wird. In großen Unternehmen verbringen Entwickler einen erheblichen Teil ihrer Arbeitszeit damit, diese Schulden abzubauen.
2026 ist ein Pendant dazu in der Arbeit mit künstlicher Intelligenz entstanden. Und zwar nicht nur beim Programmieren, sondern bei jeder Art von Arbeit. Im Juni machte der Dateningenieur und Datenstratege Drew Breunig den Begriff Prompt Debt populär, auf Deutsch: Prompt-Schulden. Der Ausdruck war schon vorher vereinzelt aufgetaucht, setzte sich aber erst nach seinem Essay durch. Breunig untersuchte Produktionsanwendungen, in denen ein Prompt das Verhalten eines ganzen Systems steuern soll. Das Problem reicht jedoch weiter. Prompt-Schulden stecken in Prompts, Skills, Dateien wie CLAUDE.md und sogar in Schleifen, die KI automatisch erzeugt. Wer sie nicht abbaut, wird ihre Folgen bald deutlich spüren.
Am 21. Juli veröffentlichte Simon Willison ein Gespräch mit den Anthropic-Ingenieuren Thariq Shihipar und Cat Wu. Darin beschrieben sie einen bemerkenswerten Fall: Das Claude-Code-Team hatte den System-Prompt für Fable 5 und Opus 4.8 um 80 % gekürzt. OpenAI empfiehlt für GPT-5.6 ebenfalls schlankere Prompts mit weniger Wiederholungen und Beispielen. Das Magazin Every veröffentlichte kurz zuvor „The Case Against Skills“. Im Mittelpunkt steht Mike Taylor, Mitautor des Lehrbuchs Prompt Engineering for Generative AI. Sein Argument: Viele vorgefertigte Anweisungspakete kämpfen gegen das, was das Modell bereits beherrscht.
Kurz gesagt: Was sind Prompt-Schulden? Lange galt folgende Regel: Wenn die KI etwas nicht tut oder umgekehrt etwas tut, was sie nicht tun soll, ergänzen Sie den Prompt um eine Anweisung, die den Fehler korrigiert. Je länger Sie mit demselben Prompt arbeiten, desto mehr solcher Anweisungen sammeln sich an. Früher oder später widersprechen sie einander. Und der Prompt wird so umfangreich, dass selbst sein Autor nicht mehr durchblickt.
Meine Einschätzung: Prompt-Schulden hat inzwischen jeder. Selbst wer seit mehr als einem Jahr kurze, verständliche Prompts schreibt und genau das anderen vermittelt, kann sie an anderer Stelle ansammeln. Meine Prompt-Schulden fand ich in Skills, die ich gemeinsam mit Claude erstellt hatte, und in Schleifen, die ich in KI-Agenten einsetze. Es gibt noch weniger offensichtliche Verstecke. Dazu später.
Minus 80 %: So sah es intern aus
Ausgangspunkt ist das Gespräch, das Simon Willison am 21. Juli veröffentlichte. Shihipar erklärte dort, das Claude-Code-Team habe den System-Prompt für Fable 5 und Opus 4.8 um 80 % gekürzt. Für ältere Modelle blieb die ausführliche Fassung bestehen. Es geht um modellabhängige Anweisungen, nicht um ein universelles Rezept.
Claude Code ist Anthropics Coding-Agent. Sein System-Prompt steuert unter anderem Werkzeugnutzung, Arbeitsweise und Ausgabe. Jede Zeile war irgendwann aus einem konkreten Grund hineingekommen. Trotzdem zeigte die Überarbeitung, dass viele dieser Gründe für die neue Modellgeneration nicht mehr trugen.
Willisons Transkript nennt vier Änderungen, die sich auf normale Wissensarbeit übertragen lassen:
- Beispiele wurden entfernt, wenn sie das Modell enger festlegten als nötig. Shihipar sagte, die Modelle seien ohne diese Beispiele kreativer gewesen.
- Verbotslisten wichen mehr Kontext. Weniger „Tun Sie X nicht“, mehr Information darüber, welches Ergebnis gebraucht wird und welche Grenzen wirklich gelten.
- Absolute Regeln wurden auf Ausnahmen geprüft. Das Team fand Anweisungen, die in 90 % der Fälle richtig waren, aber in den übrigen 10 % störten. Solche Regeln wurden bedingt formuliert.
- Der System-Prompt wurde pro Modell gepflegt. Die gekürzte Fassung galt für Fable 5 und Opus 4.8, nicht automatisch für kleinere oder ältere Modelle.
Das Muster dahinter ist klar: Ein Kriterium überlässt dem Modell Urteilsspielraum. Ein absolutes Verbot funktioniert nur in den Situationen, die seine Autoren vorhergesehen haben.
Im Juni hatte ich den geleakten System-Prompt des Chatbots Claude Fable 5 analysiert: 17.000 Wörter, Dutzende Abschnitte, Wiederholungen und veraltete Passagen. Zur Einordnung: Das ist ein anderes Dokument. Das Claude-Code-Team kürzte den Prompt seines Coding-Agenten, denn jedes Anthropic-Produkt hat eigene Anweisungen. Damals beschrieb ich, wie umfangreich und widersprüchlich ein solches Dokument intern ausfallen kann.
Aus diesem Kapitel sollten Sie eine Regel mitnehmen. Sie lässt sich sofort anwenden, ohne den restlichen Text abzuwarten. Öffnen Sie Ihre Anweisungen, etwa Ihren Nutzer-Prompt, Ihre Projektbeschreibung oder Ihren bevorzugten Arbeits-Prompt, und suchen Sie nach Verboten:
- „Verwenden Sie niemals Listen.“
- „Schreiben Sie nicht lang.“
- „Stellen Sie keine unnötigen Fragen.“
Formulieren Sie jedes Verbot als Kriterium um.
Schlecht: „Schreiben Sie niemals lang.“
Besser: „Passen Sie den Umfang der Antwort an die Frage an: Bei einer Alltagsfrage genügen ein paar Absätze, bei einer beruflichen Analyse so viel wie erforderlich.“
Warum besser? Das Kriterium funktioniert in unterschiedlichen Situationen, ohne jede davon im Voraus regeln zu müssen. Eine ähnliche Umstellung beschrieb das Claude-Code-Team für seinen System-Prompt. Als Nächstes geht es darum, warum sie überhaupt nötig wurde und woher das Übermaß in Ihren Prompts stammt.
Woher Prompt-Schulden kommen: fünf Ursachen
Die Kürzung um 80 % wirft eine unbequeme Frage auf: Wenn selbst beim Team eines der stärksten KI-Unternehmen der Welt vier Fünftel des Prompts überflüssig waren, trotz Metriken, Evaluierungen und Reviews, wie sieht es dann in Ihren Prompts, Skills und CLAUDE.md-Dateien aus, die nie jemand gemessen hat? Die Antwort beginnt bei der Frage, wie sich die Schulden ansammeln.
Ausgangspunkt ist der Urheber des Begriffs. Breunigs Definition beruht auf einer Unterscheidung, die Sie sich merken sollten. Prompts in natürlicher Sprache eignen sich hervorragend für einmalige Anfragen und dialogisches Arbeiten. Ein Mensch sieht dabei jede Antwort und kann sofort korrigieren. Für ein System, das Tag für Tag unbeaufsichtigt gleich arbeiten soll, sind sie dagegen ein schlechtes Steuerungsinstrument. Breunig beobachtete das in Produktionsanwendungen, in denen der Prompt faktisch die technische Spezifikation ersetzt. Katie Parrott vom Magazin Every übertrug seine Logik auf normale Anwender und formulierte die Definition, die ich im weiteren Text verwende: Prompt-Schulden sind Anweisungen, die das Modell überlebt haben, für das sie geschrieben wurden.
Ursache 1: Der Fortschritt der Modelle. Von den ersten ChatGPT-Versionen bis Mitte 2025 arbeiteten Modelle sehr unbeständig. Ihre Prompts brauchten deshalb zahlreiche Anweisungen und Tricks. Taylor erinnert sich: Um GPT-3 brauchbaren Code entlocken zu können, setzte er „Hacks und magische Wörter“ ein. Bereits mit GPT-4 waren diese Methoden nicht mehr nötig. Doch selbst o3, das führende Reasoning-Modell von OpenAI im ersten Halbjahr 2025, halluzinierte nach Messungen des Unternehmens häufiger als sein Vorgänger o1. Mehr Fähigkeiten bedeuteten nicht automatisch mehr Zuverlässigkeit. Fehler mussten weiterhin durch Anweisungen, Einschränkungen und Beispiele dafür korrigiert werden, „wie es sein soll und wie nicht“.
Ein weiteres Problem: Ältere Modelle ignorierten sogar ausdrücklich formulierte Anweisungen. Deshalb war es völlig üblich, zentrale Vorgaben im Prompt zwei-, drei- oder viermal zu wiederholen. Die Gewohnheit lebt bis heute. Breunig zählte in der Momentaufnahme des Fable-Chatbot-System-Prompts, die er im Juni untersuchte, Wiederholungen der Urheberrechtsregeln an bis zu sechs Stellen, verteilt über sechs verschiedene Abschnitte des Dokuments.
Ursache 2: Die Empfehlung, den Prompt nach jedem Fehlschlag zu korrigieren. Dazu ergänzt man Anweisungen, die denselben Fehler künftig ausschließen sollen. Die Idee ist logisch. Das Problem: Neue Anweisungen fügen Anwender bereitwillig hinzu. Nach jeder neuen Modellversion zu prüfen, ob sie noch nötig sind, vergessen sie dagegen.
Ursache 3: Psychologie. Viele Menschen vertrauen KI noch immer nicht vollständig. Die KI erledigt die Arbeit, aber Sie tragen die Verantwortung. Deshalb liegt der Versuch nahe, sich psychologisch abzusichern: Sie erklären dem Modell bis ins kleinste Detail, wie es arbeiten soll, liefern Beispiele guter Arbeit und ergänzen Verbote sowie Einschränkungen. In manchen Prompts VERFALLEN DIE AUTOREN GANZ SELBSTVERSTÄNDLICH IN GROSSBUCHSTABEN, weil sie hoffen, dass die KI dadurch besser arbeitet.
Tut sie nicht.
Die dritte Ursache ist übrigens die einzige, die sich mit keiner Technik und keinem Kniff beheben lässt. Dafür müssen Sie Ihre Haltung gegenüber KI ändern. Natürlich bleiben die entscheidenden Prüfungen des Ergebnisses bestehen. Wenn Sie aber jeden einzelnen Schritt anweisen und kontrollieren, ist es ehrlich gesagt einfacher, die Arbeit selbst zu erledigen.
Ursache 4: Prompt-Schulden sind ansteckend. Sie sehen im Internet einen Prompt mit vielen Likes oder laden einen Skill mit Tausenden Sternen herunter. Aber haben Sie geprüft, wie das Ganze funktioniert? Für welche Modellgeneration wurde es geschrieben? Ist der Autor vertrauenswürdig?
Ursache 5: Anweisungen überleben das Modell. Das ist die tückischste Form der Schulden und laut Breunig ihr wichtigstes Symptom. Ein Prompt entsteht immer für ein bestimmtes Modell, passend zu dessen Stärken und Schwächen. Das Modell wechselt, die Anweisungen bleiben. Auf dem neuen Modell versagt ein Teil davon auf unerwartete Weise. Breunig verweist auf Daten des Monitoring-Unternehmens Datadog, Stand Frühjahr 2026: GPT-4o blieb das meistgenutzte Modell im von Datadog beobachteten Traffic. Dabei handelt es sich um ein Modell aus dem Jahr 2024. Nicht weil es das beste ist, sondern weil Prompts, die jahrelang für GPT-4o angepasst wurden, auf neuen Modellen auseinanderfallen. Für Teams ist es einfacher, nichts anzufassen. Dann halten nicht mehr die Nutzer den Prompt. Der Prompt hält seine Nutzer und bindet sie an ein alterndes Modell.
Der Wendepunkt 2026: Die Regeln funktionieren, aber anders als erhofft
Warum explodieren die Schulden ausgerechnet jetzt? Prompts wachsen seit Jahren, und bis vor Kurzem störte das kaum jemanden. Die Antwort wirkt zunächst widersinnig. Nicht die Schwächen neuer Modelle machten Prompt-Schulden zum Problem, sondern ihre Stärke. 2026 werden Modelle vor allem für agentische Szenarien trainiert, also für lange, selbstständige Arbeit ohne einen Menschen, der die KI nach jedem Schritt korrigiert. Dafür muss ein Modell Anweisungen präzise befolgen. Genau das wird ihm nun ernsthaft beigebracht. Plötzlich zeigt sich: Die mehrstöckigen Prompts, die ältere Modelle nur diagonal lasen, führen neue Modelle vollständig aus. Alles, was über Jahre in Prompts geschrieben wurde, wirkt nun gleichzeitig.
Am deutlichsten zeigt sich dieser Wandel im aktuellen Leitfaden zu GPT-5.6. OpenAI empfiehlt dort outcome-orientierte Prompts: Ziel, relevanter Kontext, Grenzen, benötigte Belege, Erfolgskriterien und Ausgabeformat. Aufforderungen wie „Denken Sie härter nach“ oder „Erzeugen Sie mehrere Kandidaten“ seien nicht nötig, wenn das gewählte Modell und der Reasoning-Modus die Arbeit bereits steuern.
Der Leitfaden rät außerdem zu schlankeren System-Prompts. Wiederholte Anweisungen und Beispiele sollen entfernt, Werkzeugbeschreibungen vereinfacht und jede Anweisung nur einmal genannt werden. Beispiele und Stilregeln bleiben dort, wo sie eine Produktanforderung abbilden oder eine gemessene Lücke schließen. Kürze ist kein Selbstzweck. Entscheidend ist die Wirkung im Test.
Die naheliegende Schlussfolgerung lautet: Formulieren Sie Regeln sorgfältiger, ohne Widersprüche und überflüssige Wörter, dann funktioniert alles. Leider nein. Entscheidend ist, in welchem Maßstab Modelle gehorsam geworden sind. Einzelne Anweisungen führen sie inzwischen präzise aus. Genau das macht alte Prompts gefährlich. Zwischen „eine Zeile ausführen“ und „ein hundertseitiges Regelwerk über fünfzig Arbeitsschritte hinweg im Kopf behalten“ liegt jedoch ein Abgrund. Den hat auch die neue Generation noch nicht überwunden.
Der nächste Schlag gegen den alten Ansatz ist der Benchmark HANDBOOK.md des Evaluierungsteams von Surge AI. Die Agenten erhielten 65 Arbeitsaufgaben in virtuellen Unternehmen aus fünf Branchen. Dazu kamen Unternehmensrichtlinien mit 20 bis 124 Seiten. Das Ergebnis: Das beste Modell bestand 36,2 % der Tests strikt, die meisten führenden Modelle weniger als ein Viertel. Die Forschenden dokumentierten außerdem Fälle, in denen Agenten die Einhaltung der Richtlinie meldeten, obwohl ihr Handeln dagegen verstieß. Ein großes Regelwerk schafft keine Kontrolle. Es kann die Illusion von Kontrolle schaffen.
Das ergibt folgendes Bild. 2024 war ein aufgeblähter Prompt harmloser Ballast. Das Modell ignorierte Überflüssiges. 2026 schadet derselbe Prompt auf drei Arten gleichzeitig:
- Veraltete Regeln werden buchstäblich und eifrig ausgeführt.
- Überflüssige Anweisungen verbrauchen Kontext, Tokens und Zeit.
- Wirklich große Regelwerke bleiben dennoch unzuverlässig, bis hin zu falschen Meldungen über ihre Einhaltung.
Genau deshalb bringt Bereinigung einen messbaren Gewinn. In internen Durchläufen von OpenAI steigerte die Umstellung von Prompts auf die Outcome-first-Formel die Qualität um 10 bis 15 %. Gleichzeitig sanken die Tokens um 41 bis 66 % und die Kosten um 33 bis 67 %. OpenAI ergänzt diese Zahlen ausdrücklich um einen Vorbehalt: Sie sind Richtwerte. Testen Sie sie an Ihren eigenen Aufgaben.
Auch die praktische Konsequenz dieses Kapitels lässt sich in fünf Minuten umsetzen. Öffnen Sie Ihren bevorzugten Arbeits-Prompt und suchen Sie nach verstärkenden Formulierungen:
- „maximal gründlich“
- „prüfen Sie alle Varianten“
- „kontrollieren Sie mehrfach“
- „erreichen Sie vollständige Sicherheit“
Löschen Sie sie. Prüfen Sie anschließend an typischen Aufgaben, ob die Antwortqualität stabil bleibt. Wenn Sie über eine API oder mit einem Agenten arbeiten, können Sie zudem Geld oder Abonnementlimits sparen. Diese Optimierung besteht aus dem Drücken der Löschtaste.
Eine Unstimmigkeit bleibt. Wenn Regeln, Beispiele und Details aus Prompts verschwinden sollen, was gehört dann hinein? Ein Prompt kann schließlich nicht nur aus der Zeile „Machen Sie es gut“ bestehen.
Kann er.
Sollte er aber nicht.
Entscheidend ist deshalb, was nach dem Kürzen übrig bleibt.
So prompten Sie Modelle heute: Schreiben Sie keine Regeln, füllen Sie die „Leerstellen“
Für dieses Kapitel reicht eine Formel: Belasten Sie das Modell nicht mit dem, was es bereits weiß. Geben Sie ihm das, was nur Sie wissen. Moderne Modelle haben, grob gesagt, fast alle Bücher der Welt gelesen. Ihnen das Handwerk beizubringen, ist sinnlos. Was ein Modell dagegen nicht kennt und nie von allein erfahren wird, ist Ihre konkrete Situation.
In meiner Analyse des System-Prompts von Fable 5 nannte ich diese Informationen „Leerstellen“: Wofür brauchen Sie das Ergebnis? Wer wird es lesen? Bei welcher Entscheidung soll es helfen? Was bedeutet „gut“ für Sie? Der System-Prompt wurde nicht für Sie geschrieben, die Modellgewichte erst recht nicht. Niemand sonst wird diese Lücken für Sie schließen. Daraus folgt ein einfacher Test für jede Zeile Ihres Prompts. Dem Modell zu erklären, wie man Artikel schreibt, ist unsinnig. Es hat Millionen davon gesehen. Sinnvoll sind dagegen Umfang, Struktur und redaktionelle Vorgaben. Die stehen in keinem Buch, weil sie von Ihnen kommen.
Nur in zwei Fällen müssen Sie Wissen selbst mitbringen. Erstens bei einem sehr engen Fachgebiet, zu dem weltweit nur wenige Texte existieren: interne Abläufe Ihres Unternehmens, regionale Besonderheiten, eine seltene Methode oder ein eng umrissenes Berufsfeld. Zweitens bei allem, was nach dem Wissensstichtag des Modells passiert ist. Ich beginne eine solche Sitzung mit dem Satz: „Wir arbeiten an X. Sammeln Sie zuerst aktuelle Informationen zum Thema. Wir haben jetzt August 2026.“ Dann sucht das Modell, statt aus dem Wissensstand des Vorjahres zu antworten.
Ich fasse daraus nun das Gerüst eines neuen Prompts zusammen. Die Outcome-first-Formel aus dem Leitfaden von OpenAI lässt sich so übersetzen: Ergebnis, Abnahmekriterien, Einschränkungen, konkreter Kontext. Im ersten Text über Prompts zeigte ich einen ausführlichen Prompt zur Auswahl eines Laptops aus fünf Blöcken: Aufgabe, Ausgabeformat, Einschränkungen, Punkte zur Selbstprüfung und Kontext. Dieselbe Aufgabe sieht nach der Formel von 2026 so aus:
„Helfen Sie mir, einen Laptop auszuwählen. Ich trage ihn jeden Tag mit mir, deshalb darf er höchstens 1,8 kg wiegen. Ich arbeite im Browser mit 20+ Tabs und in Figma, abends spiele ich Civilization. Das Budget liegt bei 800–1.200 Euro. Fertig ist die Aufgabe, wenn Sie 3-5 aktuelle Modelle finden, die zu diesem Preis verfügbar sind, jeweils mit geprüften Links zu den Shops. Falls Ihnen Informationen für die Auswahl fehlen, fragen Sie nach, bevor Sie mit der Suche beginnen.“
Verglichen mit der alten Version sind zwei Blöcke verschwunden. Das Ausgabeformat fehlt, weil das Modell die Tabelle selbst wählen kann. Falls Sie eine feste Vorgabe haben, gehört sie als Einschränkung in eine einzige Zeile. Auch die Selbstprüfung ist weggefallen, denn sie steckt bereits im Abnahmekriterium: „aktuelle Modelle“, „verfügbar“ und „mit geprüften Links“. Der Prompt ist nur noch halb so lang. Der Kontext wurde aber nicht gekürzt, sondern erweitert. Mein Grundsatz lautet: Regeln streichen, nicht Informationen.
Noch ein interessanter Punkt. Ich testete den Prompt kurz im normalen ChatGPT und erhielt dieses Ergebnis:
Aktuelle Modelle fragen zunehmend selbst nach, wenn ihnen entscheidende Informationen fehlen. Das ist ein weiteres Beispiel dafür, warum Sie Modelle möglichst einfach prompten sollten. Zusätzlich benötigtes Wissen versuchen sie inzwischen selbst zu beschaffen. Wie stark sich eine Anfrage dabei in Teilfragen auffächern kann, zeigt meine Datenanalyse „Der Prompt als Lego-Figur“.
Bisher hilft das allerdings nur bei kleineren Beispielen. Bei einer umfangreichen Aufgabe, besonders in einem KI-Agenten, beginnt die Arbeit schon vor dem Prompt: blinde Flecken durchgehen und Fragen nach ihrer Wichtigkeit ordnen. Diese Vorbereitung behandelte ich bereits unter dem Bild „Karte und Territorium“, angelehnt an den Leitfaden von Thariq Shihipar. Vorbereitung bedeutet nicht, alles aufzublähen. Ihr Ergebnis ist eine kurze Leistungsbeschreibung mit guten Referenzen, kein Regelwerk.
Bei der Abnahme zählt das Artefakt. Wenn das Ergebnis der Arbeit Programmcode, eine Präsentation, ein Text oder die Gliederung eines Textes ist, prüfen Sie dieses Artefakt und nicht den Bericht darüber. Die dokumentierten Fehlschläge im HANDBOOK.md-Benchmark zeigen, wie überzeugend ein Agent die Einhaltung einer Richtlinie melden kann, obwohl sein Handeln dagegen verstößt. Für Arbeitsberichte gilt dasselbe: Eine glatte Zusammenfassung ist noch kein Beleg dafür, dass die Arbeit gelungen ist.
Falls Sie das Artefakt nicht direkt bewerten können, laden Sie es in einen neuen Chat oder einen neuen KI-Agenten und lassen Sie es analysieren. Selbst mit demselben Modell ist der neue Chat auf eine unvoreingenommene Prüfung eines „fremden“ Ergebnisses ausgerichtet. Dafür eignet sich ein unabhängiger Prüf-Agent: Er kennt die Entstehungsgeschichte des Artefakts nicht und sucht gezielt nach Fehlern statt nach Gründen, die eigene Arbeit zu verteidigen.
Die Ein-Zeilen-Merkliste für dieses Kapitel: erwartetes Ergebnis, Abnahmekriterien, Einschränkungen, Ihr Kontext. Nehmen Sie das Artefakt ab, nicht die Erzählung darüber.
Alle Hinweise in diesem Kapitel betreffen Prompts, die Sie neu schreiben. Dort liegt aber nicht der größte Teil der Schulden. Der versteckt sich im Archiv: in Google Docs mit Sammlungen „liebster Prompts“, in Skills, die Sie lange nicht geöffnet haben, im Gedächtnis des Modells über Sie und in Schleifen, in denen sich die KI selbst anweist.
Wo sich die Schulden verstecken: drei Fallen
Bisher ging es um Schulden in Prompts. Die sind immerhin sichtbar, denn der Prompt liegt vor Ihnen. Schwieriger sind Schulden, die sich dort ansammeln, wo niemand hinsieht. Ich kenne drei solcher Orte. Einer davon wurde für mich persönlich zum Problem.
Falle 1: Modelle bringen einander schlechte Gewohnheiten bei. Modelle reproduzieren beim Schreiben eigener Prompts häufig Muster aus den Jahren 2024 und 2025. In meinem Test mit Fable entstand deshalb ein Entwurf nach einem bereits veralteten Muster.
Während der Arbeit an diesem Text wollte ich einen Prompt entwickeln, mit dem sich veraltete Prompts und Skills von überflüssigen Elementen bereinigen lassen. Ich übergab die Aufgabe an Fable. Das war das Ergebnis:
„Hier ist mein [Skill / CLAUDE.md / Benutzer-Prompt]. Prüfen Sie ihn zunächst, ohne etwas umzuschreiben. Ordnen Sie jede Anweisung einer dieser Kategorien zu: (1) Invariante: eine Tatsache oder Einschränkung, die Sie nicht selbst herausfinden können; (2) Duplikat des Antrainierten: Das tun Sie auch ohne Anweisung; (3) Relikt: wurde für ein altes Modell oder einen Fehler geschrieben, der sich nicht mehr reproduzieren lässt; (4) 90-%-Regel: trifft meistens zu, ist aber als ‚immer/nie‘ formuliert; (5) Konflikt: widerspricht einer anderen Zeile oder überschneidet sich mit ihr. Schlagen Sie für (2) und (3) die Löschung vor, für (4) eine bedingte Formulierung und für (5), welche Zeile bleiben soll. Sicherheits- und Zugriffsregeln bleiben unangetastet. Zeigen Sie am Ende eine gekürzte Version und eine Liste der gelöschten Punkte, jeweils mit einer einzeiligen Begründung. Die Entscheidung über jede Zeile treffe ich.“
Schauen Sie genau hin. Mehrere Fehler fallen sofort auf.
- Widersprüchliche Anweisungen: Am Anfang soll nichts umgeschrieben werden, am Ende soll eine gekürzte Version stehen.
- Analyse und Handlung werden vermischt: Die Entscheidung über jede Zeile soll beim Nutzer liegen, aber Claude liefert in derselben Antwort bereits eine fertige Kurzfassung.
- Auch die detaillierte Anleitung für die Prüfung in den Punkten 1-5 widerspricht den neuen Regeln für Prompts. Mit etwas Wohlwollen ist sie dennoch gerechtfertigt, denn selbst neue Modelle kennen diese Regeln derzeit nicht.
Meine Schlussfolgerung ist einfach: Seien Sie vorsichtig, wenn Sie KI bitten, einen Prompt von Grund auf zu schreiben. Einen brauchbaren Entwurf liefert sie. Aus der finalen Version sollten Sie alles Überflüssige entfernen. Im weiteren Verlauf erkläre ich, wie sich Prompts manuell refaktorieren lassen, und zeige außerdem einen sehr einfachen Prompt, den ich selbst verwende.
Falle 2: Skills. Ein Skill ist ebenfalls ein Prompt, nur gespeichert: eine Anweisung, die das Modell für einen bestimmten Aufgabentyp lädt. Also können sich auch darin Schulden verstecken.
Zuerst der Fall, dass ein Skill aus dem Internet heruntergeladen wird. Im „Fall gegen Skills“ wird Taylors Position durch eine Messung gestützt: den SWE-Skills-Bench. Die Forschenden nahmen 49 öffentliche Skills für die Programmierung und führten dieselben Aufgaben mit und ohne diese Skills aus. Das Ergebnis: 39 von 49 Skills brachten keinerlei Verbesserung. Der durchschnittliche Gewinn lag bei plus 1,2 %, während der zusätzliche Token-Aufwand einzelner Skills bei gleichem Ergebnis bis zu plus 451 % erreichte. Die Messung stammt aus dem März und prüfte Software-Engineering-Aufgaben mit Claude Code und Haiku 4.5. Die Autoren nennen den engen Benchmark-Kontext selbst als Einschränkung. Die Zahlen lassen sich deshalb nicht ohne Weiteres auf Schreib-, Recherche- oder andere Wissensarbeit übertragen.
Der Benchmark untersuchte fremde, öffentliche Skills in Software-Engineering-Aufgaben. Genau darin liegt ein weiteres Problem. Viele Menschen laden populäre Skills herunter, die bessere Ergebnisse beim Programmieren oder Webdesign versprechen oder dem Modell KI-Slop abgewöhnen sollen. Der Autor eines Skills hat ihn jedoch für sich geschrieben, nicht für Sie. Sein Verständnis von „Verbesserung“ ist nicht automatisch Ihres. Deshalb überzeugt mich Taylors Prinzip: Jeder Skill muss sich seinen Platz in der Bibliothek durch eine Messung verdienen, nicht durch ein Gefühl von Nützlichkeit. Nehmen Sie mehrere Aufgaben, führen Sie sie mit und ohne Skill aus und vergleichen Sie die Ergebnisse. Gefällt Ihnen das Resultat nicht, passt der Skill nicht zu Ihnen.
Im Winter begann ich, Skills für Claude zu nutzen, zunächst in einem Chatbot für Websuche und Textarbeit, später auch in Claude Code. Mein Ablauf sah so aus: Zuerst besprach ich die Aufgabe mit Claude und entwickelte einen Entwurf für den Arbeitsprozess. Danach testete ich ihn in mehreren Experimenten, gab Rückmeldung und ließ Claude aus den gefestigten Regeln einen Skill erstellen.
Wenn das Modell während der Arbeit Fehler machte oder mir Verbesserungsmöglichkeiten auffielen, beschrieb ich sie Claude und ließ den Skill überarbeiten.
Anfangs funktionierte das gut. Die Arbeit mit dem Skill wurde schneller, und das Modell lieferte Ergebnisse, die mir gefielen. Später sank die Qualität etwas. Ich hielt das für den typischen Effekt, dass man mit einer Arbeit zunächst zufrieden ist und ihre Mängel erst später erkennt. Also überarbeitete ich den Skill weiter nach demselben Muster, ohne das eigentliche Problem zu bemerken.
Mit der Veröffentlichung von Opus 4.7 kam der Einbruch. Mit demselben Skill schrieb das Modell plötzlich miserable Texte: kaputte Struktur, seltsame Sprache, völlig unlesbare Überschriften. In kleinen Textexperimenten arbeitete das Modell dagegen gar nicht so schlecht.
Nach einem weiteren misslungenen Text erklärte ich Opus direkt im Chat, wie der Text überarbeitet werden sollte. Das Modell weigerte sich unerwartet mit den Worten: „Der Skill verbietet das!“ Erst dann öffnete ich den Skill selbst und war entsetzt. Über Monate hatte das Modell ihn mit Anweisungen und Beispielen dafür gefüllt, was zu tun und was zu vermeiden war. Es war ein Musterbeispiel für Prompt-Schulden, reif für den Bilderrahmen.
Seitdem folge ich einer einfachen Regel: Einen Skill nicht nur weiterentwickeln, sondern regelmäßig refaktorieren und alles entfernen, was veraltet ist oder stört. Dasselbe gilt übrigens für den nächsten Punkt.
Falle 3: Schleifen, in denen sich die KI selbst anweist. Nach meiner Einschätzung sind sie in den kommenden Monaten die wichtigste potenzielle Brutstätte für Prompt-Schulden. Wie solche Schleifen funktionieren, habe ich im Beitrag über Loop Engineering beschrieben: Eine KI promptet sich selbst nach den Regeln von 2024-25, bewertet das Ergebnis immer wieder und versucht, es durch überarbeitete Prompts zu verbessern. Natürlich ebenfalls nach den Regeln von 2024-25.
Wie schnell sich dieses Muster mit neuen Modellgenerationen verändert, lässt sich nicht seriös vorhersagen. Bis dahin gilt dieselbe Lösung wie bei Skills: Wechseln Sie gelegentlich in den manuellen Modus, greifen Sie in die Schleife ein und analysieren Sie gemeinsam mit dem Modell die Anweisungen, nach denen es arbeitet. Alles Überflüssige fliegt raus.
Prompt-Schulden refaktorieren
In großen IT-Teams gehört der Abbau technischer Schulden zum laufenden Betrieb. Dafür gibt es verschiedene Methoden, doch sie folgen alle derselben Idee: Sie müssen regelmäßig eine feste Zeit für den Abbau technischer Schulden reservieren.
Psychologisch ist das leicht nachzuvollziehen. Angenommen, Sie haben Ihre KI sauber eingerichtet und sparen dadurch 2 Stunden pro Tag. Wenn Sie nichts tun, schrumpft diese Ersparnis nach und nach zusammen, wie mein Beispiel mit den Skills zeigt. Irgendwann müssen Sie Ihre Prozesse erneut einrichten. Investieren Sie dagegen täglich 10 Minuten der gewonnenen Zeit ins Refactoring, bleibt die Ersparnis mindestens stabil und wächst höchstwahrscheinlich sogar. Sie müssen nicht jeden Tag 10 Minuten an Prompts und Skills feilen. Ich erledige das lieber alle 2 Wochen und nehme mir dafür direkt 2 Stunden Zeit.
So würde ich den Prozess aufbauen.
Schritt 1: Bestandsaufnahme. Sammeln Sie alle dauerhaften Anweisungen in einem Dokument: Benutzer-Prompt, Projektanweisungen, Memory, also das, was das Modell über Sie gespeichert hat, Skills und, falls vorhanden, CLAUDE.md samt Entsprechungen. Wo diese Elemente liegen, habe ich in meinem Text über die sechs Personalisierungsbereiche ausführlich erklärt. Hier reicht die wichtigste Erinnerung: Die Anweisungen liegen über verschiedene Ecken der Benutzeroberfläche verstreut. Genau darin steckt die Hälfte des Problems. Sie müssen diese Bestandsaufnahme nur einmal erledigen, danach liegt alles griffbereit vor Ihnen.
Versuchen Sie nicht, sofort alles zu refaktorieren. Beginnen Sie mit Aufgaben, die aktuell und nützlich, aber nicht kritisch sind. Dass beim ersten Versuch alles perfekt gelingt, ist keineswegs sicher. Einen kritischen Prozess zu beschädigen, wäre keine besonders gute Idee. Genauso wenig sinnvoll ist es, den Prompt für die Planung einer Urlaubsreise zu refaktorieren, wenn Sie erst in einem Jahr verreisen wollen.
Schritt 2: Invariante oder Urteil? Gehen Sie jetzt die Liste durch und ordnen Sie jede Zeile einem von zwei Typen zu. Eine Invariante ist eine Tatsache, die das Modell nicht selbst herausfinden kann: wie Sie heißen, was Sie beruflich machen, dass Sie ohne den Buchstaben „ё“ schreiben oder Tabellen nur für Vergleiche benötigen. Ein Urteil bezeichnet etwas, das das Modell auch ohne Hinweis beherrscht: „Schreibe korrekt“, „Achte auf Details“, „Antworte professionell“, „Prüfe die Logik“. Die Regel ist einfach: Invarianten bleiben, Urteile fliegen raus. Sie machen ein Modell nicht aufmerksamer, indem Sie ihm Aufmerksamkeit befehlen. Sie zwingen es nur zu erraten, was Sie damit gemeint haben.
Schritt 3: Aus „immer“ und „nie“ werden Bedingungen. Wenden Sie auf die Zeilen, die Schritt 2 überstanden haben, eine Methode an, die das Claude-Code-Team „90/10“ nennt: Wenn eine Regel in 90 % der Fälle stimmt, formulieren Sie kein Verbot, sondern beschreiben Sie, wann sie gilt. Aus „Antworte immer kurz“ wird: „Antworte bei Alltagsfragen kurz, bei beruflichen Analysen ausführlich.“ Die Empfehlung von OpenAI zielt in dieselbe Richtung: Reservieren Sie absolute Formulierungen für echte Verbote, also für Dinge, die nie und unter keinen Umständen geschehen dürfen.
Bei einem normalen Menschen kommen so zwei oder drei Zeilen zusammen, bezogen auf einen langen Prompt, nicht zwanzig.
Schritt 4: Entfernen Sie alles, was sich aus dem Kontext ableiten lässt. Eine eigene Kategorie von Prompt-Schulden bilden Anweisungen, die nur wiederholen, was das Modell ohnehin aus dem Kontext erkennt. Wenn Sie das Modell bitten, mit Code zu arbeiten, müssen Sie nicht zusätzlich „Antworte wie einem Entwickler“ in den Prompt schreiben. Das Modell wählt diesen Stil von selbst als Grundmodus. Wenn Sie einem Prompt redaktionelle Richtlinien beifügen, müssen Sie deren einzelne Punkte nicht noch einmal wiederholen.
Es gibt auch den umgekehrten Fall, in dem eine solche Anweisung nützlich ist. Angenommen, Sie stoßen auf den Preprint einer wichtigen wissenschaftlichen Arbeit über Mathematik, laden ihn herunter, geben ihn in die KI und fragen, was darin passiert ist. Standardmäßig spricht das Modell mit Ihnen wie mit einem Mathematiker. Falls Sie keiner sind, ergänzen Sie im Prompt: „Erkläre es einem Laien.“
Schritt 5: Messen Sie. Erinnern Sie sich an den Hinweis von OpenAI: „Die Zahlen sind Richtwerte, prüfen Sie sie anhand Ihrer eigenen Aufgaben“? Er gilt auch gegen uns. Glauben Sie weder mir noch Anthropic einfach aufs Wort. Nehmen Sie zwei oder drei typische Aufgaben, führen Sie sie einmal mit der alten Sammlung und einmal mit der gekürzten Version aus und vergleichen Sie die Ergebnisse. Schneidet die gekürzte Fassung irgendwo schlechter ab? Gut. Dann haben Sie eine Anweisung gefunden, die tatsächlich funktioniert. Nehmen Sie sie guten Gewissens wieder auf. Eine Revision ist keine Ideologie des totalen Minimalismus. Sie hilft Ihnen, wirksame Zeilen von Ballast zu unterscheiden.
Wann Sie Prompts nicht radikal kürzen sollten
Echte Invarianten, persönliche Fakten sowie sämtliche Sicherheits- und Zugriffsbeschränkungen bleiben erhalten. Dazu gehören Regeln wie „Sende keine E-Mails ohne Bestätigung“, „Fasse die Produktionsumgebung nicht an“ und „Verwende keine Zahlungsdaten“. Das sind keine Schulden, sondern Sicherheitsgurte. Ihr Wert hängt nicht davon ab, wie oft sie gebraucht werden.
Dasselbe gilt für internes Fachwissen, regionale Besonderheiten und verbindliche Produktanforderungen. Wenn das Modell diese Informationen nicht selbst kennen kann, ist ihre Länge kein Argument für die Löschung.
Auch Beispiele und Formatregeln dürfen bleiben, wenn ein Vergleichstest einen messbaren Vorteil zeigt. Refactoring folgt den Ergebnissen Ihrer Aufgaben, keinem Ideal des kürzesten möglichen Prompts.
Prompt-Schulden automatisch prüfen: Skript und Audit-Prompt
Für die erste Bestandsaufnahme habe ich einen kleinen Detektor gebaut. Das Python-Skript braucht keine externen Bibliotheken. Es markiert Selbstbeschreibungen des Modells, absolute Verbote, wiederholte Verbotsobjekte und einige klar definierte Widersprüche. Zusätzlich gibt es einen Meta-Prompt für die semantische Prüfung mit einem Sprachmodell.
Wichtig ist die Grenze: Das Skript versteht weder Ihren Arbeitskontext noch die Folgen einer gelöschten Regel. Ein Treffer ist deshalb ein Prüfkandidat, keine Löschanweisung. Sicherheitsregeln, Zugriffsgrenzen und verbindliche Produktanforderungen bleiben bestehen, bis ein Mensch ihre Änderung freigibt.
Beide Dateien als ZIP herunterladen. Das Skript und der Prompt liegen außerdem einzeln unter prompt_schulden_detektor.py und prompt-schulden-audit-prompt.txt.
So führen Sie den Detektor aus
Speichern Sie das Skript als prompt_schulden_detektor.py. Es läuft mit Python 3.10 oder neuer:
python3 prompt_schulden_detektor.py "Ihr Prompt"
python3 prompt_schulden_detektor.py pfad/zum/prompt.md
cat prompt.txt | python3 prompt_schulden_detektor.py --stdin
python3 prompt_schulden_detektor.py --stdin --json < prompt.txtDie Textausgabe eignet sich für die manuelle Prüfung. Mit --json erhalten Sie strukturierte Treffer für weitere Werkzeuge. Die Schalter --no-outdated, --no-forbidden und --no-repetitions deaktivieren einzelne Prüfungen.
Der vollständige Python-Detektor
#!/usr/bin/env python3
"""Heuristischer Prompt-Schulden-Detektor ohne externe Abhängigkeiten.
Der Detektor markiert Kandidaten. Er kann nicht entscheiden, ob eine Sicherheits-
oder Produktregel fachlich notwendig ist. Prüfen Sie jeden Treffer im Kontext und
vergleichen Sie Änderungen an realen Aufgaben.
Verwendung:
python prompt_schulden_detektor.py "Ihr Prompt"
python prompt_schulden_detektor.py pfad/zum/prompt.md
cat prompt.txt | python prompt_schulden_detektor.py --stdin
python prompt_schulden_detektor.py --stdin --json
"""
from __future__ import annotations
import argparse
import json
import re
import sys
from collections import Counter, defaultdict
from pathlib import Path
from typing import Iterable
class PromptSchuldenDetektor:
"""Findet auffällige Regeln mit bewusst konservativen Heuristiken."""
def __init__(
self,
enable_outdated: bool = True,
enable_forbidden: bool = True,
enable_repetitions: bool = True,
) -> None:
self.enable_outdated = enable_outdated
self.enable_forbidden = enable_forbidden
self.enable_repetitions = enable_repetitions
self.severity = {
"outdated": "info",
"forbidden": "warning",
"repetition": "warning",
"contradiction": "critical",
}
self.outdated_patterns = [
(
re.compile(
r"\b(?:du|Sie)\s+(?:bist|sind)\s+(?:ein(?:e)?\s+)?"
r"(?:KI-Assistent|Sprachmodell|künstliche\s+Intelligenz|Assistent|KI)\b",
re.IGNORECASE,
),
"Die Selbstidentifikation beschreibt das Modell statt der Aufgabe.",
"Entfernen, sofern die Rolle nicht für die konkrete Ausgabe nötig ist.",
),
(
re.compile(
r"\b(?:denke\s+daran|erinnere\s+dich|vergiss\s+nicht)\s*,?\s*"
r"(?:dass\s+)?(?:du|Sie)\s+(?:ein(?:e)?\s+)?"
r"(?:Sprachmodell|KI|Assistent|kein\s+Mensch)\s+(?:bist|sind)?\b",
re.IGNORECASE,
),
"Die Erinnerung an die KI-Natur steuert kein fachliches Ergebnis.",
"Entfernen oder durch ein konkretes Ausgabeziel ersetzen.",
),
(
re.compile(
r"\b(?:erwähne|sage)\s+nicht\s*,?\s*(?:dass\s+)?du\s+"
r"(?:eine?\s+)?(?:KI|Modell|Assistent)\s+bist\b|"
r"\b(?:erwähnen|sagen)\s+Sie\s+nicht\s*,?\s*(?:dass\s+)?Sie\s+"
r"(?:eine?\s+)?(?:KI|Modell|Assistent)\s+sind\b",
re.IGNORECASE,
),
"Das Verbot betrifft die Selbstdarstellung des Modells, nicht die Aufgabe.",
"Nur behalten, wenn die Formulierung eine verbindliche Produktanforderung ist.",
),
(
re.compile(
r"\b(?:du|Sie)\s+(?:hast|haben|besitzt|besitzen)\s+"
r"(?:kein|keine|keinen)\s+(?:Bewusstsein|Emotionen|Gefühle)\b",
re.IGNORECASE,
),
"Die Aussage über Bewusstsein oder Gefühle hilft selten bei der Aufgabe.",
"Entfernen, sofern sie nicht Gegenstand der gewünschten Antwort ist.",
),
]
object_text = r"(?P<object>[^.!?\n]{2,120})"
self.forbidden_patterns = [
re.compile(
r"\b(?:verwende|benutze|nutze|verwenden\s+Sie|benutzen\s+Sie|nutzen\s+Sie)\s+"
r"(?:bitte\s+)?(?:nicht|kein(?:e|en|er|es)?)\s+" + object_text,
re.IGNORECASE,
),
re.compile(
r"\b(?:sage|erwähne|antworte|sagen\s+Sie|erwähnen\s+Sie|antworten\s+Sie)\s+"
r"(?:bitte\s+)?nicht\s+" + object_text,
re.IGNORECASE,
),
re.compile(
r"\b(?:vermeide|vermeiden\s+Sie)\s+" + object_text,
re.IGNORECASE,
),
re.compile(
r"\b(?:es\s+ist\s+verboten|verboten\s+ist)\s+" + object_text,
re.IGNORECASE,
),
re.compile(
r"\b(?:niemals|auf\s+keinen\s+Fall)\s+" + object_text,
re.IGNORECASE,
),
]
self.contradiction_pairs = [
(
re.compile(r"\b(?:sei|seien\s+Sie|antworte|antworten\s+Sie)\s+kurz\b", re.IGNORECASE),
re.compile(
r"\b(?:gib|geben\s+Sie)\s+(?:eine\s+)?ausführliche\s+Antwort\b|"
r"\bantworte\s+ausführlich\b",
re.IGNORECASE,
),
"Kürze und Ausführlichkeit werden gleichzeitig verlangt.",
"Bedingungen ergänzen: wann kurz, wann ausführlich.",
),
(
re.compile(
r"\b(?:verwende|benutze|verwenden\s+Sie|benutzen\s+Sie)\s+"
r"(?:keinen|nicht)\s+Slang\b|\b(?:vermeide|vermeiden\s+Sie)\s+Slang\b",
re.IGNORECASE,
),
re.compile(
r"\b(?:verwende|benutze|verwenden\s+Sie|benutzen\s+Sie)\s+Slang\b",
re.IGNORECASE,
),
"Slang wird zugleich verboten und verlangt.",
"Eine Regel entfernen oder die Zielgruppen als Bedingungen nennen.",
),
(
re.compile(
r"\b(?:verwende|verwenden\s+Sie)\s+(?:keine|nicht)\s+Listen\b|"
r"\b(?:vermeide|vermeiden\s+Sie)\s+Listen\b",
re.IGNORECASE,
),
re.compile(
r"\b(?:verwende|verwenden\s+Sie)\s+(?:immer\s+)?Listen\b",
re.IGNORECASE,
),
"Listen werden zugleich verboten und verlangt.",
"Den passenden Ausgabetyp je Aufgabe als Bedingung formulieren.",
),
]
@staticmethod
def _normalisiere_objekt(text: str) -> str:
text = text.casefold().strip(" \t.,!?;:()[]{}\"'„“‚‘")
text = re.sub(r"\b(?:der|die|das|den|dem|des|ein|eine|einen|einem|einer)\b", " ", text)
text = re.sub(r"\s+", " ", text)
return text.strip()
@staticmethod
def _overlaps(a: dict, b: dict) -> bool:
start = max(a["start"], b["start"])
end = min(a["end"], b["end"])
if end <= start:
return False
shorter = min(a["end"] - a["start"], b["end"] - b["start"])
return (end - start) / max(shorter, 1) >= 0.8
def _finde_veraltete_muster(self, text: str) -> list[dict]:
findings = []
for pattern, explanation, recommendation in self.outdated_patterns:
for match in pattern.finditer(text):
findings.append(
{
"category": "outdated",
"severity": self.severity["outdated"],
"snippet": match.group(0).strip(),
"explanation": explanation,
"recommendation": recommendation,
"start": match.start(),
"end": match.end(),
}
)
return findings
def _finde_verbote(self, text: str) -> list[dict]:
findings = []
for pattern in self.forbidden_patterns:
for match in pattern.finditer(text):
findings.append(
{
"category": "forbidden",
"severity": self.severity["forbidden"],
"snippet": match.group(0).strip(),
"object": self._normalisiere_objekt(match.group("object")),
"explanation": (
"Die absolute Formulierung kann eine sinnvolle Ausnahme blockieren. "
"Die Heuristik kann ihre fachliche Notwendigkeit nicht beurteilen."
),
"recommendation": (
"Prüfen, ob eine echte Sicherheitsgrenze vorliegt; andernfalls als "
"Bedingung formulieren und im Vergleichstest prüfen."
),
"start": match.start(),
"end": match.end(),
}
)
return findings
def _finde_wiederholungen(self, prohibitions: Iterable[dict]) -> list[dict]:
groups: defaultdict[str, list[dict]] = defaultdict(list)
for finding in prohibitions:
obj = finding.get("object", "")
if obj:
groups[obj].append(finding)
findings = []
for obj, items in groups.items():
if len(items) < 2:
continue
findings.append(
{
"category": "repetition",
"severity": self.severity["repetition"],
"snippet": " | ".join(item["snippet"] for item in items),
"phrase": obj,
"count": len(items),
"explanation": f'Dasselbe Verbotsobjekt „{obj}“ erscheint {len(items)} Mal.',
"recommendation": "Zu einer einzigen, möglichst bedingten Regel zusammenführen.",
"start": min(item["start"] for item in items),
"end": max(item["end"] for item in items),
}
)
return findings
def _finde_widersprueche(self, text: str) -> list[dict]:
findings = []
for left_pattern, right_pattern, explanation, recommendation in self.contradiction_pairs:
left = left_pattern.search(text)
right = right_pattern.search(text)
if not left or not right:
continue
findings.append(
{
"category": "contradiction",
"severity": self.severity["contradiction"],
"snippet": f'„{left.group(0)}“ vs. „{right.group(0)}“',
"explanation": explanation,
"recommendation": recommendation,
"start": min(left.start(), right.start()),
"end": max(left.end(), right.end()),
}
)
return findings
def analysiere(self, prompt_text: str) -> dict:
outdated = self._finde_veraltete_muster(prompt_text) if self.enable_outdated else []
prohibitions = self._finde_verbote(prompt_text) if self.enable_forbidden else []
# Eine modellbezogene Altlast wird nicht zusätzlich als allgemeines Verbot gezählt.
prohibitions = [
finding
for finding in prohibitions
if not any(self._overlaps(finding, old) for old in outdated)
]
findings = [*outdated, *prohibitions]
if self.enable_repetitions:
findings.extend(self._finde_wiederholungen(prohibitions))
findings.extend(self._finde_widersprueche(prompt_text))
findings.sort(key=lambda item: (item["start"], item["end"], item["category"]))
counts = Counter(finding["category"] for finding in findings)
return {
"total_findings": len(findings),
"counts": dict(sorted(counts.items())),
"findings": findings,
"limitations": (
"Heuristische Prüfung: Treffer sind Kandidaten, keine automatische "
"Löschentscheidung. Sicherheits- und Produktregeln müssen fachlich geprüft werden."
),
}
def formatiere_bericht_text(self, report: dict) -> str:
if report["total_findings"] == 0:
return "Keine Prompt-Schulden gefunden."
category_names = {
"outdated": "Veraltete Muster",
"forbidden": "Potenziell überflüssige Verbote",
"repetition": "Wiederholte Anforderungen",
"contradiction": "Widersprüchliche Anweisungen",
}
order = ("outdated", "forbidden", "repetition", "contradiction")
grouped: defaultdict[str, list[dict]] = defaultdict(list)
for finding in report["findings"]:
grouped[finding["category"]].append(finding)
lines = [f"Potenzielle Probleme gefunden: {report['total_findings']}", ""]
for category in order:
if not grouped[category]:
continue
lines.append(category_names[category] + ":")
for finding in grouped[category]:
lines.extend(
[
f"- Fragment: {finding['snippet']}",
f" Warum: {finding['explanation']}",
f" Empfehlung: {finding['recommendation']}",
f" Schweregrad: {finding['severity']}",
]
)
lines.append("")
lines.append("Hinweis: " + report["limitations"])
return "\n".join(lines)
@staticmethod
def formatiere_bericht_json(report: dict) -> str:
return json.dumps(report, ensure_ascii=False, indent=2)
def _looks_like_path(value: str) -> bool:
path = Path(value)
return (
value.startswith(("/", "./", "../", "~"))
or path.suffix.casefold() in {".txt", ".md", ".prompt", ".json", ".yaml", ".yml"}
)
def _read_input(value: str) -> str:
path = Path(value).expanduser()
if path.is_file():
return path.read_text(encoding="utf-8")
if _looks_like_path(value):
raise FileNotFoundError(value)
return value
def build_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description="Prompt-Schulden heuristisch erkennen")
source = parser.add_mutually_exclusive_group(required=True)
source.add_argument("input", nargs="?", help="Prompt-Text oder Pfad zu einer Textdatei")
source.add_argument("--stdin", action="store_true", help="Prompt aus stdin lesen")
parser.add_argument("--json", action="store_true", help="Ausgabe im JSON-Format")
parser.add_argument("--no-outdated", action="store_true", help="Veraltete Muster nicht prüfen")
parser.add_argument("--no-forbidden", action="store_true", help="Verbote nicht prüfen")
parser.add_argument("--no-repetitions", action="store_true", help="Wiederholungen nicht prüfen")
return parser
def main(argv: list[str] | None = None) -> int:
args = build_parser().parse_args(argv)
try:
prompt_text = sys.stdin.read() if args.stdin else _read_input(args.input)
except (FileNotFoundError, OSError) as error:
print(f"Datei nicht gefunden: {error}", file=sys.stderr)
return 2
detector = PromptSchuldenDetektor(
enable_outdated=not args.no_outdated,
enable_forbidden=not args.no_forbidden,
enable_repetitions=not args.no_repetitions,
)
report = detector.analysiere(prompt_text)
if args.json:
print(detector.formatiere_bericht_json(report))
else:
print(detector.formatiere_bericht_text(report))
return 0
if __name__ == "__main__":
raise SystemExit(main())Meta-Prompt für die semantische Prüfung
Reguläre Ausdrücke erkennen klare Formulierungen, aber keine sinngleichen Wiederholungen über mehrere Absätze. Dafür eignet sich der zweite Teil: ein Sprachmodell schlägt Prüfkandidaten und Vergleichstests vor. Auch hier bleibt die Entscheidung beim Menschen.
Du prüfst bestehende Prompts auf mögliche Prompt-Schulden. Analysiere den Text zwischen <PROMPT> und </PROMPT>. Ändere ihn noch nicht.
Prüfe fünf Kategorien:
1. Überflüssiges oder zu absolutes Verbot: Eine Formulierung mit „nicht“, „nie“, „vermeide“ oder ähnlichen Wörtern, die sinnvolle Ausnahmen blockieren kann.
2. Veraltetes Muster: Eine Anweisung beschreibt die Natur des Modells oder repariert erkennbar das Verhalten einer früheren Modellgeneration.
3. Wiederholung: Dieselbe Absicht steht mehrfach im Prompt, auch mit anderer Wortwahl.
4. Widerspruch: Zwei Anweisungen können nicht gleichzeitig oder nicht im selben Kontext erfüllt werden.
5. Unklarer Zweck: Der Text zeigt nicht, welches Ergebnis oder welches Risiko die Anweisung steuern soll.
Gib für jeden Treffer aus:
- Typ
- exaktes Fragment aus dem Prompt
- mögliche Begründung für die ursprüngliche Regel
- heutiges Risiko der Regel
- Empfehlung: behalten, testen, zusammenführen oder bedingt formulieren
- Schweregrad: info, warning oder critical
- Sicherheit deiner Einschätzung: niedrig, mittel oder hoch
Regeln für die Analyse:
- Behandle jeden Treffer als Prüfkandidaten, nicht als automatische Löschentscheidung.
- Sicherheitsregeln, Zugriffsgrenzen, rechtliche Vorgaben und verbindliche Produktanforderungen bleiben erhalten, solange ihr Zweck nicht widerlegt ist.
- Behaupte nicht, eine Regel sei im Basisverhalten des Modells enthalten, wenn du dafür nur Vermutungen hast. Empfehle dann einen Vergleichstest.
- Wenn der ursprüngliche Zweck nicht aus dem Text hervorgeht, schreibe „unklar“.
- Zitiere Fragmente exakt. Erfinde keine Anweisungen hinzu.
- Gib noch keine überarbeitete Gesamtfassung aus.
Schließe mit zwei Listen:
1. „Entscheidung durch den Menschen“: alle Stellen, bei denen Kontext oder Risikowissen fehlt.
2. „Vorgeschlagene Vergleichstests“: kleine Aufgaben, mit denen sich die Wirkung der verdächtigen Regeln mit und ohne Anweisung prüfen lässt.
Wenn du keine Kandidaten findest, schreibe: „Keine Prompt-Schulden gefunden.“
<PROMPT>
[HIER DEN ZU ANALYSIERENDEN PROMPT EINFÜGEN]
</PROMPT>Führen Sie zuerst die Analyse aus. Entscheiden Sie anschließend, welche Kandidaten tatsächlich getestet werden. Eine gekürzte Fassung entsteht erst nach dieser Auswahl und muss gegen typische Aufgaben antreten.
Für den laufenden Betrieb helfen drei einfache Methoden.
Die erste ist der „saubere Durchlauf“, den ich bereits im Text über Fable 5 empfohlen habe. Wenn ein neues Modell erscheint, deaktivieren Sie den Benutzer-Prompt, das chatübergreifende Memory und alle Skills. Führen Sie anschließend einige Ihrer einfachen Standardaufgaben von Grund auf mit dem Modell aus. So erkennen Sie die „rohen“ Fähigkeiten des Modells. Danach schalten Sie alles wieder ein und vergleichen schnell, ob sich die Qualität bei denselben Aufgaben verändert hat. Ist sie gesunken, steht Refactoring an.
Die zweite Methode ist ein Prompt, den ich seit mehr als einem Jahr nutze, um meine Prompts, Skills und andere Elemente zu verbessern:
Lies [Prompt / Skill / CLAUDE.md]. Was ist darin gut umgesetzt? Was fehlt für die Arbeit? Was schränkt dich bei der Arbeit ein? Gibt es Anweisungen, die einander widersprechen? Führe alle Vorschläge als Liste auf. Ich entscheide, was verbessert wird.
Dieser Prompt ersetzt kein Refactoring. Er lässt Sie die Aufgabe jedoch mit den „Augen“ des Modells betrachten: Was gefällt ihm, was nicht und was würde es gern verbessern? Übernehmen Sie nicht alle Änderungen automatisch. Wählen Sie nur die besten Vorschläge aus der Liste aus.
Die dritte Methode richtet sich an Nutzer von Claude Code: Der Befehl /doctor kann seit Juli ungenutzte Skills und Plugins finden, deren Kontextkosten anzeigen und vorschlagen, was Sie aus CLAUDE.md entfernen sollten. Ein leistungsfähiges Werkzeug, das viele nicht kennen.
Fazit: Prompt-Schulden werden gemessen, nicht vermutet
Ein moderner Prompt muss kein kurzes Dokument sein. Er muss wirksame Informationen enthalten und überlebte Regeln loswerden. Behalten Sie Kontext, Invarianten und Sicherheitsgrenzen; streichen Sie trainierte Selbstverständlichkeiten, Wiederholungen und ungemessene Verbote. Ob die gekürzte Fassung besser ist, entscheidet der Vergleich an Ihren typischen Aufgaben.
Häufige Fragen zu Prompt-Schulden
Was sind Prompt-Schulden?
Prompt-Schulden sind dauerhafte Anweisungen, die für ein früheres Modell, einen früheren Fehler oder einen anderen Arbeitskontext geschrieben wurden. Auf einem neuen Modell können sie überflüssig werden, Konflikte erzeugen oder zusätzliche Arbeit bestellen.
Woran erkenne ich Prompt-Schulden?
Typische Signale sind wiederholte Regeln, lange Verbotslisten, absolute Wörter wie „immer“ und „nie“, Beispiele ohne messbaren Nutzen sowie Anweisungen, die eine aktuelle Modellversion ohnehin zuverlässig befolgt.
Welche Regeln darf ich nicht löschen?
Behalten Sie Sicherheits- und Zugriffsgrenzen, persönliche Fakten, verbindliche Produktanforderungen und Kontext, den das Modell nicht selbst kennen kann. Diese Informationen sind Invarianten, kein Ballast.
Sind lange Prompts grundsätzlich schlecht?
Nein. Länge allein ist kein ausreichendes Kriterium. Ein langer Prompt kann nötig sein, wenn er echten Kontext oder verbindliche Anforderungen enthält. Problematisch sind Widersprüche, Wiederholungen und Anweisungen ohne gemessenen Nutzen.
Wie prüfe ich eine gekürzte Fassung?
Führen Sie zwei oder drei typische Aufgaben einmal mit der alten und einmal mit der gekürzten Fassung aus. Vergleichen Sie Ergebnisqualität, Regelverstöße, Tokens, Laufzeit und Kosten. Verschlechtert sich ein relevantes Ergebnis, nehmen Sie die wirksame Anweisung wieder auf.
Quellen und Stand
Stand der Quellenprüfung: 14. August 2026.
- Drew Breunig: The Problem is Prompt Debt, 22. Juni 2026
- Simon Willison: Cat Wu and Thariq Shihipar on Claude Code, 21. Juli 2026
- OpenAI: Model guidance for GPT-5.6, abgerufen am 14. August 2026
- Surge AI: HANDBOOK.md, arXiv:2607.25398
- Tingxu Han et al.: SWE-Skills-Bench, arXiv:2603.15401
- Every: The Case Against Skills, 16. Juli 2026
- Datadog: State of AI Engineering, abgerufen am 14. August 2026