KI-Codes für 24 Stunden. Die Zukunft ist hier (und fehlerhaft).

Cole Medin wollte wissen, was passiert, wenn man KI nicht mehr als eine Autovervollständigung für den Code betrachtet, sondern als einen Junior Engineer, der nie schläft. Also setzte er Anthropics neuen Claude Code „langlaufenden Agenten-Harness“ in Gang und ließ eine KI 24 Stunden lang ohne Pausen und ohne „Ich bin fertig“-Knopf arbeiten. Das Ergebnis: ein Stresstest, der nicht den rohen IQ des Modells prüfte, sondern ob agentische Systeme in der Lage sind, ein echtes Softwareprojekt von Anfang bis Ende durchzuführen.

Statt um eine To-Do-Listen-App oder ein einzelnes Python-Skript zu bitten, setzte Medin ein brutales Ziel: einen funktionalen Webklon von claude.ai. Das bedeutet Chatverlauf, Gesprächsabläufe, Artefakte und eine responsive Benutzeroberfläche, die sich wie das echte Produkt verhält und nicht nur wie eine statische Landing Page. Der Rahmen definierte Erfolg als eine voll funktionsfähige Full-Stack-App und nicht als einen flüchtigen Codeschnipsel.

Medin hatte das Experiment von Anfang an um testgetriebene Entwicklung aufgebaut. Bevor die KI eine Zeile Code schrieb, legte er automatisierte End-to-End-Tests fest, die einen Entwicklungsserver hochfahren, einen headless Browser starten und durch die Kernabläufe klicken. Die Aufgabe desAgenten: Den Code so lange bearbeiten, bis diese Tests erfolgreich sind.

Die Open-Source-Harnes von Anthropic, die Medin von GitHub heruntergeladen hat, verbindet all dies. Ein „Initializer“-Agent legt die Spezifikationen, Aufgaben und Test-Suiten fest, anschließend bearbeitet ein dedizierter Coding-Agent wiederholt Dateien, führt Tests durch und inspiziert Fehler. Jede Sitzung verhält sich wie ein Mini-Sprint, und das Harness verbindet dutzende dieser Sprints hintereinander.

In etwa 24 Stunden durchlief das System mehr als 50 Codierungssitzungen, wobei Backend-APIs, Frontend-Komponenten und Testfixtures behandelt wurden. Die Browser-Tests fungierten als unerbittlicher Schiedsrichter: Sie bestätigten entweder, dass eine Funktion funktionierte, oder schoben den Agenten zurück in den Editor. Der Fortschritt kam in Schüben, während die KI einen fehlerhaften Ablauf behebt und dann auf einen neuen Integrationsrandfall stieß.

Am Ende bestanden etwas mehr als die Hälfte der Gesamttests, genug, um eine erkennbare Claude.ai-Oberfläche zu erzeugen, aber weit entfernt von einem pixelgenauen Klon. Der Testlauf zeigte, dass „24 Stunden KI“ nicht magisch gleichbedeutend mit „produktionsreifem SaaS“ ist, bewies jedoch auch, dass moderne Agenten nicht triviale, mehrschichtige Softwarearbeit leisten können, wenn sie Struktur, Ausdauer und klare Metriken für den Abschluss erhalten.

Die Open-Source Agenten-Hardware von Anthropic verwandelt Claude von einem gesprächigen Autocomplete in etwas, das eher einem Junior-Ingenieur ähnelt, der niemals Feierabend macht. Anstatt eines einzelnen Prompts und einem Codeblock, verbindet die Hardware Claude mit einem Gerüst, das über Stunden, sogar Tage, laufen kann, ohne dass jemand jeden Schritt überwachen muss.

Im Kern erzwingt das System einen Zyklus: planen → codieren → testen → verfeinern. Claude schlägt eine Änderung vor, bearbeitet Dateien, führt automatisierte Tests oder einen Entwicklungsserver aus, überprüft die Ergebnisse und trifft dann Entscheidungen über die nächsten Schritte. Dieser Zyklus wiederholt sich Dutzende Male, genau das, worauf Cole Medin setzt, wenn er Claude bittet, einen Klon von claude.ai 24 Stunden lang zu verfolgen.

