Ein Tag, eine Milliarde Token? Die AI-Rechnung der Programmierer bestraft die "Faulen"

Zielgruppe: Entwickler, die AI-Programmierungstools (wie Cursor, Windsurf, trae...) nutzen, sowie technische Manager, denen das Bewusstsein für AI-Kosten fehlt.

Kernaussage: Token sind nicht nur einfache Abrechnungseinheiten, sondern eine "Aufmerksamkeitsressource" und "Rechenleistungswährung". Der Missbrauch des Agent-Modus und die Vernachlässigung des Kontextmanagements verdecken strategische Faulheit (selbst nicht nachdenken) mit taktischem Fleiß (die AI herumprobieren lassen).

Ihre "AI-Ausgaben" könnten höher sein als Ihr Gehalt

Vor ein paar Tagen habe ich meine Token-Abrechnung überprüft. Als ich die Zahl sah, war ich etwas überrascht: 10 Millionen Token. Achtung, das ist nicht der Verbrauch eines Monats, sondern eines Tages.

Ich dachte, das sei extrem. Dann postete ich ein kurzes Video zur Token-Berechnung.

Die Kommentare zeigten mir, was "die Welt da draußen" bedeutet.

Das folgende Bild ist ein Screenshot des Token-Verbrauchs von Nutzer "老K的日常" mit 200 Millionen Token an einem Tag:

Zuerst dachte ich, es sei ein Einzelfall, aber als viele Nutzer schrieben, sie verbrauchten täglich 100 Millionen, wurde mir klar: Das ist ein weit verbreitetes Phänomen.

Was bedeutet eine Milliarde Token? Geht man von der üblichen Abrechnungsgröße "einiger gängiger Geschäftsmodelle" aus (Eingabe/Ausgabe getrennt berechnet, grob geschätzt als 10 US-Dollar / Million Token), dann werden an einem Tag 1000 Dollar verbrannt. 7000 Renminbi pro Tag. Das Monatsgehalt vieler Junior-Programmierer reicht möglicherweise nicht einmal aus, um die AI einen Tag lang "denken" zu lassen.

(Anmerkung: Die Preise variieren stark je nach Modell/Anbieter, und die Kosten für Eingabe und Ausgabe sind oft unterschiedlich. Hier geht es nicht um eine Berechnung auf zwei Dezimalstellen genau, sondern darum, ein Gefühl für die "Größenordnung" zu vermitteln.)

Wenn Sie es selbst nachrechnen möchten, gibt es im Allgemeinen diese eine Formel (Sonderregeln wie Caching/Rabatte werden ignoriert): Kosten ≈ (Eingabe-Token / 1.000.000) × Preis_in + (Ausgabe-Token / 1.000.000) × Preis_out

Das ist so kontraintuitiv. Wir denken immer, AI sei billig, OpenAI will sogar die Preise senken. Aber warum explodiert der Token-Verbrauch in der praktischen Anwendung exponentiell?

Heute nehmen wir diese "Token-Schwarze-Loch"-Logik genau unter die Lupe und sehen, wie wir den Schaden begrenzen können.

1. Warum explodieren Token "exponentiell"?

Viele Kollegen haben überhaupt kein Gefühl für das Volumen von Token. Sie denken: "Ach, es sind nur ein paar Codezeilen. Wie viel kann das schon sein?"

1. Eine klare Rechnung aufmachen

Zuerst schaffen wir ein quantitatives Gefühl, das für die Praxis ausreicht. Um es klar zu sagen: Token sind keine Wörter und keine Zeichen. Es sind "Codierungssegmente", in die der Modell-Text aufgeteilt wird. Verschiedene Modelle verwenden unterschiedliche Tokenizer, daher kann man nur Bereiche angeben, keine "allgemeingültigen Konstanten".

Die folgenden Zahlen dienen als "Schätzmaßstab" (Ziel: Größenordnung beurteilen, Kosten abschätzen, Schadensbegrenzungsentscheidungen treffen):

• 1 chinesisches Schriftzeichen: typischerweise 1–2 Token (häufige Zeichen näher an 1, seltene Zeichen/Kombinationen eher 2–3)
• 1 englisches Wort: typischerweise etwa 1,2–1,5 Token (zur groben Schätzung kann auch 1,3 verwendet werden)
• 1 Codezeile ≈ 10–50 Token (inkl. Einrückungen, Kommentare, Typdeklarationen)
  • Einfache Geschäftslogik ≈ 12–20 Token
  • Mit Typannotationen, Interface, JSDoc, 4-Leerzeichen-Einrückung ≈ 20–35 Token
  • Mit vielen Imports / Dekoratoren / Kommentaren ≈ 30–50+ Token
