Angenommen, ein Entwicklungsteam lässt einen KI-Agenten über Nacht einen Importdienst für Lieferantendaten schreiben. Am Morgen liegen zwei Fassungen vor, eine in Python, eine in Rust. Die Python-Fassung startet sofort und sieht gut aus. Ob sie bei einer leeren Preisspalte abstürzt, zeigt sich erst, wenn die erste fehlerhafte Datei kommt. Die Rust-Fassung hat den Agenten in der Nacht Dutzende Anläufe gekostet, weil der Compiler jeden unbehandelten Sonderfall abgelehnt hat. Dafür sind viele dieser Fehler schon beseitigt, bevor ein Mensch den Code liest.

Diese Verschiebung beschäftigt Entwicklungsteams seit 2025 zunehmend. Jahrelang galt die Faustregel, dass man im Zweifel Python oder TypeScript nimmt, weil Menschen damit schneller zu Ergebnissen kommen. Wenn ein Großteil des Codes von Maschinen kommt, verliert dieses Argument an Gewicht. Wichtiger wird, wie zuverlässig eine Sprache die Fehler der Maschine sichtbar macht.

Die alte Rechnung: Schreibtempo schlägt Laufzeit

Die Wahl der Programmiersprache war lange eine Abwägung zwischen zwei Arten von Geschwindigkeit. Python und TypeScript erlauben es, eine Idee in wenigen Tagen in eine lauffähige Anwendung zu verwandeln. Dazu kommen riesige Paketsammlungen und ein großer Arbeitsmarkt. Rust, Go oder C++ liefern dagegen schnellere und sparsamere Programme, verlangen aber mehr Einarbeitung und mehr Sorgfalt beim Schreiben.

Für die meisten Unternehmen fiel die Entscheidung deshalb auf die bequemere Seite. Die Rechenzeit war billiger als die Arbeitszeit der Entwickler:innen, und die Optimierung wurde auf „später“ verschoben. Die Rechnung ging auf, solange Menschen jede Zeile selbst schrieben und die schwierigen Sprachen vor allem Lernaufwand bedeuteten.

Mit Coding-Agenten wie Claude Code, OpenAI Codex oder GitHub Copilot im Agentenmodus ändern sich die Kosten auf der einen Seite der Waage. Ein Agent ist ein Sprachmodell, das nicht nur Vorschläge macht, sondern selbstständig Dateien ändert, Befehle ausführt und auf die Ergebnisse reagiert. Für ihn ist eine strenge Sprache kein Lernproblem. Er braucht vor allem klare Rückmeldungen, ob sein Code stimmt.

Der Compiler als unbestechlicher Prüfer

Ein Compiler übersetzt Quelltext in ausführbaren Maschinencode und prüft dabei, ob das Programm den Regeln der Sprache genügt. In Rust sind diese Regeln besonders streng. Das liegt an zwei Konzepten. Beim Ownership hat jeder Wert genau einen Besitzer, und der Speicher wird freigegeben, sobald dieser Besitzer nicht mehr gebraucht wird. Der Borrow Checker, ein Teil des Compilers, überwacht, wer einen Wert wann ausleihen und verändern darf. So schließt Rust ganze Fehlerklassen aus, etwa den Zugriff auf bereits freigegebenen Speicher oder gleichzeitige Schreibzugriffe aus mehreren Threads.

Für einen KI-Agenten ist das ein Vorteil. Jede abgelehnte Übersetzung liefert eine präzise Meldung mit Fehlercode, Zeilennummer und oft einem Korrekturvorschlag. Der Agent liest die Meldung, ändert den Code und versucht es erneut. Diese Schleife aus Schreiben, Prüfen und Nachbessern läuft in Sekunden und ohne menschliches Zutun.

Ein einfaches Beispiel zeigt, welche Art von Fehler dabei auffällt:

fn main() {
    let bestellungen = vec![String::from("A-1001"), String::from("A-1002")];

    // Der Besitz an der Liste wandert hier zu `archiv`.
    let archiv = bestellungen;

    // Fehler E0382: `bestellungen` wurde bereits verschoben.
    println!("{} Bestellungen", bestellungen.len());
    println!("{} im Archiv", archiv.len());
}