Einmalige Eingaben liefern Ihnen eine Antwort basierend auf einem statischen Momentaufnahme des Kontexts. Eine langfristige, zustandsbehaftete Sitzung sammelt kontinuierlich Projekthistorie: fehlgeschlagene Tests, frühere Diffs, architektonische Entscheidungen und sogar TODO-Kommentare. Über 50+ Codierungssitzungen hinweg kann der Agent frühere Entscheidungen refaktorisieren, Rückschritte entwirren und mehrstufige Strategien verfolgen, die in einem einzigen Antwortfenster unmöglich wären.

Die Gestaltung von Anthropic unterteilt dies in verschiedene Rollen. Ein Initialisierer-Agent läuft zuerst und liest das Repository, die Spezifikationen und vordefinierten Tests, um anschließend einen groben Plan zu entwerfen: Tech-Stack, Verzeichnisstruktur, Meilensteine und welche Tests „erledigt“ definieren. Er kann sogar Testsuiten generieren oder verfeinern, sodass das System eine objektive Bewertungsgrundlage hat, bevor ernsthafter Code geschrieben wird.

Sobald der Initialisierer die Bühne vorbereitet hat, übernimmt ein dedizierter Coding-Agent. Dieser Agent durchläuft konkrete Aufgaben: Er erstellt React-Komponenten, verbindet API-Routen, passt Datenbankschemas an oder behebt einen bestimmten fehlgeschlagenen Playwright-Test. Jeder Durchlauf nutzt die von der Umgebung bereitgestellten Werkzeuge—Dateibearbefehle, Testlaufwerke, Headless-Browser-Überprüfungen—um Änderungen vorzunehmen und zu verifizieren.

Da das Harness den Zustand auf die Festplatte speichert und in die Eingaben zurückführt, kann Claude über die Migrationen von gestern oder den einen anfälligen UI-Test, der ständig fehlschlägt, nachdenken. Medins 24-Stunden-Lauf zeigt das Ergebnis: Das Harness generiert nicht nur Code, es orchestriert eine laufende Verhandlung zwischen Plan und Realität, gemessen an bestandenen Tests statt an hübschen Demos.

Ihre Tests, nicht Ihre Aufforderungen, haben dieses 24-Stunden-Stunt wirklich vorangetrieben. Cole Medin behandelte testgetriebene Entwicklung (TDD) als das Lenkrad: Definieren Sie, was „fertig“ im Code bedeutet, und lassen Sie Claude Code arbeiten, bis die Realität mit den Spezifikationen übereinstimmt. Keine Stimmung, kein „sieht gut aus für mich“, nur rot oder grün.

Bevor der Agent eine einzige Zeile UI schrieb, rüstete Cole ein vollständiges Test-Setup aus, das die zentralen Abläufe von claude.ai erfasste. Das Test-Setup wusste um die Erstellung von Konversationen, den Nachrichtenverlauf und Artefakte als explizite Anforderungen, nicht als vage Ziele. Erfolg bedeutete, dass diese Tests bestanden wurden, oder der Agent weiterarbeitete.

Dieses Testset diente als Vertrag zwischen Mensch und Agent. Anstatt jedes einzelne Element genau zu steuern, sagte Cole einfach: Hier sind die Verhaltensweisen, hier sind die Behauptungen, erfülle sie. Die Autonomie des Agents lebte vollständig innerhalb dieses Vertrags, wobei das System dies von Lauf zu Lauf durchsetzte.

Der Fortschritt hörte fast sofort auf, subjektiv zu sein. Nach jeder Codierungssitzung führte das System die Tests durch und erzeugte eine einfache Bilanz: X von Y bestanden, plus Stack-Traces für die Fehler. Über ungefähr 50+ Sitzungen innerhalb von 24 Stunden kletterte diese Zahl von null auf „ein bisschen über die Hälfte“ der bestandenen Tests.

Tests dienten sowohl als Navigation als auch als Leitplanken. Als eine Umstrukturierung einen früheren Ablauf störte, zogen die roten Tests den Agenten zurück und zwangen ihn, neuen Code mit alten Versprechen in Einklang zu bringen. Dieser Rückkopplungszyklus ersetzte die menschliche Code-Überprüfung durch etwas Kälteres und Zuverlässigeres: automatisierte Prüfungen.

