Programmieren
Verbessere ein Mutationstest-Tool anhand des aktuellen Codes und der Tests
Für Änderungen an einem Mutationstest-Tool. Prüft zuerst aktuellen Code und Tests, bewahrt die Verarbeitungsreihenfolge und verzögerte Auswertung, baut Mutatoren ohne ungültige Mutanten, schreibt Tests, die sie erkennen, und folgt sicheren Schritten für Prüfung, CI und Veröffentlichung.
Funktionen in eine mehrschichtige Desktop-App einbauen und jeden Build testen
Für Fälle, in denen eine KI eine Desktop-App mit Kern, Desktop-Host und Web-Benutzeroberfläche ändert. Sie hält Regeln im Kern, begrenzt Befehle und Ordner für Werkzeuge, trennt optionale Funktionen nach echten Abhängigkeiten und testet jeden unterstützten Build vor dem Abschluss.
In hardwarenahen Systempatches echte Fehler finden statt Stilkleinigkeiten
Für Reviews von Patches an hardwarenaher Systemsoftware wie Treibern oder Paketbibliotheken. Verfolgt Speicher, Locks und Fehlerpfade, prüft Ganzzahlbreiten, Threads, Kryptografie und API-Änderungen und meldet nur behebbare Fehler, Stilfragen nur bei hoher Sicherheit.
Erweitere einen anpassbaren Go-Dienst um Funktionen und Tests, die Konfigurationsüberschreibungen standhalten
Für Änderungen an einem Go-Dienst, den nachgelagerte Builds umbenennen oder anpassen. Behält den Trace-Kontext in Logs, registriert neue Tools in der passenden Gruppe, testet öffentliches Verhalten bei überschriebener Konfiguration und aktualisiert erzeugte Doku.
Eine Kompatibilitätsschicht bauen, die sich wie ein anderes Webframework verhält
Für das Nachbauen eines anderen Webframeworks über mehrere Laufzeitumgebungen. Die KI portiert zuerst dessen Tests, wahrt Anfragereihenfolge und Laufzeitgrenzen, vereinheitlicht Dateipfade und führt nur über Pull Requests zusammen, die alle Prüfungen bestehen.
Eine verwaltete Bindungsschicht und ihre native Bibliothek ändern, ohne die ABI zu brechen
Für plattformübergreifende verwaltete Bindungsschichten um eine native C-Bibliothek. Verfolgt Änderungen durch alle Schichten, baut native Binärdateien aus Quellcode statt veralteter Downloads, hält die ABI stabil, regelt Zeigerbesitz und Threads und überspringt keine scheiternden Tests.
In einer JIT-kompilierten GPU-Kernelbibliothek Kernel hinzufügen und testen
Für Arbeiten einer KI an einer GPU-Kernelbibliothek, die Kernel erst bei Bedarf kompiliert (JIT). Sie fügt Kernel durch alle Schichten hinzu, schreibt Erzeugtes nur in beschreibbare Ordner, testet je GPU-Typ und prüft Ergebnisse, bevor sie Geschwindigkeit misst.
Ein Mehrprotokoll-Integrationsgateway ändern und prüfen, ohne Zugriffsprüfungen zu brechen
Nutze dies, wenn eine KI ein Gateway für mehrere Protokolle ändert oder prüft. Sie führt die Pflichtprüfungen aus, hält Berechtigungen streng, trennt Trace- und Audit-Schreibvorgänge ab, erstellt Migrationen sorgfältig und fragt vor einem Push nach.
Asynchrone Rust-Dienste bauen, die Abbrüche und Fehler überstehen
Für asynchrone Rust-Dienste: Die KI schreibt echten Code statt Mocks, behandelt Fehler und Abbrüche sicher, testet über die echte Dienstschnittstelle und besteht alle Prüfungen, bevor sie die Arbeit als fertig meldet.
Eine mehrsprachige Datenbibliothek ändern, ohne Dateiformate und öffentliche Schnittstellen zu brechen
Für Änderungen durch eine KI an einer schnellen Datenbibliothek mit nativem Kern und schlanken Sprachanbindungen. Hält stabile Dateiformate und öffentliche Schnittstellen kompatibel, nutzt die dokumentierten Befehle und ergänzt Tests und Dokumentation.
Code für Datenreplikation (ETL) bauen, der Werte nicht still verändert und keine Daten preisgibt
Für Code, der Daten zwischen Datenbanken kopiert. Die KI hält Änderungen klein, verhindert stille Wertänderungen wie Rundung, gibt bei kaputten Eingaben Fehler statt Abstürzen zurück, hält Geheimnisse und Zeilenwerte aus Logs fern und prüft, ob Tests wirklich liefen.
Ein Tool zur Geräteautomatisierung ändern und auf echten Geräten prüfen
Nutzen, wenn eine KI ein plattformübergreifendes Tool zur Geräteautomatisierung ändert. Hält Änderungen klein, bündelt Befehlsdaten in einem Register, wählt passende Tests und prüft mit frischen Builds auf echten Geräten oder Simulatoren, bevor sie berichtet.
Ein großes typisiertes Monorepository ändern, ohne andere Pakete zu beschädigen
Nutze dies, wenn eine KI Code mit mehreren Paketen ändert. Sie findet das zuständige Paket, nutzt gemeinsame Hilfsfunktionen, hält Build- und Typregeln ein, testet nur betroffene Pakete und meldet nur Prüfungen, die wirklich liefen.
Ändere eine Datenbank-Speicher-Engine, ohne Geschwindigkeit oder Kompatibilität zu verlieren
Nutze dies, wenn eine KI eine Datenbank-Speicher-Engine ändert. Es hält Fehlerbehandlung und Nebenläufigkeit korrekt, beschleunigt oft ausgeführten Code nur mit Benchmarks, hält APIs, Dateiformate und Builds kompatibel und verlangt reproduzierbare Tests vor jeder Freigabe.
Ein plattformübergreifendes Befehlszeilenprogramm im gemeinsamen Arbeitsbaum entwickeln, ohne fremde Arbeit zu zerstören
Für ein Befehlszeilenprogramm in einem Arbeitsbaum, den andere Sitzungen mitnutzen. Es arbeitet nur im aktuellen Arbeitsbaum, bewahrt fremde Änderungen, trennt Daten von Meldungen für Menschen, testet auf allen Systemen und hält Momentaufnahmen und Dokumentation aktuell.
Ein Containerwerkzeug ohne Root-Rechte bauen, mit Sperren und geprüften Image-Downloads
Für den Bau eines Containerwerkzeugs ohne Root-Rechte. Die KI sperrt Container bei Änderungen, prüft jede geladene Image-Schicht, übernimmt keine Host-Einstellungen, beendet ganze Prozessbäume und lehnt unsichere Pfade beim Wiederherstellen ab.
Ein KI-Tool für Code-Reviews und Korrekturen bauen, ohne Nutzercode zu verlieren
Für die Arbeit an einem Tool, das im Hintergrund KI-Code-Reviews und Korrekturen ausführt. Erst Build und Zuständigkeitsdokumente lesen, Befehle aus unsicheren Branches blockieren, laufende Jobs schützen und unsichere Pushes oder Releases stoppen.
Fähigkeiten für KI-Agenten schreiben und prüfen, ob sie wirklich helfen
Für das Hinzufügen oder Ändern von Fähigkeiten in einer Fähigkeitenbibliothek für KI-Agenten. Regelt Namen und Versionen, Beschreibungen, die zur richtigen Zeit auslösen, minimale Werkzeugrechte, Tests mit und ohne die Fähigkeit und Prüfungen vor der Freigabe.
Kleine, getestete Änderungen in das Monorepo eines Frameworks einbringen
Wenn eine KI Code im Monorepo eines Frameworks ändert. Sie sucht zuerst die maßgeblichen Anleitungsdateien, beschränkt jede Änderung auf ein Verhalten, schreibt vor der Korrektur einen fehlschlagenden Test und prüft Sicherheit, Build und Veröffentlichungshinweise.
Ein großes Python-Monorepository für Arbeitsabläufe ändern, ohne es zu beschädigen
Für den Fall, dass eine KI ein großes Python-Monorepository für Arbeitsabläufe ändert. Sie trennt die Rollen von Planer, Arbeitsprozessen und Datenbank, legt Abhängigkeiten ins richtige Paket, testet zuerst das geänderte Verhalten und prüft den ganzen Diff vor dem Pull Request.
Synchrone und asynchrone Version einer Clientbibliothek gemeinsam ändern, ohne die API zu brechen
Für Fälle, in denen eine KI eine Clientbibliothek mit synchroner und asynchroner Version ändert. Sie hält öffentliche APIs und Fehler stabil, ändert beide Seiten gleich, bremst häufige Pfade nicht und testet vom fehlschlagenden Fall bis zur vollen Matrix.
Einen Gedächtnisdienst für KI-Agenten bauen, ohne die Erinnerungen von Benutzern zu vermischen
Für den Bau oder die Erweiterung eines Langzeitgedächtnisses für KI-Agenten. Hält jede Gedächtnisbank getrennt, trennt Aufnahme, Abruf und Schlussfolgern und deckt Datenbankmigrationen, API-Clients, Tests mit einem zweiten Bewertungsmodell und Einstellungen pro Mandant oder Bank ab.
Ein Monorepository für verteilte Aufträge ändern und mit echten Diensten testen
Für eine KI, die das Monorepo einer verteilten Auftragsplattform ändert. Sie wählt pro Paket die passende Prüfung, testet mit echten Datenbanken und Warteschlangen, erfasst Paketänderungen, führt eine Aufgabe lokal vollständig aus und berichtet, was geprüft und was ausgelassen wurde.
Domänengetriebene (DDD) .NET-Module bauen, ohne Schichten oder öffentliche APIs zu brechen
Für Fälle, in denen eine KI eine modulare .NET-App mit domänengetriebenem Design ändert. Sie folgt bestehenden Mustern, hält Schichtabhängigkeiten einseitig, legt Aggregate, Repositorys und DTOs in die richtige Schicht und testet mit allen Datenbanken, ohne bestehende Nutzer zu stören.
Eine Erweiterung für mehrere Browser ändern, ohne Geheimnisse preiszugeben oder gespeicherte Daten zu beschädigen
Für Änderungen an einer Erweiterung für mehrere Browser. Hält Geheimnisse lokal, erzeugt Abhängigkeitsrichtlinien neu, ergänzt nummerierte Upgrades für gespeicherte Daten, testet in der passenden Schicht und nutzt Git nur auf Wunsch.
Verteilten Trainings- und Inferenzcode für maschinelles Lernen ändern, ohne ihn zu beschädigen
Für Software, die Modelle über viele Prozesse oder Beschleuniger trainiert oder ausführt. Fragt vor riskanten Änderungen nach, hält Gewichtsversionen gleich, lässt jeden Rang Kollektivoperationen in gleicher Reihenfolge aufrufen, hält Konfiguration kompatibel und nennt übersprungene Tests.
Eine Web-App entwickeln, die Container-Protokolle und Messwerte live zeigt
Für Änderungen an einer App aus Serverteil und Oberfläche, die Container-Protokolle und Messwerte live überträgt. Die KI hält Schichten, Stream-Grenzen, Anmelde- und Bereitstellungsarten ein, baut Funktionen durch alle Schichten, testet und schreibt kurze Reviews.
Ein öffentliches Serverpaket ändern, ohne Code zu brechen, der es erweitert
Für Änderungen an einem öffentlich ausgelieferten Serverpaket, das andere über Hooks erweitern. Die KI hält Geheimnisse fern, erhält Callbacks, Hooks und Middleware-Reihenfolge, ergänzt neue Migrationen statt alte zu ändern und führt die echten Tests und Lint aus.
Ändere ein langlebiges portables C-Projekt, ohne die Kompatibilität zu brechen
Wenn eine KI eine ausgereifte C-Codebasis ändert, die mit alten Compilern, vielen Plattformen und optionalen Funktionen laufen muss. Sie baut und testet das Betroffene, folgt den Regeln zu Stil, Speicher, Commits, Doku und Releases und hält jeden Patch klein und eigenständig gültig.
Ein Repository mit Server- und Oberflächenmodulen ändern, ohne den Build zu beschädigen
Wenn eine KI ein Repository mit API, Serverseite und Benutzeroberfläche ändert. Sie liest die Regeln jedes Moduls, hält beide Seiten abgestimmt, erzeugt den API-Client neu statt ihn von Hand zu ändern, führt passende Tests aus und fragt vor Migrationen oder neuen Abhängigkeiten.
Ein großes mehrsprachiges Datenplattform-Monorepo ändern und Pull Requests vorbereiten
Für den Fall, dass eine KI eine große Datenplattform-Codebasis in mehreren Sprachen ändert: Sie wählt den richtigen Git-Zweig, ändert erzeugte Dateien nicht von Hand, nutzt die kleinste Testbasis, testet nur Geändertes, prüft alle CI-Fehler und fragt vor push oder Pull Requests.
Ansible-Infrastrukturautomatisierung schreiben und prüfen, ohne die Sicherheit zu schwächen
Nutzen, wenn eine KI Infrastrukturautomatisierung mit Ansible schreibt oder ändert. Sie besteht alle Lint- und Sicherheitsprüfungen ohne Warnung, hält Geheimnisse aus dem Repository, prüft Netzwerke von unten nach oben, belegt, dass Tests Fehler finden, und meldet nur echte Prüfungen.
Ein großes Python-Datensystem ändern, ohne die verzögerte Ausführung auszuhebeln
Für Fälle, in denen eine KI ein großes Python-System für Daten oder Parallelrechnen ändert. Sie erfasst zuerst die Schichten, rechnet beim Aufbau von Graphen nichts aus, testet vom Nächstliegenden nach außen und veröffentlicht nichts ohne Erlaubnis.
Zuerst die Spezifikation schreiben, dann in kleinen testgeführten Schritten entwickeln
Wenn eine KI aus unklaren Anfragen in einem Repository mit Spezifikation und Plan programmiert. Sie notiert offene Fragen und wartet ab, pflegt Spezifikation und Plan, schreibt zuerst fehlschlagende Tests, prüft geänderte Dateien, schützt die Datenbank und hinterlässt eine klare Übergabe.
Regeln für eine Barrierefreiheitsprüfung schreiben, die bestanden, fehlgeschlagen oder unvollständig melden
Für eine KI, die Regeln einer Web-Barrierefreiheitsprüfung ergänzt oder ändert. Sie trennt DOM- und Abhängigkeitsschichten, liest HTML- und ARIA-Daten aus einer Quelle, testet auf realistischen Seiten mit Shadow DOM, hält Übersetzungen synchron und vermeidet Breaking Changes.
Befehlsschemata für KI-Agenten aus den echten Befehlen und Flags erzeugen
Für Schemata, die KI-Agenten zeigen, welche Befehle es gibt und wie man sie aufruft. Die KI erzeugt sie in eine Richtung aus einer geprüften Befehlsliste und den echten Befehlen und prüft Abdeckung, Beispiele sowie Sicherheit und Bestätigung.
Nimm kleine, kompatible Änderungen in einem modularen Java-Projekt vor
Für KI-Änderungen an einem in Module aufgeteilten Java-Projekt. Prüft zuerst Build- und CI-Regeln, hält ältere Java-Versionen und Modulabhängigkeiten lauffähig, testet auf der passenden Ebene und fragt vor weitreichenden oder riskanten Änderungen nach.
Einer mehrsprachigen Infrastructure-as-Code-Bibliothek Funktionen hinzufügen, ohne bestehende Nutzer zu stören
Für Änderungen an einer typisierten IaC-Bibliothek mit erzeugten Sprachanbindungen. Ordnet Funktionen der passenden Schicht zu, meidet nicht übertragbare Syntax, sichert Verhaltensänderungen mit Funktionsschaltern, hält Berechtigungen eng und ergänzt Doku und Tests.
Module zu einem Go-Server hinzufügen, ohne die Sicherheit zu schwächen
Beim Bauen oder Prüfen von Funktionen eines erweiterbaren Go-Servers. Die KI baut Module von der Erstellung bis zum Aufräumen, prüft die Konfiguration streng, besteht Tests, Lint und Build unter Linux, macOS und Windows vor dem Zusammenführen und überlässt Pull-Requests einem Menschen.
Baue eine TypeScript-App für Native und Web nach den Regeln des Repositorys
Für die Arbeit an einer TypeScript-App, die nativ und im Web läuft. Die KI folgt den Skripten und der Ordnerstruktur des Repositorys, nutzt gemeinsame Komponenten wieder, macht sichtbare Texte übersetzbar und testet jede betroffene Plattform vor dem Abschluss.
Ein Repository über alle Schichten ändern, ohne die Kompatibilität zu brechen
Für Fälle, in denen eine KI ein Repository über alle Schichten ändert. Sie liest zuerst die Vorgaben, hält Datenbankschlüssel, Migrationen und API-Felder kompatibel, nutzt gemeinsame Bausteine und Übersetzungsdateien und meldet nur Prüfungen, die wirklich liefen.
Behebe fehlgeschlagene E2E-Tests, indem du den echten Browser beobachtest
Für fehlgeschlagene E2E-Tests. Legt den sichtbaren Erfolg fest, startet den Test im echten Browser, sammelt Screenshots und Konsolenfehler, ordnet die Ursache Test, Code oder Umgebung zu, macht die kleinste Korrektur und wiederholt bis zum Bestehen oder Abbruch.
Einen Programmieragenten-Dienst bauen, der Anfragen aus Chat und Vorgangsverwaltung annimmt
Für einen Dienst, dessen Programmieragenten Aufträge von Codeplattform, Vorgangsverwaltung und Chat erhalten. Trennt Haupt-, Prüf- und Analyserolle, hält pro Thread eine Sandbox, legt die Reihenfolge der Middleware fest und macht die automatische CI-Reparatur schaltbar.
Eine Go-API und eine React-SPA ändern, indem zuerst die OpenAPI-Spezifikation angepasst wird
Für Repositories mit Go-Backend und React-SPA, die eine OpenAPI-Spezifikation teilen. Ändert die Spezifikation statt generierter Dateien, erzeugt den Code neu, folgt Regeln für Einstellungen, Fehler, Sitzungen, Downloads und Aktualisierungen und testet vor dem Bericht.
Komponenten in einer UI-Komponentenbibliothek mit Theme-Unterstützung erstellen oder ändern
Für Fälle, in denen eine KI eine Komponente in einer wiederverwendbaren UI-Bibliothek hinzufügt oder ändert. Findet die betroffenen Dateien, erhält Theme-Standardwerte, Barrierefreiheit und Layouts von rechts nach links und ergänzt Tests und Dokumentation.
Aus einer Softwareidee ein getestetes Mehragentensystem bauen
Für Systeme, in denen mehrere KI-Agenten und Werkzeuge zusammenarbeiten. Stellt eine Frage nach der anderen, lässt Rollen und Kommunikation freigeben, baut in Abhängigkeitsreihenfolge und wiederholt 5 Nutzerszenarien, bis sie bestehen.
Ein Full-Stack-TypeScript-Monorepo ändern und seine LLM-Funktionen nach Bedeutung testen
Für KI-Änderungen an einem TypeScript-Monorepo mit LLM-Funktionen. Führt nur die Paketprüfungen der CI aus, testet Verhalten, hält personenbezogene Daten aus breiten Logs heraus und bewertet LLM-Antworten nach Bedeutung statt Wortlaut.
Eine Full-Stack-TypeScript-App mit API-Schemas bauen, die Server und Client teilen
Für den Bau oder Umbau einer Full-Stack-TypeScript-App. Die KI legt jede API-Anfrage und -Antwort einmal für Routen und Client-Hooks fest, prüft die Anmeldung vor dem Lesen von Eingaben, hält Abhängigkeiten, Cache und Stile einheitlich und schreibt schnelle Tests.
Code in einem Full-Stack-Monorepo ändern, ohne gemeinsame Pakete zu beschädigen
Für KI-Änderungen in einem Monorepo mit Apps und gemeinsamen Paketen. Legt jede Änderung ins zuständige Modul, baut erzeugte Bundles neu, hält die Daten jeder Organisation getrennt und liefert einen Pull Request mit Testergebnissen.
Code einer Hochleistungsdatenbank ändern, ohne Tempo oder Kompatibilität zu verlieren
Für Änderungen durch eine KI an einer auf Tempo ausgelegten Datenbank mit Java, SQL, Rust, nativem Code und CI. Legt Regeln für Codestil, NULL, Speicherfreigabe, Abfragetests, Fehlersuche, Pull Requests und Builds fest und endet mit einer Prüfung vor der Fertigmeldung.
Eine Sicherheitsschulungs-App mit absichtlichen Schwachstellen ändern, ohne ihre Übungsaufgaben zu beschädigen
Für Änderungen an einer Schulungs-App, deren Schwachstellen Lerninhalte sind. Die KI trennt gewollte Übungsaufgaben von zufälligen Fehlern, hält Änderungen klein, entfernt KI-Füllstoff, führt die nötigen Tests und das Übungs-Sicherheitsnetz aus und hält Korrekturdateien abgeglichen.
Eine analytische Datenbank-Engine in C++ ändern und die nötigen Tests bestehen
Für Änderungen am Code einer analytischen Datenbank-Engine in C++. Die KI verfolgt die Änderung vom SQL-Parsing bis zur Ausführung, ändert erzeugte Dateien über ihre Quelle, hält die C++- und Fehlerregeln ein und schließt erst ab, wenn SQL-Logiktests und alle nötigen Builds bestanden sind.
Einen Fehler beheben, indem man ihn zuerst mit einem fehlschlagenden Test nachstellt
Für gemeldete Fehler. Die KI ordnet ein, welcher Teil zuständig ist, stellt das sichtbare Fehlverhalten in einem fehlschlagenden Test nach, findet die echte Ursache, behebt sie mit der kleinsten Änderung, behält den Test gegen Rückfälle und prüft mit den Schritten der Nutzer nach.
Eine Bibliothek erstellen, die Bilddateien mit Ebenen ohne Datenverlust liest und schreibt
Für eine Binärformat-Bibliothek für Bilder mit Ebenen. Sie trennt das binäre Lesen von der Benutzer-API, liest Abschnitte der Reihe nach, behält unbekannte Daten, baut Ebenengruppen neu auf, testet durch Lesen, Schreiben und erneutes Lesen und veröffentlicht automatisch.
Sicherheitsdokumentation für Entwickler schreiben und prüfen
Für das Schreiben oder Prüfen von Sicherheitsdokumentation für Entwickler in einem gemeinsamen Repository. Zitiert nur gelesene Quellen, nennt, wovor jede Maßnahme schützt und wovor nicht, hält Änderungen klein, führt die Prüfungen des Repositorys aus und legt KI-Hilfe offen.
Kleine, getestete Änderungen in einem großen TypeScript-Monorepo vornehmen
Für Fälle, in denen eine KI einen TypeScript-Arbeitsbereich mit vielen Paketen ändert. Sie erfasst zuerst Aufbau und Werkzeuge des Repositorys, führt nur die betroffenen Builds und Tests aus, ändert erzeugte Dateien nicht ohne Grund und prüft, ob alles unter Unix und Windows läuft.
Ein Monorepository mit mehreren Implementierungen ändern, ohne dass sie auseinanderlaufen
Für Änderungen an einem großen mehrsprachigen Monorepository, in dem ein Produkt mehrere Implementierungen hat. Die KI liest lokale Regeln, überträgt sichtbare Änderungen auf alle, baut neu, was Tests nutzen, testet gezielt, ergänzt Freigabeeinträge und pflegt den Änderungsantrag.
Zustandsbehaftete UI-Bibliothek in kleinen Schritten ändern, ohne bestehende Nutzer zu stören
Wenn eine KI eine zustandsbehaftete UI-Bibliothek im Browser ändert. Sie findet den Besitzer des Zustands, hält öffentliche APIs und gespeicherte Daten kompatibel, schreibt zuerst einen fehlschlagenden Test, wählt die passende Testart und prüft Änderungen und Veröffentlichungshinweis.
Einen lokalen Cloud-Emulator bauen, der mit offiziellen SDKs und CLIs funktioniert
Für neue Dienste oder Operationen in einem Emulator, der eine Cloud lokal nachbildet. Ermittelt zuerst das echte Protokoll, hält Anfragen und Antworten wie in der echten Cloud, ändert Speicherung und Konfiguration gemeinsam und testet vor der Freigabe mit offiziellen SDKs.
Einen Emulator bauen, der Bus und Timing der echten Hardware nachbildet
Für das Bauen oder Korrigieren eines Emulators. Teilt den Code nach Hardwareteilen, bildet Bus, Timing und DMA exakt nach, testet mit auf echter Hardware bestandenen Programmen und hält Speicherstände und öffentliche API stabil.
Kleine Codeänderungen umsetzen, die lokale Tests und eine Prüfung bestehen
Für den Fall, dass eine KI deinen Code ändert. Sie legt vorher fest, was sich ändert und wie es nachgewiesen wird, testet lokal vor und nach der Änderung, lässt die aktuellen Änderungen prüfen, behebt nur echte Probleme und endet mit einem Übergabebericht.
Ändere ein mehrsprachiges Automatisierungs-Monorepo, ohne die Kompatibilität zu brechen
Wenn eine KI ein großes Automatisierungs-Monorepo mit Anbindungen für mehrere Sprachen ändert. Sie hält öffentliche APIs kompatibel, baut und testet nur das kleinste betroffene Ziel, vergleicht mit einer anderen Anbindung und fragt vor Änderungen an riskanten gemeinsamen Bereichen nach.
Backend und Frontend einer Erzeugungs-App über OpenAPI synchron halten
Für Apps, in denen Elemente extrahiert, auf einer Vorbereitungsseite bestätigt und im Erzeugungsarbeitsbereich erzeugt werden. Erzeugt nach jeder API-Änderung die OpenAPI-Typen neu, trennt Aufgaben der Oberflächen und Zustandsarten und hält Dokumentation und Versionshinweise aktuell.
Code in einem großen Monorepo mit vielen Paketen ändern und testen
Für eine KI, die in einem großen Framework-Repository mit vielen Paketen arbeitet. Sie prüft vor dem Bearbeiten den Aufbau, hält den Build aktuell, wählt Tests passend zum CI-Modus, behebt zuerst CI-Fehler, hält Geheimwerte aus Protokollen heraus und prüft jede Änderung.
Kleine Änderungen an einer systemnahen Bibliothek vornehmen, ohne die öffentliche API zu brechen
Wenn eine KI eine systemnahe Bibliothek repariert oder ändert. Sie hält Änderungen klein, lässt öffentliche API und ABI unberührt, sofern nicht verlangt, baut und testet das betroffene Teilsystem, scheitert bei Speicherfehlern sicher und pusht nie.
Eine Codebasis mit mehreren Paketen ändern, ohne Funktionierendes kaputtzumachen
Für eine KI, die ein Repository mit mehreren Paketen bearbeitet. Sie klärt zuständiges Paket und Regeln, erhält bisheriges Verhalten und öffentliche Namen, ergänzt Tests und Dokumentation, fragt vor neuen Abhängigkeiten nach Genehmigung und berichtet Prüfungen und offene Risiken.
Statische Analyseregeln mit Autokorrekturen schreiben, die das Laufzeitverhalten nicht ändern
Für neue statische Analyseregeln (Lint). Zielt auf häufige Muster, nutzt vorhandene Helfer, bietet Autokorrekturen nur, wenn sie sicher sind, testet heikle Syntax und erzeugt Dokumentation neu, statt sie von Hand zu ändern.
Ein Rust-Datenfluss-Framework für Robotik und KI entwickeln und Tests passend zur Änderung wählen
Nutze dies, wenn eine KI an einem Rust-Datenfluss-Framework für Robotik und KI arbeitet. Sie hält die Nachrichtenregeln klar, prüft vor jedem Commit, wählt tiefe Tests nach Risiko und meldet, welche Tests wirklich liefen.
Backend-Code beim Ändern vor Angriffen über Uploads und Nutzereingaben schützen
Nutze dies, wenn eine KI Backend-Code ändert, der Uploads, Archive oder Anfragedaten verarbeitet. Sie verfolgt externe Daten, prüft sie vor der Nutzung, behebt alle ähnlichen Codepfade und schließt mit einer Sicherheits-Checkliste sowie bestandenem Lint und Tests ab.
Eine mandantenfähige Automatisierungsplattform bauen, ohne Mandanten oder Editionen zu vermischen
Für Code an einer mandantenfähigen Automatisierungsplattform mit Gemeinschafts-, Unternehmens- und gehosteter Edition. Hält jede Abfrage im Projekt, leitet ausgehendes HTTP gegen SSRF über den sicheren Client, deklariert Abhängigkeiten dort, wo sie genutzt werden, und testet jede Edition.
Ereignisgesteuerte Zustandsautomaten bauen und ändern, ohne ihr Verhalten zu beschädigen
Für Zustandsautomaten-Bibliotheken: Die KI verarbeitet jedes Ereignis ganz vor dem nächsten, überspringt bei Fehlern kein Aufräumen, schützt Threads und untergeordnete Automaten, schreibt zuerst Tests für synchrone und asynchrone Ausführungsmodule und hält Code, Doku und Schemas gleich.
Code in großen Repositorys mit mehreren Sprachen ändern und nur Nötiges bauen und testen
Für Codeänderungen in großen Repositorys mit mehreren Sprachen. Die KI studiert ähnlichen Code, prüft verfügbare Werkzeuge und Hardware, baut und testet nur Betroffenes, stellt vor dem Merge die volle CI wieder her und meldet, was ungeprüft blieb.
Eine Webentwicklungs-CLI aus JavaScript und nativem Code in der zuständigen Ebene ändern
Für Änderungen an einer Webentwicklungs-CLI, die JavaScript und nativen Code mischt. Findet die zuständige Ebene, prüft den globalen und den lokalen Befehlsweg und wählt Tests passend zur Art der Änderung.
Baue ein System, das hochgeladene Dokumente einliest und für KI-Agenten durchsuchbar macht
Für einen Dienst, der PDFs und andere Dateien für die KI-Suche aufnimmt. Leitet jede Datei an einen passenden Parser, behält Überschriften und Tabellen, speichert Chunks in festem Format und sucht innerhalb eines Budgets, mit Belegen und Quellenangaben.
Offline-Wiederherstellungssoftware entwickeln, die ein Geheimnis in Teile aufteilt
Für Software, die ein Geheimnis auf Vertrauenspersonen verteilt und offline wiederherstellt. Verfolgt jede Änderung, teilt die Kryptologik zwischen CLI und Browser, hält Pakete offline, testet zuerst und schreibt ruhige, klare Texte für Menschen unter Druck.
Ein Framework entwickeln, das eine API für mehrere Programmiersprachen bereitstellt
Für Frameworks, die aus einer Codebasis Pakete für mehrere Sprachen erzeugen. Legt Regeln fest für das JSON-Protokoll zwischen Prozessen, exportierbare Typen, Codeerzeugung und Tests, die gleiches Verhalten in allen Sprachen prüfen.
Einen KI-Agenten bauen, der mit Werkzeugen untersucht, und prüfen, dass er nicht rät
Für einen KI-Agenten, der Probleme über Werkzeugaufrufe untersucht. Werkzeuge sind standardmäßig nur lesend, liefern begrenzte Daten und erklären Fehler genau; alte Konfigurationsnamen bleiben gültig, und Tests fragen nach Fakten, die nur echte Abfragen finden.
Codebeiträge vorbereiten, die ein Mensch prüft und einreicht
Für eine KI, die in einem gemeinsam genutzten Code-Repository arbeitet. Befolgt die Projektregeln, wartet auf die Freigabe der Projektverantwortlichen, hält Geheimnisse aus Commits und Tests heraus und entwirft Pull Requests, die ein Mensch einreicht.
KI-Anbieter und Vektorspeicher zu einem modularen Rust-KI-Framework hinzufügen
Für die Erweiterung eines Rust-Frameworks für viele KI-Anbieter. Die KI folgt den vorhandenen Traits und Buildern, erhält die WebAssembly-Unterstützung, lässt Hooks mit und ohne Streaming gleich arbeiten und prüft aufgezeichnete Kassetten auf API-Schlüssel.
Ein CLI-Werkzeug zu einem plattformübergreifenden Downloader hinzufügen und jede Binärdatei prüfen
Nutze dies, um ein CLI-Werkzeug in einem Installer, der Release-Binärdateien lädt, hinzuzufügen oder zu prüfen. Es ermittelt die Dateien je System und Architektur, ordnet URLs zu, testet mit fester Version, prüft jede Binärdatei und aktualisiert Katalog und PR.
Ein Konsolen-UI-Toolkit nach seiner aktuellen Doku ändern und am echten Bildschirm prüfen
Für ein Konsolen-UI-Toolkit nach einer großen Neufassung: Die KI folgt der aktuellen Repository-Doku statt alten Gewohnheiten, legt Tests richtig ab und zeichnet das laufende Terminal auf, um UI-Änderungen zu prüfen.
Eine große .NET-Codebasis ändern und dabei schnell und kompatibel halten
Für große, leistungskritische .NET-Quellcodearchive wie eine Build-Engine. Vermeidet zusätzliche Speicherzuweisungen in kritischen Pfaden, wertet jede neue Warnung als inkompatible Änderung, kompiliert vom kleinsten Projekt aus und nennt ausgeführte Builds, Tests und Beispiele.
Einen Rust-Workspace mit Bibliotheken und CLI ändern und mit dem Referenzwerkzeug vergleichen
Für KI-Änderungen an einem Rust-Workspace mit Bibliotheken und CLI-Tools. Beginnt mit einem fehlschlagenden Test, vergleicht Ergebnisse mit dem Referenzwerkzeug, vermeidet unwrap() und testet jede Feature-Kombination.
Mobile UI-Automatisierung entwickeln und Fehler im Produkt statt in der CI beheben
Wenn eine KI ein Tool zur Automatisierung mobiler Oberflächen entwickelt. Sie legt jede Änderung ins zuständige Modul, wählt die günstigste Testebene, trennt Testsammlungen, die bestehen oder scheitern müssen, und behebt Fehler im Produkt statt in der CI.
Ein lokales Codegraph-Werkzeug bauen, das KI-Agenten abfragen können
Für ein Werkzeug, das eine Codebasis in einen lokalen Graphen für KI-Agenten umwandelt. Behandelt Symbole und Verknüpfungen aus Syntaxbäumen, sauberes Installieren und Deinstallieren in mehreren Clients, brauchbare Antworten für Agenten, Tests mit echten Repositorys sowie Releases.
Eine plattformübergreifende Werkzeugkettenverwaltung entwickeln und Aufnahmen ins Verzeichnis prüfen
Für KI-Agenten, die an einem Verwalter für Versionen von Entwicklerwerkzeugen arbeiten. Folgt den Aufgaben und Modulen des Repositorys, verlangt Verbreitungsbelege vor der Aufnahme ins Verzeichnis, überlässt die Versionsreihenfolge den Backends und prüft gezielt je Plattform.
Ändere ein Repository mit mehreren Modulen und erzeugtem Code, ohne Freigaben zu überschreiten
Für KI-Arbeit in einem Repository mit mehreren Modulen und erzeugtem Code. Liest zuerst lokale Regeln, ändert Spezifikationen statt erzeugter Dateien, macht kleine, kompatible Änderungen mit Tests je Modul und überlässt Releases und Pipelines berechtigten Personen.
Ein großes TypeScript-Repository zur Bewertung von KI-Modellen ändern und testen
Für KI-Agenten in einem großen TypeScript-Repository mit CLI, Web-App und KI-Modellbewertung. Liest lokale Regeln, testet Änderungen in der echten CLI oder im Browser, debuggt ohne Caches oder Daten zu löschen, bringt Änderungen über Branches und CI ein und prüft zuerst die Sicherheit.
Ein typisiertes Monorepo ändern, ohne es zu beschädigen, und sein Wiki aktuell halten
Für Fälle, in denen eine KI in einem großen typisierten Monorepo mit Projekt-Wiki arbeitet. Sie nutzt die Befehle des Repositorys, vermeidet veraltete Build-Dateien und Probleme mit Start-Snapshots, führt passende Tests aus und pflegt Wiki-Seiten mit ihren Quelldateien.
Ändere einen Rust-Reverse-Proxy, ohne Ereignisschleife und Sicherheit zu beschädigen
Für KI-Änderungen, Tests und Releases eines Rust-Proxys mit mehreren Prozessen. Legt Regeln fest für Build und Feature-Flags, Fehler und Logs, Ereignisschleife und Protokoll, Tests und Fuzzing, sicherheitskritischen Code, Pull-Requests und Release.
Ein großes Plattform-Monorepo ändern und alle betroffenen Clients synchron halten
Für KI-Änderungen an einem Plattform-Monorepo mit CLI, Client-Bibliotheken und Doku. Liest zuerst die Regeln jedes Bereichs, erzeugt Dateien aus ihren Quellen neu, fragt vor inkompatiblen Änderungen und meldet, welche Prüfungen liefen.
KI-erstellte Pull Requests mit menschlicher Prüfung an ein quelloffenes Framework senden
Wenn eine KI Code zu einem quelloffenen Java-Framework beiträgt. Kennzeichnet KI-Arbeit, liest vor dem Korrigieren die Codehistorie, entfernt feste Wartezeiten aus Tests, folgt dem Vertrauensmodell des Projekts und führt nur nach menschlicher Freigabe zusammen.
Einem schemageprüften Katalog KI-Anbieter und -Modelle hinzufügen
Wenn eine KI einen Katalog von KI-Anbietern und -Modellen ergänzt oder prüft. Sie startet den Validator des Repositorys, erbt gemeinsame Modelldaten statt sie zu kopieren, trägt nur geprüfte Reasoning-Einstellungen und Preise ein und erhält Quellen beim Synchronisieren.
Ein großes Repository mit systemnahem Code und langsamen Builds ändern, ohne sprachübergreifende Aufrufe zu brechen
Für Änderungen in einem großen Repository mit systemnahen Sprachen, erzeugten Anbindungen und langsamen Builds. Passt den Ablauf an die Änderung an, startet mit dem kleinsten Test, speichert lange Logs einmal und schützt sprachübergreifende Aufrufe.
Einen Extraktor für den Hauptinhalt von Webseiten bauen und verlorene Inhalte finden
Zum Bauen oder Reparieren eines Extraktors für den Haupttext von Webseiten in Browser, Server, CLI oder Edge. Die KI hält die Reihenfolge der Bereinigung ein, protokolliert jede Entfernung, blockiert Skript-Einschleusung und belegt Korrekturen mit einem zuerst fehlschlagenden Test.
Eine öffentliche Go-Bibliothek ändern, ohne den Code ihrer Anwender zu brechen
Für Änderungen an einer öffentlichen Go-Bibliothek. Die KI prüft zuerst unterstützte Go-Versionen und Zweige, testet mit den Werkzeugen des Projekts, folgt den vorhandenen API-Mustern und erstellt einen Änderungsantrag mit Testergebnissen und Kompatibilitätsfolgen.
Eine lokale CLI bauen, die Dokumente nach Stichwort und Bedeutung durchsucht
Für den Bau oder die Pflege eines Befehlszeilenwerkzeugs, das Dokumente auf dem eigenen Rechner durchsucht. Regelt Sammlungen, Kontexthinweise, Stichwort- und Vektorsuche, Ergebnisgrenzen, den Betrieb als Dienst, Tests und Veröffentlichung; Indexänderungen führt der Benutzer aus.
Agentenfähigkeiten aus der Projektdokumentation erstellen und aktuell halten
Erstellt KI-Agenten-Fähigkeiten aus Projektdokumenten oder Fähigkeiten des Ursprungsprojekts. Trennt erzeugte, abgeglichene und handgeschriebene Fähigkeiten, schreibt eine kurze Übersicht mit Referenzdateien zu je einem Thema und aktualisiert nur Änderungen seit der erfassten Revision.
Eine Datenbibliothek mit leicht auffindbaren APIs und Tests mit echten Werten bauen
Für das Bauen oder Ändern einer Bibliothek, die komplexe Quelldaten in einfache Objekte umwandelt. Die KI prüft den Code vor Änderungen, führt Vorgänge nach und verlangt für jede neue Funktion einen Test mit echten Werten, ein lauffähiges Doku-Beispiel und klare Fehler.
Code in einem Repo mit mehreren Paketen ändern und PRs nur aus dem eigenen Fork öffnen
Nutzen, wenn eine KI ein Repo mit mehreren Paketen und schreibgeschütztem Upstream bearbeitet. Folgt den Anweisungen je Ordner, pusht nur in deinen Fork, schützt nicht committete Änderungen, markiert die Herkunft von Python-Tests und berichtet mit echt gelaufenen Prüfungen.
Langzeitgedächtnis für KI-Agenten mit Graph- und Vektorsuche bauen
Nutze dies, wenn KI-Agenten Wissen über Sitzungen hinweg behalten sollen. Wandelt Dateien, URLs und Text in durchsuchbare Graph- und Vektordaten um, trennt die Daten jedes Nutzers mit Authentifizierung und macht Speicher und Modellanbieter austauschbar, ohne den Kerncode zu ändern.
Einen graphbasierten Autorisierungsdienst ändern und dabei zuerst Tests schreiben
Für Änderungen an einem graphbasierten Autorisierungsdienst. Verfolgt den Weg jeder Anfrage, nutzt die Build-Targets und Lint-Regeln des Repositorys, schreibt zuerst einen fehlschlagenden Test und ändert erzeugte Dateien nicht von Hand.
Ein typsicheres Web-Framework ändern und den Datenbankcode in drei Schichten trennen
Für Änderungen an einem typsicheren Web-Framework aus mehreren Paketen. Arbeitet in der festgelegten Umgebung, prüft erst schnell und dann vollständig, hält öffentliche Module klein, trennt den Datenbankzugriff in Schichten und nutzt nie Force-Push.
Halte KI-Skill-Dokumente an einer Stelle und schreibe sie zum Nachschlagen für die KI
Für die Pflege von KI-Skill-Dokumenten. Behält eine Quelldatei und erzeugt Kopien daraus neu, stellt Entscheidungstabellen voran, legt Details in Referenzdateien ab, testet das Verhalten vor und nach Änderungen und überlässt Versionen der automatischen Veröffentlichung.
Einen SQL-Compiler für mehrere Dialekte erweitern, ohne die Bedeutung der Abfragen zu ändern
Für Änderungen an einem SQL-Compiler, der SQL in einen AST umwandelt und für andere Datenbanken neu erzeugt. Er findet zuerst die zuständige Schicht, wahrt die Bedeutung über Dialekte hinweg, baut SQL mit AST-Hilfsfunktionen statt Zeichenketten und testet echte Ausführung und Tempo.
Agentenfähigkeiten schreiben und veröffentlichen, die richtig auslösen und die Prüfung bestehen
Für ein Repository mit Agentenfähigkeiten: Die KI schreibt kurze Beschreibungen zu Zweck und Einsatz, hält die Hauptdatei knapp mit separaten Referenzen, gleicht Versionen und Doku ab und lässt vor jeder Veröffentlichung die Prüfwerkzeuge laufen.
Ein komplexes CLI-Werkzeug aus Skripten starten und den Erfolg im JSON-Bericht prüfen
Für Skripte oder Coding-Agenten, die eine komplexe CLI ausführen. Prüft zuerst Aufgaben und Klassen, hält ohne Lizenz vor lizenzpflichtigen Aufgaben an, legt Eingaben und Gerät fest und bewertet den Erfolg an Exit-Code und JSON-Bericht statt am Fortschrittstext.
Einem Spracherkennungs-Repository Dateiendungen oder neue Sprachen hinzufügen
Für Fälle, in denen eine KI einem Spracherkenner Dateiendungen oder Sprachen hinzufügt. Sie ergänzt echte Codebeispiele und getestete Regeln für geteilte Endungen, erzeugt Dateien über die Skripte des Repositorys und prüft Nutzungs- und Lizenzbelege vor der Einreichung.
Einen KI-Agenten-Dokumentgenerator ändern, ohne aktuellen und alten Stack zu verwechseln
Für eine KI, die eine Multi-Agenten-App für Dokumente mit altem Stack ändert: Sie sucht den echten Startbefehl, vertraut dem Code statt veralteter Doku, hält Konfigurationsnamen stabil, verfolgt Änderungen über Python und Node und führt die kleinsten sinnvollen Tests aus.
Einem modularen Netzwerkdienst Module hinzufügen, ohne die Modulgrenzen zu verletzen
Hilft, wenn eine KI einen modularen Netzwerkdienst ändert oder erweitert. Sie verbindet Module nur über gemeinsame Schnittstellen, baut und testet mit den Werkzeugen des Repositorys, gibt für Clients sichere Fehler zurück und teilt keinen Zustand zwischen Anfragen.
Ein selbst gehostetes Monorepo zur Zertifikatsautomatisierung ändern, ohne Geheimnisse preiszugeben
Für eine KI, die ein selbst gehostetes Tool ändert, das Zertifikate per ACME holt, erneuert und ausrollt: Sie ändert das zuständige Paket oder Plugin, schreibt zuerst Tests, ergänzt SQL-Migrationen, nutzt UI-Muster und hält Zertifikate und Schlüssel aus Code und Logs heraus.
Einen Generator für Wrapper nativer Bibliotheken in vielen Sprachen korrigieren und testen
Für Änderungen an einem compilerartigen Tool, das aus nativen Bibliotheksdeklarationen Wrapper für viele Sprachen erzeugt. Verfolgt Fehler bis zur Stufe ihres Ursprungs, wählt passende Tests, ergänzt Regressionstests und pflegt das Änderungsprotokoll.
Eine Sammlung von KI-Agenten-Kompetenzen bauen, die die Qualität von Websites prüfen
Für das Hinzufügen oder Ändern von Kompetenzen, die Ladetempo, Barrierefreiheit und SEO von Websites prüfen. Regelt Format und Namen von SKILL.md, kurze Dateien, Vorher-nachher-Beispiele, Shell-Skripte, die bei Fehlern stoppen, und eine Rangfolge nach Nutzerwirkung.
Ein Full-Stack-Repository mit seinen eigenen Befehlen und Tests ändern
Für eine KI, die ein Repository mit Frontend, API, SDK, CLI und Datenbank ändert: Sie nutzt dessen Befehle und feste Versionen, trennt die Aufgaben der Schichten, testet in der zuständigen Schicht, prüft geänderte Seiten und API-Aufrufe mit Anmeldung und nennt die Nachweise.
Entwickle Funktionen aus Spezifikationen und hole vor dem Programmieren die Freigabe ein
Für KI-Entwicklung in Schritten auf Basis von Spezifikationen. Trennt Projektvorgaben von Funktionsspezifikationen, schreibt Anforderungen, Entwurf und Aufgaben der Reihe nach mit Freigabe, holt eine unabhängige Prüfung ein und belegt den Abschluss mit frischen Nachweisen.
Regeln für Web-Oberflächen in einem Regelwerk schreiben und vor dem Veröffentlichen prüfen
Für eine KI, die ein Regelwerk für Web-Oberflächen (Barrierefreiheit, Leistung, SEO, Sicherheit) bearbeitet. Legt Pflicht-Metadaten, Reihenfolge der Abschnitte und messbare Grenzwerte fest, hält gemeinsame UI im Designsystem und führt vor dem Veröffentlichen alle Prüfungen aus.
Einen KI-Programmieragenten in einem Repository mit strengem Build zu warnungsfreiem Code und ehrlichen Berichten anhalten
Nutze dies, wenn ein KI-Programmieragent in einem Repository mit strengen Build-Prüfungen arbeitet. Er baut und prüft vor jedem Push, hält die Commit-Regeln ein, schreibt sicheren Code und belegt jede Behauptung am Code.
In einer großen Codebasis die Ursache beheben und die öffentliche API kompatibel halten
Wenn eine KI eine große, geschichtete Codebasis ändert. Hält Build-Logs kurz, verfolgt Fehler bis zur Ursache weiter oben, prüft den eigenen Diff auf Helfer, die nur Probleme verdecken, und schreibt einen klaren Pull Request.
Eine große modulare Codebasis lesbar halten und ohne Brüche ändern
Für den Einsatz, wenn eine KI in einer großen Codebasis aus vielen Komponenten arbeitet. Gibt Regeln für Codestil, Datei- und Änderungsgröße, Code-Review, Tests, API-Namen und Builds vor, damit Änderungen klein und lesbar bleiben und keine anderen Teile kaputtgehen.
Eine KI nur nötigen Code ändern und vor riskanten Schritten nachfragen lassen
Wenn ein KI-Agent Code in deinem Projekt ändert. Er legt zuerst den Änderungsrahmen fest, fügt nur Code mit klarem Zweck und Tests hinzu, die echte Fehler finden, fragt vor dem Löschen, Pushen oder Aufruf von Produktions-APIs nach und meldet am Ende geänderte Dateien und Prüfungen.
Getestete, reviewfertige Änderungen in einer großen Codebasis machen
Für den Einsatz, wenn ein KI-Agent eine große, mehrsprachige Codebasis ändert. Er baut über den Wrapper des Projekts, legt Tests neben den Code und prüft, dass sie ohne die Änderung fehlschlagen, hält sich an die Review-Regeln und meldet nur, was er selbst ausgeführt hat.
Im bestehenden Repository nur das Gewünschte ändern und bei Unklarheit nachfragen
Für KI-Agenten, die bestehenden Code ändern. Der Agent fragt bei Unklarheit nach, ändert nur das Gewünschte, führt erst die gezielten Tests und dann die ganze Testsuite aus, bevor er etwas als geprüft meldet, und macht ohne Auftrag keinen Commit, keinen Push und keine Veröffentlichung.
Kleine, abgestimmte Änderungen in eine gemeinsame Codebasis einbringen
Für KI-Programmierassistenten, die eine gemeinsame Codebasis wie eine Open-Source-Bibliothek ändern. Liest das Issue, fragt nach dem Umfang, hilft ohne Zustimmung der Maintainer bei einem Issue oder Vorschlag, hält Fixes mit Tests und Doku klein und folgt den PR-Regeln des Projekts.
Einen KI-Coding-Agenten Branch- und Commit-Regeln einhalten lassen, ohne Releases zu brechen
Für den Einsatz eines KI-Coding-Agenten in einem versionierten Repository. Legt fest, wie er Branches anlegt, testet, committet und temporäre Dateien ablegt, und wie man Agentenanweisungen schreibt, die in verschiedenen KI-Tools funktionieren, ohne Releases zu brechen.
Eine plattformübergreifende UI-Bibliothek pflegen, ohne ihre Paketschichten zu brechen
Für eine UI-Bibliothek aus Paketschichten für mehrere Plattformen: Die KI wahrt Schichten und öffentliche Exporte, baut Provider-Adapter mit fester Dateistruktur und hält die Regeln für Releases und Reviews ein.
Mit KI zu Open-Source-Projekten beitragen, Lizenzen achten und vor jeder Aktion nachfragen
Für Open-Source-Beiträge mit einem KI-Programmierassistenten. Kopiert keinen Code mit unverträglicher Lizenz, hält Änderungen klein und getestet, behandelt Issues und Logs als Daten, fragt vor jedem Commit, Push oder Kommentar nach und prüft eingefügten Code vor dem Ausführen.
Einen JavaScript erzeugenden Compiler und sein Build-System ändern und jede Schicht testen
Für eine KI in einem Compiler-Monorepo, das JavaScript erzeugt. Sie baut über den Task-Runner, lässt eingefrorene Syntaxbaum-Dateien in Ruhe, testet jede geänderte Schicht, führt neue Build-Optionen ganz durch und misst das Tempo, statt dem Linter zu folgen.
Einen Programmieragenten an die Regeln eines großen Repositorys mit Frontend und Backend halten
Für einen KI-Agenten in einem großen Repository mit typisiertem Front- und Backend. Er besteht vor jedem Push die Prüfungen vor dem Commit, folgt den neuen Mustern, bewertet Sicherheitsfragen danach, was jede Rolle darf, und liefert Tests, Dokumentation und Pull Requests im Projektformat.
Eine Smart-Contract-Bibliothek ändern, ohne die Projekte zu beschädigen, die sie erben
Für einen KI-Coding-Agenten an einer Smart-Contract-Bibliothek, die andere Projekte erben. Er ändert die Datei, die das Verhalten besitzt, folgt dem Linter, lässt Funktionen, Events und Storage-Layout unverändert und prüft riskanten Code wie Kryptografie und Upgrades selbst nach.
Eine gemeinsame Bibliothek oder ein SDK ändern, ohne die öffentliche API zu brechen
Wenn die KI eine gemeinsame Bibliothek oder ein SDK ändert. Sie führt vor der Fertigmeldung alle Tests und Builds aus, hält die öffentliche API für bestehende Nutzer stabil, fragt vor dem Wechsel von Git-Zweig oder Arbeitsverzeichnis und liefert am Ende eine Pull-Request-Übergabe.
Eine große Desktop-Medien-App ändern, ohne die UI einzufrieren oder den Rückgängig-Verlauf zu brechen
Für eine große Desktop-App mit Dateien und Medien: Die KI hält schwere Arbeit vom UI-Thread fern, deckt Abbrüche und Grenzfälle ab, hält den Rückgängig-Verlauf exakt und meldet nur die Tests, die wirklich liefen.
Eine CSS-in-JS-Bibliothek pflegen, die im Browser, auf dem Server und nativ funktioniert
Für die Arbeit eines KI-Coding-Assistenten an einer standardorientierten CSS-in-JS-Bibliothek. Erlaubt nur Standard-CSS, hält den Code in jeder Laufzeitumgebung lauffähig, schreibt Tests zuerst nach der Spezifikation und regelt Release Notes, Doku und Demos mit echtem Code.
KI FastAPI-Dienste schreiben lassen und typische Fehler im Review finden
Wenn eine KI einen FastAPI-Dienst baut oder prüft. Legt Mindestversionen fest, wann async- oder sync-Routen passen, wie Pydantic-Modelle und Abhängigkeiten geschrieben werden, wie mit Datenbank und Tests gearbeitet wird, und liefert eine Tabelle typischer Fehler im Diff mit Lösung.
In einem TypeScript-Frontend-Monorepo arbeiten, ohne Paketgrenzen zu verletzen
Für eine KI, die ein modulares TypeScript-Frontend ändert. Behandelt Paketgrenzen und einen frameworkfreien Kern, Zustandsänderungen nur über die zuständige Action, Ablage von Dateien und Tests, Prüfungen vor dem Commit, den Release-Ablauf und UI-Schichten.
Die KI in einem großen Repository erst lesen, dann ändern und nur per Review ausliefern lassen
Für KI-Agenten in einem großen Repository mit vielen Paketen. Die KI liest Code, Abhängigkeiten und Tests, bevor sie einen Fix beurteilt, nutzt für jede Sache nur einen Weg, führt nicht vertrauenswürdigen Code nie lokal aus und ändert gemeinsamen Code nur über Review und deine Freigabe.
Gemeinsame Arbeitsregeln für KI-Agenten festlegen, die ein Repository untersuchen und verbessern
Für KI-Agenten, die ein Repository selbstständig untersuchen und verbessern. Legt fest, was ins gemeinsame Gedächtnis gehört, wann vorher ein Plan nötig ist, wie Push und offengelegte Geheimnisse behandelt werden und wie Änderungen und Automatisierung vor dem Abschluss getestet werden.
Eine Plugin-Datenpipeline über zwei Laufzeitumgebungen ändern, ohne sie kaputtzumachen
Für Coding-Agenten in einem Plugin-Backend über zwei Laufzeitumgebungen. Hält Versionen in einer Datei, setzt Testfilter auf den richtigen Task, folgt den Regeln für Plugins, Nebenläufigkeit und Service-Schichten und prüft, dass jeder neue Test ohne seine Änderung fehlschlägt.
Low-Level-Debugger-Code zuerst mit Tests ändern, ohne andere Plattformen kaputt zu machen
Für eine KI, die einen Debugger einer kompilierten Sprache für viele Systeme und Backends ändert. Sie schreibt zuerst einen fehlschlagenden Test, legt OS-spezifischen Code in eigene Dateien, prüft beim Ändern gemeinsamer Schnittstellen alle Backends und beginnt Commits mit dem Subsystem.
Systemcode von der KI sorgfältig schreiben lassen, bis zu Typen und Fehlerbehandlung
Für KI-Hilfe an einer strengen Systemcodebasis. Die KI prüft ihren Code mindestens dreimal so lange, wie das Schreiben dauerte, deckt alle Fehlerfälle ab, legt Regeln in Typen fest, hält alte und neue Formate kompatibel und macht kleine Commits, die alle bauen.
Agent-Skills und Plugins schreiben, die richtig geladen werden und auslösen
Beim Erstellen eines Skills oder Plugins für einen KI-Agenten vor der Prüfung. Behandelt eine einzige Metadatenquelle, den Verzeichnisaufbau, gut auslösende Namen und Beschreibungen, schnelle Hooks und die Checkliste vor der Prüfung.
Vor einem Pull Request an ein gemeinsames Projekt prüfen, ob die Änderung wirklich nötig ist
Für einen KI-Agenten, der einen Pull Request an ein fremd betreutes Projekt senden will. Er prüft, ob das Problem wirklich auftrat, ob die Änderung ins Kernprojekt gehört und ob ein Mensch den ganzen Diff freigegeben hat.
Einen KI-Programmieragenten in einem geschichteten App-Repository beim Auftrag halten
Für ein App-Repository mit Frontend, Backend und Desktop-Paketierung, in dem eine KI programmiert. Ordnet jede Anfrage ein (Antwort, Änderung, Build, Veröffentlichung), wählt Prüfungen nach dem geänderten Teil und lässt vor Commit, Push, Release oder echten Daten nachfragen.
Code in einer streng typisierten funktionalen Codebasis ändern, ohne Fehler zu verbergen
Nutzen, wenn ein KI-Agent in einer streng typisierten funktionalen Codebasis arbeitet. Legt Regeln für Stil, Fehlertypen, Dienste, Schemata, Protokolle und UI-Komponenten fest und verlangt bestandene Typprüfung, Tests und Build, bevor die Arbeit als fertig gilt.
Ein Kommandozeilentool bauen, das keine Nutzerdaten verliert und keinen nicht freigegebenen Code ausführt
Wenn eine KI ein CLI-Tool mit echten Nutzern baut oder ändert. Sie hält Optionen und Konfiguration kompatibel, stoppt statt Arbeit zu zerstören, führt Projekt-Hooks nur nach Freigabe aus, protokolliert jeden Subprozess und zeigt Lokales vor Netzwerkdaten.
Eine große mehrsprachige Laufzeit-Codebasis ändern, ohne bisheriges Verhalten zu brechen
Für ein großes Laufzeitprojekt aus nativem Code und Skripten mit gepatchten, mitgelieferten Abhängigkeiten. Die KI liest zuerst den nächstgelegenen Leitfaden, nutzt die Build- und Test-Kurzbefehle, hält eigene Typen und Verbote ein und setzt Änderungen hinter Kompatibilitätsschalter.
Eine Indexerweiterung für Datenbanken entwickeln, die Tests besteht und Abstürze übersteht
Nutze dies, wenn eine KI eine Datenbank-Indexerweiterung baut oder ändert. Sie nimmt jeden Testfehler ernst, hält vor dem Einchecken eine feste Abfolge ein und protokolliert jede Seitenänderung, damit Wiederherstellung und Standby-Server funktionieren.
Ein bidirektionales Protokoll-SDK in einem TypeScript-Monorepo pflegen, ohne die öffentliche API zu brechen
Für Änderungen an einem typisierten SDK aus mehreren Paketen, bei dem Client und Server Anfragen senden. Wählt öffentliche Exporte bewusst, ergänzt Operationen auf beiden Seiten mit Fähigkeitsprüfung, dokumentiert inkompatible Änderungen und führt Beispiele als Tests aus.
Eine KI-Pipeline in der Sandbox betreiben, die Sicherheitslücken findet und behebt
Zum Betrieb einer autonomen Pipeline, die nicht vertrauenswürdigen Code ausführt, um echte Abstürze zu finden. Isoliert jeden Lauf in Containern, meldet Funde sofort und überlässt jeden Patch der Prüfung durch Menschen.
Backend-Code und passende Tests zu einer Anwendung mit mehreren Diensten hinzufügen
Für einen KI-Agenten, der eine Anwendung aus mehreren Diensten mit Hintergrundarbeitern ändert. Er prüft Umgebung und Dienste, legt Datenbank- und Aufgabencode richtig ab, definiert Aufgaben und Fehler nach Projektvorgaben, wählt eine passende Testart und plant vor dem Programmieren.
Anbieter- und Generator-Plugins zu einem Multi-Modul-Repository hinzufügen
Für eine KI, die in einem Multi-Modul-Repository arbeitet, das durch Anbieter und Generatoren für Secrets erweitert wird. Führt alles über die Aufgabensteuerung aus, ergänzt Erweiterungen auf dem vorgesehenen Weg und stoppt vor Push oder Release.
Eine Local-First-Desktop-App für KI-Design innerhalb ihrer festen Produktregeln ändern
Für einen KI-Programmieragenten an einer Desktop-App, die mit KI Designs in lokalen Arbeitsbereichen erstellt. Klärt, welche Anweisungsdatei gilt, die festen Regeln, wie Sitzungen, Speicher und Werkzeuge aufgebaut sind, die vier Berechtigungsstufen und was zu vermeiden ist.
Eine KI in einem großen Java-Backend an Codestil und Modulregeln halten
Für eine KI in einem großen Java-Server aus Modulen und Anbietern. Sie liest zuerst die Einstiegspunkte, hält den automatisch geprüften Codestil und die älteste unterstützte Java-Version ein, deklariert jedes genutzte Modul, prüft Aussagen im Code und testet vor dem Übertragen lokal.
Eine App bauen, die Aktivitätsereignisse aus vielen Quellen sammelt und auf mehreren Oberflächen zeigt
Für eine App, die Ereignisse vieler Werkzeuge sammelt und in einer Editor-Erweiterung und einem eigenständigen Server zeigt. Hält Schichten in einer Richtung, macht aus jeder Quelle einen Ereignistyp, nimmt neue Quellen ohne andere Änderungen auf und speichert den Zustand sicher.