Der Compiler verweigert die Übersetzung und schlägt vor, die Liste entweder zu kopieren oder nur auszuleihen. In C++ ließe sich ein vergleichbarer Fehler übersetzen und würde womöglich erst im Betrieb auffallen.

Typen, die Sonderfälle erzwingen

Der zweite Baustein ist das Typsystem. Rust kennt keinen Nullwert, der unbemerkt durch das Programm wandert. Ein möglicherweise fehlender Wert hat den Typ Option, ein Ergebnis, das scheitern kann, den Typ Result. Wer einen solchen Wert verwenden will, muss beide Fälle behandeln. Ähnlich verhält es sich bei Aufzählungstypen:

enum Zahlungsstatus {
    Offen,
    Bezahlt,
    Storniert,
}

fn anzeigen(status: Zahlungsstatus) -> &'static str {
    // Fehlt hier ein Fall, meldet der Compiler Fehler E0004.
    match status {
        Zahlungsstatus::Offen => "Zahlung ausstehend",
        Zahlungsstatus::Bezahlt => "Bezahlt",
        Zahlungsstatus::Storniert => "Storniert",
    }
}

Kommt später ein vierter Status hinzu, etwa eine Teilzahlung, zeigt der Compiler jede Stelle im Projekt, an der dieser Fall noch fehlt. Für einen Agenten, der eine Änderung durch eine große Codebasis ziehen soll, ist das eine Checkliste, die er nicht vergessen kann.

Warum dynamische Sprachen weniger zurückmelden

In Python übersetzt kein Compiler den Code vorab. Fehler wie ein Tippfehler in einem Attributnamen oder ein vergessener Sonderfall zeigen sich erst, wenn genau diese Zeile ausgeführt wird. Typannotationen mit Prüfwerkzeugen wie mypy oder Pyright und eine gute Testabdeckung schließen einen Teil dieser Lücke. Sie sind aber freiwillig, und ein Agent kann sie genauso umgehen, wie es Menschen unter Zeitdruck tun. TypeScript liegt dazwischen: Sein Typsystem fängt viele Fehler ab, lässt sich mit any aber jederzeit aushebeln.

Was Go und Rust gemeinsam haben

Rust ist nicht die einzige Sprache, die von diesem Effekt profitiert. Auch Go ist statisch typisiert und kompiliert sehr schnell. Seine Regeln sind weniger streng als die von Rust, dafür ist die Sprache bewusst klein gehalten. Go-Code sieht in fast jedem Projekt ähnlich aus, ein einheitliches Formatierungswerkzeug gehört zum Standard. Das erleichtert Menschen das Lesen von Code, den ein Agent geschrieben hat.

Ein viel beachtetes Beispiel für die Stärke von Go kam von Microsoft. Im März 2025 kündigte das TypeScript-Team an, den Compiler von TypeScript nach Go zu portieren. Die neue Fassung ist seit Juli 2026 als TypeScript 7 verfügbar und prüft Projekte laut Microsoft etwa zehnmal schneller. Die Wahl fiel ausdrücklich nicht auf Rust: Go ließ sich der bestehenden Struktur des Compilers näher nachbilden, was die Portierung erleichterte. Das Projekt ist kein KI-Experiment, zeigt aber, dass selbst große Werkzeuge der Webwelt den Sprachwechsel wagen, wenn die Leistung zählt.

Was Agenten in Rust bereits gebaut haben

Seit Anfang 2026 machen mehrere Projekte die Runde, in denen KI-Agenten große Mengen an Rust-Code geschrieben haben. Sie sind keine repräsentativen Studien, zeigen aber, was unter guten Bedingungen möglich ist.