Cole setzte stark auf Ende-zu-Ende-Tests, die einen echten Benutzer in einem kopflosen Browser simulierten. Mit Tools wie Playwright oder Puppeteer würde das Test-Framework: - Den Entwicklungsserver starten - Eine kopflose Chromium-Instanz öffnen - Sich durch den Login, den neuen Chat und die Erstellung von Artefakten klicken - Inhalte im DOM, Netzwerkaufrufe und den gespeicherten Zustand überprüfen

Diese Browser-Tests verwandelten abstrakte Anforderungen in konkrete Schritte: „klicke diesen Button“, „tippe diesen Befehl ein“, „erwarte diese Antwortform“. Wenn sie fehlschlugen, sah der Agent genaue Selektoren, Fehlermeldungen sowie erwartete und tatsächliche Werte, patchte den Code und führte die Suite erneut aus.

Am Ende beschreiben die bestandenen Tests einen teilweisen, aber echten Klon von claude.ai. Die nicht bestandenen Tests deuteten genau auf fehlende oder fehlerhafte Verhaltensweisen hin, nicht auf vage Enttäuschung.

Momentum tritt fast sofort ein. Claude Code, verbunden mit Anthropics langjährigem Agenten-Harness, startet ein neues Projekt, installiert Abhängigkeiten und erstellt eine Full-Stack-App, bevor ein Mensch die Architektur skizzieren könnte. Innerhalb der ersten Stunde generiert es ein React-Frontend, eine grundlegende Backend-API und die nötige Verkabelung, um End-to-End-Tests gegen einen lokalen Entwicklungsserver durchzuführen.

Die UI-Arbeiten erfolgen schnell und selbstbewusst. Der Agent stellt ein Layout im Stil von claude.ai nach: eine Seitenleiste für Unterhaltungen, ein Haupt-Chatbereich und ein Artefakt-Panel, das Codeblöcke und formatierten Text darstellen kann. Es werden Komponenten für Nachrichtenblasen, Eingabebereiche und Gesprächslisten skizziert und dann an Platzhalterdaten angeschlossen, sodass die Benutzeroberfläche bereits vor der Implementierung echter Logik lebendig wirkt.

Da Cole Medin eine Reihe von TDD-Überprüfungen im Voraus durchführt, gibt es eine Fortschrittsübersicht. Die frühen Tests decken die Grundlagen ab: Die App startet ohne Abstürze, die Chatansicht wird angezeigt, Nachrichten werden in der richtigen Reihenfolge angezeigt und die grundlegende Navigation funktioniert. Claude geht diese Tests wie ein Senior Engineer in einem neuen Projekt an und behebt oft fehlerhafte Tests in einem einzigen Durchlauf.

Die Grundlagen der Sanitärinstallation folgen. Der Agent verkabelt API-Routen zum Erstellen von Konversationen, zum Posten von Nachrichten und zum Abrufen von Verlauf, und aktualisiert dann das Frontend, um sie aufzurufen. TypeScript-Typen, einfache Fehlerbehandlung und Umgebungs-Konfiguration erscheinen ohne Aufforderung, eine Nebenwirkung des permanenten Wiederholens der Tests durch das Framework und der Anzeige von Stack-Traces.

Während dieses „niedrig hängenden Früchte“-Fensters sieht das System unheimlich aus wie Magie. Sie beobachten, wie sich Commits stapeln: neue Komponenten, CSS-Anpassungen, Hilfsfunktionen, Testdateien. Jeder erfolgreiche Test öffnet die nächste Ebene der Ambition – mehrfache Nachrichtenflüsse, Ladezustände, grundlegendes Rendern von Artefakten – ohne dass ein Mensch die Tastatur berührt.

Für einige Stunden ist der Engpass nicht die Intelligenz, sondern die E/A. Der Agent wartet beim `npm install`, bei Browser-Tests und beim Neustart des Entwicklungsservers mehr, als er auf Ideen wartet, und durchläuft die einfachen 30–40 % der Test-Suite, bevor die Arbeit wirklich schwierig wird.

