5 Tipps und Tips zur Agentencodierung
Bild vom Herausgeber
Einführung
Die Agentencodierung fühlt sich nur dann „clever“ an, wenn sie korrekte Unterschiede liefert, Checks besteht und eine Papierspur hinterlässt, der Sie vertrauen können. Der schnellste Weg dorthin besteht darin, einen Agenten nicht mehr zu bitten, „eine Funktion zu erstellen“, sondern ihm einen Workflow zu geben, dem er nicht entkommen kann.
Dieser Arbeitsablauf sollte Klarheit (was sich ändert), Beweise (was passiert ist) und Eindämmung (was berührt werden kann) erzwingen. Die folgenden Tipps sind konkrete Muster, die Sie in die tägliche Arbeit mit Code-Agenten integrieren können, unabhängig davon, ob Sie einen CLI-Agenten, einen IDE-Assistenten oder ein benutzerdefiniertes Software-Verwendungsmodell verwenden.
1. Verwenden Sie eine Repo-Map, um blinde Refaktoren zu verhindern
Agenten Werden Sie generisch, wenn sie die Topologie Ihrer Codebasis nicht verstehen. Sie verwenden standardmäßig umfassende Refaktoren, da sie die richtigen Nähte nicht zuverlässig lokalisieren können. Geben Sie dem Agenten eine Repo-Map, die kurz, eigensinnig und in den wichtigen Teilen verankert ist.
Erstellen Sie eine maschinenlesbare Momentaufnahme Ihrer Projektstruktur und der wichtigsten Einstiegspunkte. Halten Sie es unter ein paar hundert Zeilen. Aktualisieren Sie es, wenn sich wichtige Ordner ändern. Geben Sie die Karte dann vor der Codierung in den Agenten ein.
Hier ist ein einfacher Generator, den Sie behalten können instruments/repo_map.py:
from pathlib import Path INCLUDE_EXT = {„.py“, „.ts“, „.tsx“, „.go“, „.java“, „.rs“} SKIP_DIRS = {„node_modules“, „.git“, „dist“, „construct“, „__pycache__“} root = Path(__file__).resolve().dad and mom(1)strains = () for p in sorted(root.rglob(„*“)): if any(half in SKIP_DIRS für Teil in p.elements): fortfahren, wenn p.is_file() und p.suffix in INCLUDE_EXT: rel = p.relative_to(root)strains.append(str(rel)) print(„n“.be a part of(strains(:600)))
|
aus pathlib Import Weg INCLUDE_EXT = {„.py“, „.ts“, „.tsx“, „.gehen“, „.Java“, „.rs“} SKIP_DIRS = {„node_modules“, „.git“, „dist“, „bauen“, „__pycache__“} Wurzel = Weg(__Datei__).lösen().Eltern(1) Linien = () für P In sortiert(Wurzel.rglob(„*“)): Wenn beliebig(Teil In SKIP_DIRS für Teil In P.Teile): weitermachen Wenn P.is_file() Und P.Suffix In INCLUDE_EXT: rel = P.relative_to(Wurzel) Linien.anhängen(str(rel)) drucken(„N“.verbinden(Linien(:600))) |
Fügen Sie einen zweiten Abschnitt hinzu, der die wirklich „heißen“ Dateien benennt, nicht alle. Beispiel:
Einstiegspunkte:
api/server.ts(HTTP-Routing)core/agent.ts(Planung + Werkzeugabrufe)core/executor.ts(Befehlsläufer)packages/ui/App.tsx(Frontend-Shell)
Wichtige Konventionen:
- Bearbeiten Sie niemals generierte Dateien in
dist/ - Alle DB-Schreibvorgänge werden durchlaufen
db/index.ts - Characteristic-Flags leben in
config/flags.ts
Dies reduziert den Suchraum des Agenten und verhindert, dass er die Hälfte des Repositorys „hilfreich“ neu schreibt, weil es verloren gegangen ist.
2. Erzwingen Sie Patch-First-Änderungen mit einem Diff-Funds
Agenten entgleisen wenn sie wie ein Mensch mit unbegrenzter Zeit bearbeiten. Zwingen Sie sie, sich wie ein disziplinierter Mitwirkender zu verhalten: Schlagen Sie einen Patch vor, halten Sie ihn klein und erklären Sie die Absicht. Ein praktischer Trick ist ein Diff-Funds, eine explizite Begrenzung der professional Iteration geänderten Zeilen.
Verwenden Sie einen Workflow wie diesen:
- Der Agent erstellt einen Plan und eine Dateiliste
- Der Agent erzeugt nur ein einheitliches Diff
- Sie wenden den Patch an
- Checks laufen
- Nächster Patch nur bei Bedarf
Wenn Sie Ihre eigene Agentenschleife erstellen, Stellen Sie sicher, dass dies mechanisch durchgesetzt wird. Beispiel einer Pseudologik:
MAX_CHANGED_LINES = 120 def count_changed_lines(unified_diff: str) -> int: return sum(1 for line in unified_diff.splitlines() if line.startswith((„+“, „-„)) and never line.startswith((„+++“, „—„))) modifications = count_changed_lines(diff) if modifications > MAX_CHANGED_LINES: elevate ValueError(f“Diff zu groß: {modified} geänderte Zeilen“)
|
MAX_CHANGED_LINES = 120 def count_changed_lines(unified_diff: str) -> int: zurückkehren Summe(1 für Linie In unified_diff.Splitlines() Wenn Linie.beginntmit((„+“, „-“)) Und nicht Linie.beginntmit((„+++“, „—“))) geändert = count_changed_lines(diff) Wenn geändert > MAX_CHANGED_LINES: erheben Wertfehler(F„Diff zu groß: {modified} geänderte Zeilen“) |
Für manuelle Arbeitsabläufe integrieren Sie die Einschränkung in Ihre Eingabeaufforderung:
- Geben Sie nur ein einheitliches Diff aus
- Hartes Restrict: insgesamt 120 geänderte Zeilen
- Keine unabhängigen Formatierungen oder Umgestaltungen
- Wenn Sie mehr benötigen, halten Sie an und fordern Sie ein zweites Pflaster an
Agenten reagieren intestine auf messbare Einschränkungen. „Halten Sie es minimal“ ist vage. „120 geänderte Zeilen“ sind durchsetzbar.
3. Wandeln Sie Anforderungen in ausführbare Abnahmetests um
Vage Anfragen können einen Agenten daran hindern, Ihre Tabelle ordnungsgemäß zu bearbeiten, geschweige denn, den richtigen Code zu erstellen. Der schnellste Weg, einen Agenten konkret zu machen, unabhängig von seinem Designmusterbesteht darin, Anforderungen vor der Implementierung in Checks zu übersetzen. Behandeln Sie Checks als einen Vertrag, den der Agent erfüllen muss, und nicht als einen Greatest-Effort-Zusatz.
Ein leichtes Muster:
- Schreiben Sie einen fehlgeschlagenen Check, der das Funktionsverhalten erfasst
- Führen Sie den Check aus, um zu bestätigen, dass er aus dem richtigen Grund fehlschlägt
- Lassen Sie den Agenten implementieren, bis der Check bestanden ist
Beispiel in Python (pytest) für einen Ratenbegrenzer:
Importzeit aus myapp.ratelimit import SlidingWindowLimiter def test_allows_n_requests_per_window(): lim = SlidingWindowLimiter(restrict=3, window_seconds=1) Assert lim.enable(„u1“) Assert lim.enable(„u1“) Assert lim.enable(„u1“) Assert not lim.enable(„u1“) time.sleep(1.05) Assert lim.enable(„u1“)
|
Import Zeit aus meineapp.Ratelimit Import SlidingWindowLimiter def test_allows_n_requests_per_window(): lim = SlidingWindowLimiter(Restrict=3, window_seconds=1) behaupten lim.erlauben(„u1“) behaupten lim.erlauben(„u1“) behaupten lim.erlauben(„u1“) behaupten nicht lim.erlauben(„u1“) Zeit.schlafen(1.05) behaupten lim.erlauben(„u1“) |
Jetzt hat der Agent ein objektives Ziel. Wenn es „denkt“, dass es erledigt ist, entscheidet der Check.
Kombinieren Sie dies mit dem Software-Suggestions: Der Agent muss die Testsuite ausführen und die Befehlsausgabe einfügen. Diese eine Anforderung tötet eine ganze Klasse sicherer, aber falscher Abschlüsse.
Immediate-Snippet, das intestine funktioniert:
- Schritt 1: Checks schreiben oder verfeinern
- Schritt 2: Checks durchführen
- Schritt 3: Implementieren, bis die Checks bestanden sind
Geben Sie immer die genauen Befehle an, die Sie ausgeführt haben, und die abschließende Testzusammenfassung.
Wenn Checks fehlschlagen, erklären Sie den Fehler in einem Absatz und führen Sie dann den Patch durch.
4. Fügen Sie einen „Rubber Duck“-Schritt hinzu, um versteckte Annahmen zu erkennen
Agenten treffen stillschweigende Annahmen über Datenformen, Zeitzonen, Fehlerbehandlung und Parallelität. Sie können diese Annahmen aufdecken mit einem erzwungenen „Rubber Duck“-Second direkt vor dem Codieren.
Bitten Sie um drei Dinge in der Reihenfolge:
- Annahmen, die der Agent trifft
- Was könnte diese Annahmen zerstören?
- Wie werden wir sie validieren?
Halten Sie es kurz und verbindlich. Beispiel:
- Vor dem Codieren: Hear Sie 5 Annahmen auf
- Für jeden: ein Validierungsschritt unter Verwendung von vorhandenem Code oder Protokollen
- Wenn eine Annahme nicht bestätigt werden kann, stellen Sie eine klärende Frage und hören Sie auf
Dadurch entsteht eine Pause, die häufig schlechte Architektur-Commits verhindert. Es bietet Ihnen auch einen einfachen Überprüfungskontrollpunkt. Wenn Sie mit einer Annahme nicht einverstanden sind, können Sie sie korrigieren, bevor der Agent Code schreibt, der sie einbettet.
Ein häufiger Erfolg besteht darin, Unstimmigkeiten bei Datenverträgen frühzeitig zu erkennen. Beispiel: Der Agent geht von einem Zeitstempel aus ISO-8601aber die API gibt Epochen-Millisekunden zurück. Das Eine Nichtübereinstimmung kann zu einer „Bugfix“-Abwanderung führen. Die Trittstufe der Quietscheente spült es heraus.
5. Machen Sie die Ausgabe des Agenten mit Laufrezepten reproduzierbar
Agentencodierung schlägt in Groups fehl wenn niemand reproduzieren kann, was der Agent getan hat. Beheben Sie das, indem Sie ein Laufrezept verlangen: die genauen Befehle und Umgebungshinweise, die zum Wiederholen des Ergebnisses erforderlich sind.
Nehmen Sie eine einfache Konvention an: Jeder Agentenlauf endet mit einem RUN.md Snippet, das Sie in eine PR-Beschreibung einfügen können. Es sollte Setup, Befehle und erwartete Ausgaben enthalten.
Vorlage:
## Rezeptumgebung ausführen: – Betriebssystem: – Laufzeit: (Node/Python/Go-Model) Befehle: 1)
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
## Rezept ausführen Umfeld: – Betriebssystem: – Laufzeit: (Knoten/Python/gehen Model) Befehle: 1) <Befehl> 2) <Befehl> Erwartet: – Checks: <Zusammenfassung> – Fussel: <Zusammenfassung> – Handbuch überprüfen: <Was Zu klicken oder Locken> Beispiel für A Knoten API ändern: ## Rezept ausführen Umfeld: – Knoten 20 Befehle: 1) npm ci 2) npm prüfen 3) npm laufen Fussel 4) Knoten Skripte/Rauch.js Erwartet: – Checks: 142 bestanden – Fussel: 0 Fehler – Rauch: „OK“ gedruckt |
Dies macht die Arbeit des Agenten portabel. Es sorgt auch dafür, dass die Autonomie ehrlich bleibt. Wenn der Agent kein sauberes Laufrezept erstellen kann, hat er die Änderung wahrscheinlich nicht validiert.
Zusammenfassung
Die Agentencodierung verbessert sich schnell, wenn Sie sie wie Technik und nicht wie Vibe behandeln. Repo-Karten stoppen blindes Wandern. Durch Patch-First-Unterschiede bleiben Änderungen überprüfbar. Ausführbare Checks verwandeln handgeschwungene Anforderungen in objektive Ziele. Ein Gummienten-Kontrollpunkt deckt verborgene Annahmen auf, bevor sie sich zu Fehlern verfestigen. Laufrezepte machen den gesamten Prozess für Teamkollegen reproduzierbar.
Diese Tips verringern nicht die Leistungsfähigkeit des Agenten. Sie schärfen es. Autonomie wird nützlich, sobald sie begrenzt, messbar und an echtes Werkzeug-Suggestions gebunden ist. Dann hört ein Agent auf, beeindruckend zu klingen, und beginnt mit der Lieferung von Arbeiten, die Sie zusammenführen können.