• Ein C-Compiler von 16 Agenten: Der Anthropic-Forscher Nicholas Carlini ließ nach eigenen Angaben 16 parallel arbeitende Claude-Instanzen einen C-Compiler in Rust schreiben. Das Ergebnis umfasste rund 100.000 Zeilen und konnte laut dem Bericht den Linux-Kernel für mehrere Prozessorarchitekturen übersetzen. Die Kosten gab Carlini mit knapp 20.000 US-Dollar an. Er beschrieb auch Grenzen, etwa dass der erzeugte Maschinencode weniger effizient ist als der etablierter Compiler.
• Portierungen bestehender Software: Andreas Kling, Gründer des Browserprojekts Ladybird, berichtete 2026, Teile der JavaScript-Engine mithilfe von Agenten von C++ nach Rust übertragen zu haben, abgesichert durch die vorhandene Testsuite. Armin Ronacher, bekannt als Autor des Python-Frameworks Flask, übertrug seine Rust-Bibliothek MiniJinja mit einem Agenten nach Go und nannte dafür einen Aufwand von unter einer Stunde eigener Arbeitszeit.
• Neue Sprachen: Steve Klabnik, Mitautor des offiziellen Rust-Buchs, entwarf mit Unterstützung von Claude eine eigene Systemsprache namens Rue, deren Compiler zum größten Teil von Claude geschrieben wird.

Allen Fällen ist eines gemeinsam: Es gab ein klares Prüfkriterium. Eine umfangreiche Testsuite, eine bestehende Referenzimplementierung oder einen Compiler, der falschen Code ablehnt. Genau diese Prüfkriterien machen den Unterschied. Wo sie fehlen, liefern Agenten in jeder Sprache plausibel aussehenden, aber fehlerhaften Code.

Python ist längst zum Teil Rust

Das stärkste Argument für Python war nie die Sprache allein, sondern das Ökosystem. Doch unter der Oberfläche vieler Python-Bibliotheken arbeitet inzwischen Rust. Der Validierungskern von Pydantic ist in Rust geschrieben, ebenso die Datenrahmen-Bibliothek Polars, die Tokenizer von Hugging Face und der JSON-Parser orjson. Auch die Werkzeuge ändern sich: Die Firma Astral entwickelte mit ruff einen Linter und mit uv einen Paketmanager für Python, beide in Rust und deutlich schneller als ihre Vorgänger.

Die großen KI-Anbieter haben solche Werkzeuge als Infrastruktur für ihre eigenen Agenten entdeckt. Im Dezember 2025 übernahm Anthropic die JavaScript-Laufzeitumgebung Bun, im März 2026 kündigte OpenAI die Übernahme von Astral an. Für Python-Teams ist das zunächst eine gute Nachricht, denn Python bleibt die Oberfläche, über die sie mit diesen Bibliotheken arbeiten. Es zeigt aber, wohin die rechenintensive Arbeit wandert.

Wo das Argument an seine Grenzen stößt

Die These, dass Agenten die schwierigen Sprachen einfach machen, hat Schwachstellen. Sie verdient deshalb eine nüchterne Prüfung.

Der Compiler prüft Regeln, nicht Absichten. Ein Rust-Programm kann speichersicher sein und trotzdem die falsche Umsatzsteuer berechnen. Fachliche Fehler fängt nur ein Test oder ein Mensch, der die Anforderung kennt. Wer sich allein auf den Compiler verlässt, verschiebt das Risiko nur.

Trainingsdaten entscheiden mit. Sprachmodelle schreiben Code am besten in Sprachen, von denen sie viele Beispiele gesehen haben. Eine strenge Sprache allein reicht also nicht.

Nicht jede Umgebung belohnt native Programme. Der Datenbankzugriffsbaukasten Prisma ging 2025 den umgekehrten Weg und ersetzte seine Rust-Query-Engine durch eine Umsetzung in TypeScript. Laut Hersteller wurden die Pakete dadurch deutlich kleiner und viele Abfragen schneller, vor allem in Serverless-Umgebungen. Native Binärdateien sind dort oft sperrig.

Das Team muss den Code verstehen. Ein Agent kann eine Rust-Anwendung schreiben, betreiben muss sie das Team. Wenn nachts ein Fehler auftritt, hilft der beste Compiler nichts, wenn niemand im Haus die Sprache lesen kann. Hinzu kommt die Lieferkette: Agenten binden gern zusätzliche Pakete ein, und auch crates.io, das Paketverzeichnis von Rust, war bereits Ziel von Angriffen. Mehr dazu steht in unserem Beitrag über Angriffe auf die Lieferkette von Rust.