Momentum scheitert nicht mit einem Absturz; es verflacht in Wiederholungen. Nach etwa einem Dutzend Stunden und zahlreichen Agentensitzungen hört Cole Medins claude.ai-Klon auf, sprunghaft voranzuschreiten, und beginnt, im Kreis zu laufen. Neue Commits treffen weiterhin ein, aber sie ändern hauptsächlich die vorhandene Logik, passen Selektoren an oder benennen Komponenten um, ohne neue bestehen bleibende Tests zu ermöglichen.

Komplexität hört auf, lokal zu sein, und wird systemisch. Der Agent kämpft nun mit Mehrstufenproblemen: Browserabläufe, die vom Authentifizierungsstatus abhängen, Gesprächsstränge, die über Neu ladevorgänge hinweg bestehen müssen, und die Darstellung von Artefakten, die Backend-APIs, Front-End-Routing und UI-Zustände betreffen. Jede Änderung behebt einen Sonderfall, während leise zwei weitere kaputtgehen.

Flaky-Tests werden zum Hauptgegner. Headless-Browser-Prüfungen schlagen gelegentlich aufgrund von Wettlaufbedingungen, zeitlichen Problemen oder geringfügigen DOM-Unterschieden fehl. Das Testsystem behandelt jeden fehlerhaften Test gewissenhaft als echten Fehler, sodass der Agent Runde um Runde nicht deterministische Fehlermeldungen verfolgt, die ein Mensch schnell als „Test ist schlecht, nicht die App“ kennzeichnen würde.

Man kann das Plateau in den Zahlen erkennen. Nach 24 Stunden zeigt das Harness etwas über die Hälfte der End-to-End-Tests als bestanden – beeindruckend für ein automatisiertes System, aber eine harte Obergrenze statt einer sanften Kurve. Die frühen Stunden ermöglichen offensichtliche Gewinne; in späteren Stunden wird gegen Integrationstests gekämpft, die die Nuancen des Produkts kodifizieren, nicht nur die Syntaxkorrektheit.

Wenn Aufgaben unschärfer werden, gewinnt die architektonische Intuition an Bedeutung, und dem Agenten fehlt es daran. Er kann React-Komponenten refaktorisieren, API-Handler umsortieren und TypeScript-Typen anpassen, jedoch fehlt ihm ein starkes mentales Modell der gesamten App im Stil von claude.ai. Wenn die Abläufe im Browser nicht mit den Annahmen im Backend übereinstimmen, reagiert der Agent lokal, anstatt den Ablauf neu zu gestalten.

Senior Engineers nehmen in dieser Phase einen Schritt zurück und verändern die Struktur des Systems. Sie: - Reduzieren undichte Abstraktionen - Führen klarere Grenzen zwischen UI, Zustand und API ein - Schreiben fragile Tests um, die den falschen Vertrag festlegen

Der Agent erledigt das alles nicht von selbst. Er betrachtet jeden Fehler als ein behebbare Defekt, nicht als ein Signal dafür, dass die Architektur oder das Test-Suite überdacht werden muss. Das macht ihn zu einem leistungsstarken Umsetzer - einem unermüdlichen Junior-Entwickler, der niemals mit dem Programmieren aufhört - aber nicht zu der Person, die entscheiden sollte, wie Ihre App tatsächlich funktionieren soll.

Dieses Plateau zeigt, mehr als die auffällige Demoversion in der ersten Stunde, wo die hochmoderne autonome Codierung wirklich steht: brillant in der Ausführung, aber immer noch naiv im Design.

Nach 24 Stunden endete Cole Medins Experiment mit einem sehr untypischen Silicon-Valley-Maßstab: Nur „ein wenig über die Hälfte“ der automatisierten Tests bestanden. Kein Feierabend, kein ausgefeilter claude.ai-Klon, nur ein System, das leise berichtete, dass ungefähr 50–60% seiner eigenen Vorgaben erfüllt worden waren.

Anders ausgedrückt hat ein größtenteils unbeaufsichtigter KI-Coding-Agent einen ganzen Tag damit verbracht, an einer echten Full-Stack-App zu arbeiten, und etwas ausgeliefert, das tatsächlich läuft, routet und rendert. Für ein selbstständiges System ist das ein erstaunlicher Fortschritt im Vergleich zur Ära „Spielzeug-CRUD-App in einem Prompt“, doch es bleibt dennoch weit hinter produktionsfähiger Software zurück.