• 1 Quelldatei (400–600 Zeilen, modernes TS/Java-Projekt) ≈ 4.000–24.000 Token sind üblich (Median ≈ 12.000–18.000)
• 1 mittleres Projekt (100–200 Quelldateien, nur src/, ohne node_modules/ / generierten Code)
  • Das "Durchlesen" des Kerncodes beginnt oft bei einer Million Token
  • Wenn Tests, Konfigurationen, Skripte, Abhängigkeitsdeklarationen, Logs hinzukommen, sind auch mehrere Millionen Token nicht ungewöhnlich

Moderne Frontend-Projekte sind in TypeScript, voller komplexer Interface-Definitionen; oder in Java, mit oft dutzenden Import-Zeilen. Diese "Boilerplate-Codes" sind echte Token-Killer. Bei einem mittleren Projekt mit 100 Dateien kann das reine "Durchlesen" des Codes durch die AI leicht 1 Million Token verbrauchen.

2. Der "Schneeball"-Effekt von Token

Das Schlimmste am Token-Verbrauch ist nicht der Einzeldialog, sondern die Kontextakkumulation über mehrere Dialogrunden.

LLMs sind zustandslos. Damit sich die AI an das erinnert, was Sie zuletzt gesagt haben, packt das System normalerweise "System-Prompt + Dialogverlauf + von Ihnen referenzierte Dateien/Code-Snippets + Tool-Aufrufausgaben (z.B. Suchergebnisse, Fehlerlogs)" zusammen und sendet sie an das Modell. Sie denken, Sie haben nur eine Frage gestellt, aber Sie bezahlen wiederholt für das "gesamte Kontextpaket".

• Runde 1: 10.000 Token gesendet, AI antwortet mit 1.000.
• Runde 2: (10.000 + 1.000 + neue Frage) gesendet, AI antwortet...
• Runde 10: Ihr Kontext ist möglicherweise auf 200.000 Token angewachsen.

Selbst wenn Sie dann nur fragen "Hilf mir, einen Variablennamen zu ändern", kostet das die Gebühr für 200.000 Token. Deshalb haben Sie das Gefühl, nichts getan zu haben, aber die Rechnung schießt in die Höhe.

Noch schlimmer: Der Agent-Modus "liest Dateien aktiv". Bei einem Befehl wie "Optimier das Benutzermodul" scannt er möglicherweise zuerst das entsprechende Verzeichnis, verfolgt dann Abhängigkeiten, Konfigurationen, Tests... Er ist nicht faul, er erfüllt "pflichtbewusst die Standardstrategie", und die Standardstrategie ist oft: viel lesen, viel ausprobieren, viel iterieren.

2. Zwei Arten von "Faulheit" ruinieren Ihre Engineering-Fähigkeiten

Nach einer Analyse der Kommentare jener "Milliarden-Brüder" stellte ich fest, dass die Ursache für den Token-Anstieg nicht nur im Verbrauchsmechanismus der AI liegt, sondern auch eng mit menschlicher Faulheit zusammenhängt.

Hier sind zwei typische Arten von "Denkfaulheit".

Faulheit Eins: Der "Hands-off"-Typ

Haben Sie auch diese Einstellung:

• "Dieses alte Projekt ist zu chaotisch, ich habe keine Lust, die Logik durchzusehen, werf es einfach der AI hin."
• "Cursor hat einen Agent-Modus, super, lass ihn die Bugs selbst reparieren."

Also werfen Sie den gesamten src-Ordner dem Agenten zu und geben einen vagen Befehl: "Hilf mir, das Benutzermodul zu optimieren." Der Agent beginnt zu arbeiten:

• Er liest 50 Dateien (verbraucht 500.000).
• Er stellt fest, dass auf utils verwiesen wird, und liest die Utility-Klassen (verbraucht 200.000).
• Er versucht, Änderungen vorzunehmen, Fehler, liest Fehlerlogs (verbraucht 100.000).
• Er versucht, es zu reparieren, wieder Fehler...

Er probiert wie verrückt herum, verbraucht wie verrückt Token. Und Sie? Sie scrollen durch Ihr Handy und denken, wie effizient Sie sind. Die Wahrheit ist: Sie tauschen Geld gegen "Scheineffizienz" und produzieren Code, den Sie später nicht warten können.

Fachlicher ausgedrückt gibt es hier zwei Verluste:

• Kostenseite: Eingabe-Token werden größer, Iterationen häufiger, Kosten addieren sich linear.
• Engineering-Seite: Sie verlieren Kontext und Entscheidungsbefugnis, übrig bleibt ein unkontrollierbares System, das "nur irgendwie läuft".