Python bleibt in der KI-Forschung gesetzt. Modelle werden weiterhin überwiegend in PyTorch entwickelt. Welche Sprache in welcher Phase von KI-Projekten sinnvoll ist, beschreibt unser Vergleich der Programmiersprachen für generative KI.

Was das für Ihr Team bedeutet

Die Sprachwahl wird durch KI nicht beliebig, sie verschiebt sich. Für neue Komponenten, bei denen Leistung, Speicherbedarf oder Sicherheit zählen, etwa einen Parser für Maschinendaten, einen Dienst mit vielen gleichzeitigen Anfragen oder ein Kommandozeilenwerkzeug, lohnt sich heute ein ernsthafter Blick auf Rust oder Go. Die Einstiegshürde ist mit einem Agenten an der Seite niedriger als noch vor wenigen Jahren.

Überschätzt wird dagegen die Idee, bestehende Python- oder TypeScript-Anwendungen jetzt umfassend neu zu schreiben. Eine Portierung lohnt sich nur, wenn es ein messbares Problem gibt und eine Testsuite, die das alte Verhalten absichert. Ohne Tests ist ein von Agenten portiertes System ein Neubau mit unbekannten Fehlern.

Unsere Empfehlung: Beginnen Sie mit einem abgegrenzten Baustein und klaren Prüfkriterien. Lassen Sie den Agenten in Rust oder Go arbeiten, und achten Sie darauf, dass mindestens zwei Personen im Team den Code lesen und warten können. Wie Python, Go und Rust in einem Projekt zusammenspielen, zeigt unser Beitrag Warum Python, Go und Rust die Softwareentwicklung prägen.

Wer Rust im Unternehmen einführen möchte, findet auf unserer Seite zur Softwareentwicklung mit Rust Beratung und Seminare. Für den Einsatz von Coding-Assistenten im Team gibt es außerdem Angebote zu GitHub Copilot.

Häufige Fragen zu Rust und KI-gestützter Entwicklung

Sollten Einsteiger jetzt direkt mit Rust statt mit Python anfangen?

Für die meisten Einsteiger nicht. Python ist nachsichtig, gut dokumentiert und eignet sich, um Grundbegriffe wie Variablen, Schleifen, Funktionen und Datenstrukturen zu lernen. Wer diese Konzepte verstanden hat, kann mithilfe eines KI-Assistenten auch Rust angehen. Wichtig ist dabei, die Fehlermeldungen des Compilers selbst zu lesen, statt sie nur an den Assistenten weiterzureichen.

Wird Python an Bedeutung verlieren?

In Datenanalyse, maschinellem Lernen und Automatisierung bleibt Python tief verankert. Verschieben dürfte sich, wofür Python eingesetzt wird: stärker als Bindeglied zwischen Bibliotheken, die selbst in Rust oder C++ geschrieben sind, und weniger für rechenintensive Dienste oder Werkzeuge.

Schreibt eine KI in Rust fehlerfreien Code?

Nein. Der Compiler verhindert bestimmte Fehlerklassen, vor allem Speicherfehler und unbehandelte Sonderfälle. Logikfehler, falsch verstandene Anforderungen oder unsichere Abhängigkeiten erkennt er nicht. Tests, Code-Reviews und eine Prüfung neuer Pakete bleiben auch bei generiertem Rust-Code Pflicht.

Funktioniert der Effekt auch mit TypeScript?

Teilweise. TypeScript gibt einem Agenten über den Typprüfer ebenfalls schnelle Rückmeldungen, vor allem in Projekten mit strikter Konfiguration. Weil sich die Typen aber mit any oder Typumwandlungen umgehen lassen, ist die Prüfung weniger verbindlich als in Rust. Eine strikte Konfiguration und ein Linter, der solche Umgehungen meldet, holen einen Teil des Abstands auf.