Die bestanden Tests konzentrierten sich auf die Bereiche, in denen aktuelle Modelle hervorragend sind: Struktur, Standardtext und vorhersehbare Abläufe. Überprüfungen der UI-Darstellung, das Layout von Komponenten, grundlegende Navigation und einfache API-Endpunkte fielen größtenteils positiv aus, da sie klar auf Muster passen, die große Sprachmodelle bereits kennen.

Fehler häuften sich, wo ein unordentlicher, miteinander verbundener Zustand herrschte. Komplexe Gesprächsverknüpfungen, Regeln für den Lebenszyklus von Artefakten, mehrstufige Abläufe und die Behandlung von Randfallfehlern erzeugten einen Friedhof roter Tests und zeigten, wie anfällig autonomes Refactoring wird, wenn jede Änderung drei andere Teilsysteme brechen kann. Der Agent behebt oft einen fehlgeschlagenen Test, nur um einen vorherigen wieder zum Leben zu erwecken.

Coles Harness setzte stark auf browserbasierte End-to-End-Tests, die eine headless Umgebung hochfuhren und durch die gefälschte claude.ai-Oberfläche navigierten. Diese Tests bestätigten reales Verhalten – Schaltflächen, Modale, Netzwerkaufrufe – anstatt nur Funktionssignaturen, was jeden erfolgreichen Test bedeutungsvoller und jeden fehlgeschlagenen Test schwieriger machte, einfach zu übergehen.

Kostenmäßig verhielt sich das System weniger wie ein unendlicher Token-Schlauch und mehr wie ein CPU-gebundener CI-Server. Echte Testläufe, nicht die Länge der Eingabeaufforderungen, dominierten die Wand-Uhrzeit, sodass Sie Dutzende vollständiger Iterationen erhielten, ohne in absurde, millionen Token pro Stunde-Grenzen vorzudringen.

Dieser Kompromiss legt eine wichtige Einschränkung für langfristig agierende Agenten offen: die Wanduhrenlatenz schafft einen natürlichen Drosselmechanismus für das Token-Brennen, begrenzt jedoch auch, wie oft das System erkunden, scheitern und sich erholen kann. Man kann nicht einfach „auf mehr Token skalieren“ und erwarten, dass die verbleibenden über 40 Prozent der Tests – oft die kniffligsten Integrationsfälle – wie Dominosteine umfallen.

Code-Agenten benötigen keine Vibes, sondern Tests. Cole Medins 24-Stunden-Claude-Code-Marathon blieb nur deshalb im Rahmen, weil jedes wichtige Verhalten des claude.ai-Klons zunächst als automatisierte Überprüfungen existierte. Die Aufgabe des Agenten bestand nicht darin, „eine App zu erstellen“, sondern darin, „diese Tests zum Bestehen zu bringen“, was einen vagen Prompt in einen konkreten Vertrag verwandelte.

Dieses Test-Framework fungierte wie Schienen für ein ansonsten stochastisches System. Jeder Programmierzyklus sah gleich aus: Vorschläge zur Bearbeitung machen, die Testsuite ausführen, Fehler überprüfen, wiederholen. In über 50 Sitzungen schuf dieser Rhythmus etwas Seltenes in KI-Coding-Experimenten: wiederholbaren Fortschritt statt eines Haufens von unzusammenhängenden Code-Dumps.

TDD gab dem Agenten auch Regressionstraining. Als Claude das React-Frontend umgestaltete oder API-Handler neu konfigurierte, führte der Rahmen sofort umfassende End-to-End-Browsertests erneut aus, die durch Konversationen, Artefakte und Sidebar-Flows klickten. Wenn ein „Fix“ die Nachrichtenhistorie oder die Darstellung von Artefakten störte, zog ein roter Test den Agenten zurück, bevor der Fehler sich ausbreiten konnte.