Faulheit Zwei: Der "Alles-reinwerfen"-Typ

Wie werfen Sie Bugs der AI hin? Kopieren Sie einfach mit Strg+A die gesamte Fehlerkonsole oder lassen Sie die AI mit @Codebase selbst suchen?

Das nennt man "Alles reinwerfen". Sie sind zu faul, den Kern des Problems zu lokalisieren, zu faul, die entscheidenden Code-Snippets auszuwählen. Sie stopfen 99 % nutzlose Informationen (Rauschen) und 1 % nützliche Informationen (Signal) der AI in den Mund.

AI ist wie ein Verstärker.

• Geben Sie ihr klare Logik (Signal), verstärkt sie Ihre Intelligenz, verwendet wenige Token, gute Ergebnisse.
• Geben Sie ihr Chaos und Unklarheit, verstärkt sie Ihr Chaos, Token schießen in die Höhe, Output ist Müll.

3. Lösung: Wie man AI effizient nutzt und den Token-Verbrauch senkt

Um Ihre Brieftasche zu schützen, und wichtiger, um Ihre Engineering-Kontrolle zu bewahren, müssen wir die Zusammenarbeit mit der AI ändern.

1. Prinzip des minimalen Kontexts

Das ist das erste Prinzip der AI-Programmierung. Geben Sie der AI immer nur den minimalen Code-Satz, der zur Lösung des aktuellen Problems notwendig ist.

In Cursor sollten Sie diese Operatoren gut nutzen:

• @File: Referenzieren Sie nur relevante Dateien, nicht den gesamten Ordner.
• Strg+L Code auswählen: Senden Sie nur die 50 markierten Codezeilen an den Chat, nicht die gesamte Datei.
• @Docs: Für Bibliotheken von Drittanbietern referenzieren Sie die Dokumentation, anstatt sie raten zu lassen.

Hier ist eine strukturierte, wiederverwendbare SOP, die ich oft verwende (wenn Sie sich daran halten, werden die Token spürbar sinken):

Die Bedeutung dieses Absatzes ist: Bei der Zusammenarbeit mit der AI auf Effizienz und Präzision achten. Konkret:

• Zuerst Ziel klar definieren: Kurz und prägnant das aktuelle Problem und das gewünschte Ergebnis mitteilen, die AI nicht selbst raten lassen.
• Problem reproduzieren vereinfachen: Mit der einfachsten Methode reproduzieren, nur den minimalen, entscheidenden Code einfügen, keine Unmengen irrelevanter Inhalte.
• Minimal notwendige Informationen bereitstellen: Nur relevante 1–3 Dateien, Schlüsselfunktionen und die ersten Zeilen des Fehler-Stacks, keine Vollinformationen.
• Änderungspunkte zurückfordern: Die AI soll nur sagen, was geändert wird und warum, nicht den gesamten Code umfassend neu schreiben.
• Zuletzt selbst prüfen: Kurze Validierung durchführen, sicherstellen, dass Änderungen nichts anderes beeinflussen.

Kurz gesagt: Mit den wenigsten, entscheidendsten Informationen die AI arbeiten lassen und die endgültige Kontrolle und Urteilsfähigkeit behalten.

2. Das Wichtigste: Zuerst denken, dann prompten, zuerst planen, dann handeln

Bevor Sie die Eingabetaste drücken, zwingen Sie sich zu einer 10-Sekunden-Pause und fragen sich drei Dinge:

• Welches Problem löse ich? (Grenzen definieren)
• Welche Kernmodule betrifft dieses Problem? (Kontext filtern)
• Wie würde ich es selbst schreiben? (Denkansatz liefern)

Sie sind die 1, die AI die Nullen dahinter. Wenn die 1 nicht steht, sind die Nullen dahinter nur sinnloser Verbrauch.

Ein paar ehrliche Worte

Die Geschichte von "100 Millionen Token pro Tag" mag nicht jedem passieren. Aber Token-Verschwendung hat fast jeder Programmierer erlebt, der AI-Programmierung nutzt.

AI macht das Programmieren einfacher, aber es gibt immer noch Hürden. Nur wer sie wirklich zu nutzen weiß, wird wie ein Tiger mit Flügeln.

Früher nervte Ihr schlechter Code nur Kollegen. Jetzt wird Ihre Faulheit direkt zu einer Zahl auf der Rechnung und bestraft Sie mit explodierenden Kosten.

Seien Sie also kein "Hands-off"-Manager. Seien Sie ein tiefdenkender, präzise kommunizierender, erst planender dann handelnder AI-Architekt. Das ist auch unsere größte Unersetzbarkeit in dieser Zeit.