Dieses Sicherheitsnetz förderte aggressiv riskante Änderungen, denen man in einem reinen „Prompt-and-Ship“-Workflow niemals vertrauen würde. Der Agent konnte ganze Komponenten herausreißen, Routen neu organisieren oder Datenstrukturen umbenennen, weil die Tests das Verhalten bewahrten. Die Absicht lebte in den Assertions; die Implementierung wurde zu einem austauschbaren Detail, das das Modell immer wieder neu anordnen konnte.

TDD trennte auch klar Absicht von Implementierung, was nahezu perfekt zu der Funktionsweise von LLMs passt. Menschliche Ingenieure kodierten Produkterwartungen als Jest- und Playwright-Tests: „Wenn ich eine Nachricht sende, erscheint sie im Thread“, „Artefakte öffnen sich in einem Panel mit Metadaten.“ Claude musste nur im Codebestand nach Möglichkeiten suchen, um diese Aussagen zu erfüllen.

Diese Externalisierung ist wichtig, weil Modelle Anforderungen halluzinieren, wenn Eingaben auf hohem Niveau bleiben. Hier existierte die Absicht außerhalb des Kontextfensters des Modells, als Code auf der Festplatte verankert. Selbst nach tausenden von Tokens und Dutzenden von Toolaufrufen blieb die Wahrheit über "fertig" dieselbe: die Suite bestehen, nicht den Eingabendenjenigen zufriedenstellen.

Vergleiche das mit dem üblichen Prompt-und-Bitte-Coding, das die Leute in Chat-UIs versuchen. Du fügst eine vage Spezifikation ein, erhältst einen Klumpen TypeScript, betrachtest ihn mit dem Auge und stellst dann drei Eingaben später fest, dass eine „kleine Anpassung“ stillschweigend die Authentifizierung oder das Zustandsmanagement kaputtgemacht hat. Keine automatisierten Regressionstests, kein stabiles Ziel, nur ein Gefühl und manuelles Klicken.

Medins Experiment macht den Kompromiss deutlich. Strukturiertes TDD plus ein Framework ergaben eine App im Stil von claude.ai, bei der nach 24 Stunden über die Hälfte der Tests bestanden. Prompt-basierte Arbeitsabläufe überstehen selten 24 Minuten, ohne in inkonsistenten, nicht reproduzierbaren Code zu kollabieren.

Der menschliche Aufwand in Cole Medins 24-Stunden-Experiment floss nicht in das Schreiben von React-Komponenten oder das Anpassen von Tailwind-Klassen, sondern in die Definition des Systems, das die KI bewohnen sollte: das Layout des Repos, das Funktionsset im Stil von claude.ai und die Verhaltensregeln, die der Agent befolgen musste. Sobald dieses Gerüst existierte, wurde Claude Code mehr wie ein sehr schneller, sehr wörtlicher Auftragnehmer als ein Kollege.

Medins am stärksten genutzte Schritte fanden statt, bevor die erste Zeile KI-geschriebenen Codes erstellt wurde. Er wählte den Technologie-Stack, verband das langfristig laufende System aus Anthropics GitHub-Repo und legte fest, dass „fertig“ bedeutete, eine Reihe automatisierter Tests zu bestehen. Dieses Fundament bestimmte alles, was der Agent in diesen 24 Stunden tun konnte und was nicht.

Das Harness selbst kodierte effektiv eine neue Stellenbeschreibung für Menschen. Ein „Initializer“-Agent legte Spezifikationen, Aufgaben und Tests fest; ein „Coding-Agent“ iterierte über die Codebasis, führte die Testsuite aus und verfolgte grüne Häkchen. Medins Rolle bestand darin, diesen Zyklus zu entwerfen, nicht jede Funktion oder CSS-Regel zu micromanagen.

Zukünftige Entwickler, die in dieser Welt erfolgreich sein werden, werden sich auf die Problemdarstellung konzentrieren und nicht auf die Syntax. Sie werden definieren:

• 1Der Problemraum: Was die App tun muss, welche Abläufe wichtig sind, welche Randfälle zählen.
• 2Die Einschränkungen: Stapelauswahl, Leistungsbudgets, Sicherheitsregeln, Integrationspunkte
• 3Die Erfolgskriterien: End-to-End-Tests, Akzeptanzschwellen und nicht verhandelbare Verhaltensweisen.

Diese Entscheidungen bestimmten, warum Claude "etwas mehr als die Hälfte" der Tests bestehen konnte und warum er dort ins Stocken geriet. Fehlende oder mehrdeutige Tests bedeuteten, dass der Agent keinen Anreiz hatte, bestimmte Integrationsfehler zu beheben. Zu allgemeine Ziele führten dazu, dass er sich in komplexen Benutzeroberflächen verlor, anstatt die Kernfunktionalität zu priorisieren.

Der Wert verschiebt sich hin zur Konstruktion des Harnischs selbst: die Eingaben, Werkzeuge und Feedback-Signale, die die Agenten auf den richtigen Hügel ausrichten. Dazu gehört das Schreiben rigoroser Test-Suites, das Entwerfen von Beobachtungsmöglichkeiten rund um die Ausführungen der Agenten und die Entscheidung, wann der Kontext zurückgesetzt oder die Spezifikation überarbeitet werden sollte. Menschen werden zu KI-Architekten, verantwortlich für den Bauplan und das Maßband, während das Modell die Trockenbauarbeiten und Verkabelungen übernimmt.

Agentisches Codieren existiert nicht mehr nur in Forschungsarbeiten und Demovideos. Cole Medins 24-Stunden-Herausforderung bringt Anthropics langjährige Agenten‑Plattform direkt in das gleiche Gespräch wie GitHub Copilot, Codeium und Replit Ghostwriter – nur dass dieses System nicht nur eine Funktion vervollständigt, sondern eigenständig einen gesamten Software-Sprint durchführt. Das System erstellt ein klaude.ai-Klon, vernetzt Benutzeroberflächen-Workflows und arbeitet den ganzen Tag an End-to-End-Tests.

Der Sprung von „intelligentem Autocomplete“ zu „persistierendem Arbeiter“ ist die eigentliche Geschichte. Werkzeuge wie GitHub Copilot arbeiten auf der Tastaturebene: Sie sagen die nächste Zeile voraus, vielleicht den nächsten Block. Medins Setup arbeitet auf der Aufgabenebene: „Implementiere Artefakte, führe Gespräche, erfülle diese 40+ Tests“, und arbeite dann durch Dutzende von Agentensitzungen, bis die Realität mit den Spezifikationen übereinstimmt – zumindest zur Hälfte.

Agent-Frameworks fühlten sich früher wie exklusive Spielzeuge von DeepMind an, verborgen hinter internen Orchestrierungsstacks. Das Open-Source-Projekt claude-code-harness von Anthropic verändert dieses Verhältnis. Ein einzelner Entwickler kann jetzt Folgendes erstellen: - Einen Initialisierungsagenten, der Spezifikationen definiert und Tests durchführt - Einen Programmieragenten, der Code bearbeitet und Browser steuert - Eine Feedback-Schleife, die über 50 Sitzungen hinweg fortgeführt wird

Diese Zugänglichkeit verändert, wer mit autonomen Agenten experimentieren kann. Sie benötigen kein spezielles Infrastrukturteam mehr, um langfristige Tools auszuführen, die CLIs aufrufen, headless Browser starten und den Projektstatus verwalten. Sie brauchen ein GitHub-Repo, eine Test-Suite und eine Kreditkarte.

Branchenspezifisch deutet dies auf eine neue Schicht im Stack hin: „AI-Bau-Pipelines“, die neben CI/CD stehen. IDE-Copiloten helfen Menschen, schneller zu tippen; eingesetzte Agenten setzen Fahrpläne um, refaktorisieren Codebasen über Nacht oder arbeiten hart an fehlerhaften Integrationstests. Medins 24-Stunden-Lauf sieht chaotisch und unvollständig aus, aber er gibt einen Ausblick auf eine nahe Zukunft, in der jede ernsthafte Ingenieurorganisation mindestens ein Repository hat, in dem der Hauptbeitragende ein Bot ist.

Die meisten Entwickler benötigen kein 24-Stunden-AI-Marathon im tmux-Paneel. Das eigentliche Upgrade besteht darin, die agentischen Gewohnheiten hinter Coles Medins Stunt zu übernehmen: Formuliere deine Ziele als Tests, gib dem Modell Werkzeuge an die Hand und lasse es durch eine Feedbackschleife arbeiten, während du auf Systemeebene supervisierst.

Beginnen Sie mit einer einzelnen Funktion, nicht mit einem vollständigen Klon von claude.ai. Wählen Sie etwas wie „OAuth-Anmeldung hinzufügen“, „CSV-Import implementieren“ oder „eine Einstellungsseite erstellen“ und definieren Sie 3–10 automatisierte Tests, die „fertig“ genauer beschreiben, als es jede Aufforderung jemals könnte.

Um diese Funktion in einer engen Test-und-Optimierungs-Schleife zu verpacken, lassen Sie Ihre bevorzugte KI die Implementierung schreiben, führen Sie die Tests durch und bitten Sie sie, alles zu beheben, was fehlschlägt. Widerstehen Sie dem Drang, sofort manuell einzugreifen; betrachten Sie sich stattdessen als den Architekten, der die Spezifikationen anpasst, Randfälle klärt und gelegentlich eine komplizierte Funktion neu schreibt.

Die eigenen Repositories von Anthropic bieten Ihnen einen konkreten Ausgangspunkt. Der langlaufende Agent, den Cole verwendet hat, befindet sich unter github.com/anthropics/claude-agentic-coding, und die umfassenderen Claude Code-Beispiele zeigen, wie Dateiänderungen, Testläufer und Browserautomatisierung in eine Schleife integriert werden können.

Du musst nicht gleich an deinem ersten Tag Coles über 50 Codierungssitzungen kopieren oder eine Headless-Browserfarm einrichten. Du kannst 80 % des Nutzens erzielen, indem du einen Agenten wiederholt `pytest`, `npm test` oder Playwright-Skripte aufrufen lässt und nur eingreifst, wenn es offensichtlich stagniert oder anfängt, übermäßig belastet zu werden.

Ein praktisches Einstiegsrezept sieht folgendermaßen aus: - Schreibe eine kurze Spezifikation und Tests für ein Feature - Gib der KI dein Repository, die Spezifikation und den Testbefehl - Lass es iterieren, bis die Tests bestehen oder der Fortschritt stagniert - Verfeinere die Tests, Architektur oder Eingabeaufforderungen und wiederhole den Vorgang

Auf diese Weise ersetzt agentengetriebenes Entwickeln dich nicht; es erweitert deinen Handlungsspielraum. Du kannst Funktionen ausprobieren, die du als „zu groß für diesen Sprint“ beiseitegelegt hättest, ehrgeizigere Refaktorisierungen erkunden und eine höhere Qualitätssicherung aufrechterhalten, weil nicht deine Geduld, sondern Tests dies durchsetzen.

Was ist ein KI-Agenten-Harness?

Ein KI-Agenten-Harness ist ein Framework, das einem KI-Modell Werkzeuge, Gedächtnis und eine strukturierte Schleife (planen, codieren, testen, verfeinern) bereitstellt, um komplexe, lang laufende Aufgaben autonom auszuführen, wie das Programmieren einer gesamten Anwendung.

Hat die KI die App erfolgreich in 24 Stunden erstellt?

Die KI hat bedeutende Fortschritte gemacht und über die Hälfte der erforderlichen Tests für einen Claude.ai-Klon abgeschlossen. Das Projekt wurde jedoch nicht vollständig abgeschlossen, was die aktuellen Einschränkungen von KI-Agenten bei komplexen Integrationsaufgaben verdeutlicht.

Ist dies heute eine praktische Methode, Software zu entwickeln?

Obwohl noch experimentell, ist der testgetriebene Ansatz äußerst praktisch. Er zeigt, dass die Definition von Erfolg mit automatisierten Tests es der KI ermöglicht, zuverlässiger zu arbeiten und bessere Ergebnisse zu erzielen als bei einfachen Gesprächstextanfragen.

Welches KI-Modell wurde im Experiment verwendet?

Das Experiment verwendete das Claude Code-Modell von Anthropic, das speziell für Softwareentwicklungsaufgaben optimiert ist, innerhalb ihres quelloffenen, länger laufenden Agentenrahmens.