scieneers
  • Story
  • Leistungen
    • Leistungen allgemein
    • KI für die Energiewirtschaft
    • Große Sprachmodelle für Ihre Daten
    • Erweiterbare AI-Chat-Basis
    • Azure über CSP beziehen
    • Microsoft Fabric Data Platforms
    • Social Impact @ scieneers
  • Workshops
    • Datenprodukt-Strategie Workshop
    • Microsoft Data Strategy & Analytics Assessment
    • Azure Data Platform Proof of Concept
    • Retrieval-Augmented Generation
    • Microsoft Fabric: „Bring Your Own Data“ Workshop
    • Power BI Training
    • Fabric Analyst in a Day
  • Content
  • Team
  • Join
  • Kontakt
  • DE
  • EN
  • Menü Menü

KI-Agenten · Software Engineering

Mehr Autonomie, klare Grenzen: Coding-Agenten in der Praxis

Milan Petrovic · Data Engineer · ca. 9 Min. Lesezeit

Auf einen Blick

  • Agenten schreiben Code schneller, als Entwickler:innen ihn prüfen können. Damit ein Coding-Agent trotzdem längere Zeit autonom arbeiten kann, braucht er einen festen Rahmen, der prüft, was er tut. In unserer Praxis besteht dieser Rahmen aus Skills, Hooks, lokalen Checks, einer Vorlage für Pull Requests und einer Plan-Datei pro Thema.
  • Entwickler:in und Agent planen zuerst gemeinsam. Nach einem „Go“ bringt der Agent einen inkrementellen Planschritt allein bis zum Draft-PR. Er baut und testet, pflegt die Dokumentation, lässt zwei unabhängige Reviews laufen, committet und pusht.
  • Ein Hook prüft jeden Befehl des Agenten, bevor er ausgeführt wird. Was sich nicht rückgängig machen lässt, braucht die Zustimmung der Entwickler:innen oder ist gesperrt. Wo eine Prüfung genügt, ersetzt sie die Rückfrage: Pushen darf der Agent selbstständig, sobald alle lokalen Tests und Prüfungen für genau diesen Code-Stand bestanden sind.
  • Wiederkehrende Anweisungen und Regeln werden an einer oder mehreren festen Stellen hinterlegt: in der AGENTS.md, in Skills, in Hooks oder in den Settings.

Inhalt

  1. Zwischen Autonomie und Kontrolle
  2. Gemeinsam planen, selbstständig umsetzen
  3. Anweisungen und Regeln
  4. Skills
  5. Prüfen und absichern
  6. Fazit

Zwischen Autonomie und Kontrolle

Coding-Agenten gehören inzwischen für viele Teams zum Alltag. Sie lesen ein Repository selbst, führen Befehle aus, schreiben Tests und öffnen Pull Requests. Lange waren Entwickler:innen dabei „in the loop“ und haben jeden Befehl des Agenten einzeln bestätigt. Der Trend geht jedoch klar dahin, dem Agenten mehr Autonomie zu gewähren. So ist in Claude Code seit August 2026 ein Classifier der Standard, der riskante Aktionen selbst bewertet. Laut einem Anthropic-Beitrag von 2026 bestätigen Nutzer:innen 97 % aller Permission-Prompts1, also der Rückfragen, ob der Agent etwas ausführen darf. Im selben Beitrag wird ein Versuch beschrieben: Von 1053 Testpersonen erkannten nur 13,6 % einen gefährlichen Befehl, während der Classifier 89 % derselben Befehle blockierte. Die Studie stammt zwar von Anthropic selbst, aber wer schon einmal eine Stunde lang mit einem Coding-Agenten gearbeitet hat, kennt das: Irgendwann liest man die Rückfragen nicht mehr genau und klickt reflexhaft auf „Ja“.

Das Bestätigen einzelner Befehle ist aber nur die eine Seite der Medaille. Am Ende muss jemand auch den vom Agenten geschriebenen Code prüfen. Bei dem Tempo, das Coding-Agenten vorlegen, kommt man damit kaum noch hinterher. In der Tat ist der messbare Gewinn durch KI-Agenten bisher kleiner als angenommen. Als Microsoft Anfang 2026 Claude Code und GitHub Copilot CLI einführte, mergten Entwickler:innen, die diese Tools nutzten, rund 24 % mehr Pull Requests2. Obwohl das einem ordentlichen Produktivitätszuwachs entspricht, ist es noch weit entfernt vom Faktor zwei bis zehn, von dem in sozialen Medien häufig die Rede ist. Ein wichtiger Grund dafür ist das Review. Der Agent schreibt den Code zwar schneller, geprüft werden muss er aber weiterhin. In einem Unternehmen, das die Zahl seiner Pull Requests mit KI verdoppeln wollte, hat sich auch die Last pro Reviewer:in verdoppelt3. Der Engpass liegt somit beim Prüfen.

Die Zahlen im Überblick

97 %

aller Permission-Prompts werden von Nutzer:innen bestätigt

Quelle: Anthropic [1]

Gefährliche Befehle erkannt

Testpersonen13,6 %
Classifier89 %

Versuch mit 1053 Testpersonen · Quelle: Anthropic [1]

+24 %

mehr gemergte Pull Requests nach Einführung von Claude Code und GitHub Copilot CLI bei Microsoft

Quelle: Microsoft [2]

2×

so viel Review-Last pro Reviewer:in, als ein Unternehmen seine Pull Requests mit KI verdoppeln wollte

Quelle: He et al. [3]

Um dem zu begegnen, kann ein strikter Rahmen gebaut werden, in dem der Coding-Agent seine Arbeit selbst testen kann, aber auch von anderen unabhängigen Agenten überprüft wird. Entwickler:innen müssen nicht mehr jede Zeile selbst lesen. Wie genau sie hinschauen, hängt dabei vom Risiko einer Änderung ab. Das Claude-Code-Team bei Anthropic z. B. arbeitet ähnlich: Je nach Risiko braucht ein Pull Request dort kein menschliches Approval, eines oder zwei4.

Basierend auf unserer Praxiserfahrung beschreiben wir hier ein Beispiel-Setup. Unsere Beispiele wurden mit Claude Code getestet, die Ideen lassen sich aber auch auf Codex, Cursor und andere Tools übertragen. Dabei muss das Setup natürlich an den jeweiligen Projektkontext angepasst werden.

Gemeinsam planen, selbstständig umsetzen

Interaktiver Ablauf · Schritt anklicken für Details

Ablauf in zwei Phasen: In Phase 1 durchlaufen Entwickler:in und Agent gemeinsam Brainstorming, Recherche, Entwürfe, Entscheidung und Plan. Nach dem Go setzt der Agent in Phase 2 selbstständig um: Bauen, Doku, zwei Reviews, Checks und Draft-PR. Entwickler:innen testen, prüfen den Draft-PR und geben ihn ins Team-Review.

← Grafik seitlich wischen →

Abbildung 1: Ein Ablauf in zwei Phasen. In der ersten sind Entwickler:innen eng eingebunden, in der zweiten arbeitet der Agent weitgehend selbstständig. Entwickler:innen steigen an drei Stellen ein: beim Go, beim Testen und bei der Prüfung des Draft-PR.

Die Arbeit an einem Feature oder einer größeren Aufgabe verläuft in zwei Phasen. In beiden arbeiten Entwickler:in und Agent zusammen. Es ändert sich nur, wie stark Entwickler:innen eingebunden sind. In die erste Phase stecken Entwickler:innen bewusst viel Zeit und Einsatz, in die zweite möglichst wenig.

Phase 1: Gemeinsam entscheiden. Entwickler:innen sind eng eingebunden. Die Schleifen sind kurz: Prompt, Antwort, Entscheidung. Am Anfang steht ein Brainstorming mit dem Agenten. Er recherchiert, schlägt Lösungswege vor und macht Optionen greifbar, je nach Aufgabe als Architekturskizze, Datenmodell, kleinen Prototyp auf Beispieldaten oder klickbares Mockup. Bei einem RAG-System kann das zum Beispiel ein Vergleich verschiedener Chunking- und Retrieval-Varianten sein, bei einer Datenpipeline ein Entwurf von Schema und Datenfluss. Offene Entscheidungen bekommen Entwickler:innen einzeln vorgelegt, nummeriert und mit einer Empfehlung. Hier liegt die eigentliche Arbeit der Entwickler:innen: Was soll das System leisten, woran messen wir, ob es funktioniert, und was lassen wir weg? Daraus entsteht ein Plan als Markdown-Datei. Er enthält das Ziel, die Schritte (je ein Pull Request), die Kriterien, wann ein Schritt fertig ist, und ein Log aller Entscheidungen samt Begründung. Die Phase endet, wenn alle wichtigen Entscheidungen im Plan stehen.

Phase 2: Selbstständig umsetzen. Geben Entwickler:innen für einen Planschritt das „Go“, setzt der Agent ihn ohne weitere Rückfragen bis zum Draft-PR um. Kleine Entscheidungen trifft er selbst und protokolliert sie. Taucht eine Frage auf, die den Plan ändern würde, hält er an, und es geht zurück in die erste Phase. Ist der Planschritt gebaut, probieren Entwickler:innen das Ergebnis selbst aus, bevor die Reviews laufen, meistens am laufenden System, also in der Anwendung, in den Daten, im Dashboard oder in den Ergebnissen der Evaluation, und seltener im Diff. Sie geben dem Agenten Feedback, bis das Ergebnis passt. Den fertigen Draft-PR prüfen sie auf einer höheren Ebene: Passt das Ergebnis zum Plan, stimmen die Entscheidungen, die der Agent unterwegs getroffen hat, und was haben die Reviews gefunden? Erst dann geben sie ihn für das Review im Team frei. Dort braucht jeder Pull Request wie bisher ein Approval. Dieses Review geht deutlich schneller, weil der Pull Request seine Belege mitbringt: bestandene Checks, die Befunde der Reviews und eine Beschreibung, was der Agent und was die Entwickler:innen geprüft haben. Auch Reviewer:innen lassen sich dabei von ihren eigenen Agenten unterstützen.

Anweisungen und Regeln

Interaktive Grafik · Baustein anklicken für Details

Zwei Arten von Regeln. Links: Der Agent hält sich daran, fast immer, aber ohne Garantie: Instruktionsdatei, Doku und Plan, Skills sowie Checks und Reviews. Rechts: Das System setzt es durch, jedes Mal, egal was der Agent tut: Hooks sowie Branch Protection und CI. Je mehr das System durchsetzt, desto weniger müssen Entwickler:innen selbst überwachen.

← Grafik seitlich wischen →

Abbildung 2: Zwei Arten von Regeln. An Instruktionsdatei, Doku, Plan, Skills sowie Checks und Reviews hält sich der Agent. Hooks, Branch Protection und CI setzt das System durch.

Die Regeln für den Coding-Agenten fallen in zwei Gruppen. Die erste Gruppe sind Anweisungen, die vom Agenten befolgt werden sollen. Meistens hält sich der Agent daran, er kann sie aber auch abwägen oder sogar vergessen. Daher ist es wichtig, eine zweite Gruppe zu definieren, die das System durchsetzt, unabhängig davon, was der Agent vorhat: Hooks, also kleine Skripte, die vor jeder Aktion des Agenten automatisch laufen, sowie Branch Protection und CI auf der Code-Plattform. Was immer garantiert sein muss, gehört in die zweite Gruppe. So empfiehlt es auch die Doku von Claude Code5: „If something has to happen every time, make it a hook, a deny rule, or a managed setting.“

Die Instruktionsdatei (AGENTS.md, CLAUDE.md) halten wir generell eher kurz. Sie sollte nur enthalten, was nicht direkt aus dem Code ersichtlich ist, also Befehle, Stolperfallen und Absprachen im Team. Instruktionsdateien erhöhen die Erfolgsquote laut einer Studie der ETH Zürich im Allgemeinen nicht, wohl aber die Kosten6. Wichtiger ist eine gute Dokumentation. Sie beschreibt, wie das System heute funktioniert. Warum es so gebaut ist, halten Architecture Decision Records (ADRs) fest: kurze Dokumente zu je einer Entscheidung, die sich schwer rückgängig machen lässt, mit Kontext und verworfenen Alternativen. Dazu gehören auch fachliche Entscheidungen, etwa was das System bewusst nicht kann. Ein Glossar legt fest, was Fachbegriffe im Projekt bedeuten. Eine Übersicht nennt für jedes Dokument das Thema. So liest der Agent nur, was er für die Aufgabe braucht. Ändert sich der Code, aktualisiert er die Dokumentation im selben Pull Request. Entscheidungen aus dem Plan, die dauerhaft gelten, schlägt der Agent beim Abschluss eines Schritts als ADR vor.

Ein Plan umfasst meist mehrere Schritte, und jeder Schritt bekommt eine eigene Session. Ein frischer, fokussierter Kontext liefert laut der Claude-Code-Doku5 bessere Ergebnisse und kostet weniger. Am Ende einer Session schreibt der Agent den Stand in den Plan. Die nächste Session liest ihn dort und gleicht ihn mit dem tatsächlichen Stand im Repository ab, bevor sie weitermacht.

Skills

Skills sind gespeicherte Prompts, die der Agent bei Bedarf selbst laden kann, z. B. in Claude Code als Markdown-Datei mit eigenem Slash-Command. Es ist hilfreich, zunächst die eigene Prompt-Historie zu analysieren und alles, was dem Agenten immer wieder als Ablauf mit mehreren Schritten erklärt wird (z. B. die Review-Checkliste), in Skills zusammenzufassen. Sie beschreiben Abläufe und kaum Programmierwissen, denn das bringt das LLM selbst mit. Aufgerufen werden sollten Skills trotzdem per Namen, weil Coding-Agenten den passenden Skill oft nicht ganz zuverlässig von selbst verwenden.

Unsere Skills · nach Bereich filtern

11 Skill-Gruppen angezeigt

BereichSkillWas er macht
Plan/plan-interview (nur Entwickler:innen)Der Agent stellt in kleinen Runden Fragen zum Plan, jeweils mit Empfehlung, bis alles entschieden ist.
Plan/resume-planStartet eine Session aus dem Plan und gleicht dessen Stand mit Git und GitHub ab.
Bauen/worktreeStartet, parkt oder beendet ein Thema in einem eigenen Worktree.
Bauen/diagnoseReproduziert einen Bug zuerst mit einem Befehl, prüft dann Hypothesen der Reihe nach und behebt ihn.
Prüfen/verifySucht die passenden Checks für die Änderung aus und meldet „verified“ nur mit Beleg.
Prüfen/fresh-reviewZwei Review-Agenten mit frischem Kontext: einer sucht Bugs, einer prüft gegen Plan und Projektstandards.
Abschließen/shipDoku, Review, Checks, Commit, Push und Draft-PR mit einem Befehl.
Abschließen/restackRebased gestapelte Pull Requests, sobald einer davon gemergt wurde.
Übergabe/handoffSchreibt den Stand in den Plan und räumt auf, was die Session gestartet hat.
Doku/record-docs, /record-pr (nur Entwickler:innen), /record-experiment (nur Entwickler:innen)Aktualisiert Doku und Architekturentscheidungen, schreibt PR-Beschreibungen nach Teamvorlage und dokumentiert Experimente.
Rechte/allow-writes, /approve (nur Entwickler:innen)Öffnet befristet Schreibrechte auf eine Umgebung oder gibt einen einzelnen geblockten Befehl frei.

Skills können andere Skills aufrufen. So startet /ship nacheinander /record-docs, /fresh-review und /verify, und aus kleineren Schritten wird eine Pipeline. Einige Skills sollten nur Entwickler:innen starten dürfen, etwa bei Entscheidungen zu Schreibrechten, Freigaben und beim Interview, mit dem ein Plan festgelegt wird. In Claude Code lässt sich das pro Skill einstellen, der Agent kann sie dann nicht selbst starten.

/ship → /record-docs → /fresh-review → /verify

Skill-Pakete oder eigene Skills?

Skill-Sammlungen gehören zu den beliebtesten Repos auf GitHub. Wie viel sie in der Softwareentwicklung bringen, ist aber noch offen. Im Benchmark SWE-Skills-Bench hatten 92 von 98 öffentlichen Skills keinen statistisch signifikanten Effekt7, die durchschnittliche Erfolgsquote stieg von 76,6 % auf 76,9 %. Einzelne Skills haben deutlich geholfen, andere ebenso deutlich geschadet. Große Skill-Bibliotheken sollte man deshalb vor dem Einsatz prüfen und an das eigene Projekt anpassen.

92 ohne signifikanten Effekt6 mit signifikantem Effekt (positiv oder negativ)

Skills helfen dort, wo dem LLM Wissen fehlt, etwa bei Projektwissen, eigenen Konventionen und Abläufen, die sich im Team ständig wiederholen. Sie sollten aber regelmäßig überprüft werden, denn mit jeder Modellgeneration wird ein Teil der Anweisungen überflüssig. In den Best Practices von Claude Code gibt es z. B. dafür einen eigenen Abschnitt „What you can stop doing“5.

Prüfen und absichern

Der Agent muss belegen, dass seine Änderungen funktionieren und die Kriterien aus dem Plan erfüllen. Dafür führt er die Checks aus, die dort festgelegt sind, vom Linter über Tests und einen Browser-Check der Oberfläche bis zur Evaluation gegen einen festen Testdatensatz. Danach prüfen zwei weitere Agenten die Änderung mit frischem Kontext, einer auf Bugs, der andere gegen Plan und Projektstandards. Findet sich etwas, behebt der Agent es, und die Reviews laufen erneut, bis zu dreimal. Das ist wichtig, da LLMs eigene Ergebnisse zu gut bewerten. In einer Studie markierten sie nicht erfüllte Kriterien um mehr als 50 % häufiger8 als erfüllt, wenn die Antwort von ihnen selbst stammte. Ein Review-Agent mit frischem Kontext urteilt unabhängiger, weil er die Überlegungen des Autors nicht kennt.

Die kritischsten Schritte werden durch Hooks abgesichert, die z. B. vor jedem Shell-Befehl laufen. Sie sollten immer da zum Einsatz kommen, wo irreversible Fehler vom Agenten gemacht werden könnten. Lesende Befehle und lokale Änderungen, die sich rückgängig machen lassen, laufen deshalb eher durch, Schreibzugriffe auf Cloud-Umgebungen brauchen eine Zustimmung, und Deployments, Merges und Änderungen an Rechten sind gesperrt. Hooks erkennen Befehle an Mustern und sind keine vollständige Sicherheitsgrenze. Was der Agent auf keinen Fall darf, sollte er deshalb auch technisch nicht können, etwa durch fehlende Rechte oder Branch Protection.

Hook-Simulator · Befehl anklicken

Welche Befehle des Agenten lässt der Hook durch? Wählen Sie einen Beispielbefehl.

agent $ Noch kein Befehl gewählt

  • Läuft durch
  • Braucht Zustimmung
  • Gesperrt

Vereinfachtes Beispiel. Hooks erkennen Befehle an Mustern und sind keine vollständige Sicherheitsgrenze.

Wo eine Prüfung genügt, ersetzt sie die Rückfrage. Pushen und einen Draft-PR öffnen darf der Agent ohne Zustimmung, sobald alle lokalen Tests und Prüfungen für genau diesen Code-Stand bestanden sind. Den Nachweis schreibt ein Skript, das die Checks ausführt, unter einem Hash des geprüften Code-Stands. Der Hook lässt den Push nur durch, wenn der Hash passt, und nur das Skript darf Nachweise schreiben.

Push-Nachweis · selbst ausprobieren

Aktueller Code-Stand–
Nachweis der Checkskeiner

Probieren Sie die Schritte in beliebiger Reihenfolge aus, z. B. erst Checks, dann noch einmal den Code ändern und pushen.

Für die Beschreibung des Pull Requests gibt es eine feste Vorlage. Sie richtet sich an Reviewer:innen und deren Agenten und zeigt auf, was vom Agenten und was von Entwickler:innen selbst geprüft wurde.

Fazit

Ein Coding-Agent kann über längere Strecken selbstständig arbeiten, wenn seine Arbeit an mehreren Stellen geprüft wird und alles, was sich nicht rückgängig machen lässt, technisch abgesichert ist. Der Durchsatz steigt dadurch deutlich, vor allem weil mehrere Agenten in eigenen Worktrees parallel arbeiten können und das Review im Team schneller geht. Eine einzelne Änderung dauert dafür länger, weil Reviews, Checks und Doku Zeit brauchen, und fertig ist das Setup nie. Mit jeder Modellgeneration müssen Skills und Regeln überprüft und angepasst werden. Die konkreten Skills sehen in jedem Projekt anders aus, die Prinzipien dahinter lassen sich jedoch übertragen.

Quellen

  1. Anthropic: Auto mode is now the default in Claude Code for Pro, Max, Ultra, and Team plans, August 2026, aktualisiert Oktober 2026.
  2. Murphy-Hill, Butler, Savelieva (Microsoft): Adoption and Impact of Command-Line AI Coding Agents: A Study of Microsoft's Early 2026 Rollout of Claude Code and GitHub Copilot CLI, arXiv, Juli 2026.
  3. He et al.: AI Writes Faster Than Humans Can Review, arXiv, November 2026.
  4. Osmani, Westlee Lunt, Wang (Anthropic): How the Claude Code team does code review, Oktober 2026.
  5. Anthropic: Best practices for Claude Code, Dokumentation, abgerufen am 14. November 2026.
  6. Gloaguen et al. (ETH Zürich): Evaluating AGENTS.md, arXiv, September 2026.
  7. Han et al.: SWE-Skills-Bench: Do Agent Skills Actually Help in Real-World Software Engineering?, arXiv, Oktober 2026.
  8. Pombal, Rei, Martins: Self-Preference Bias in Rubric-Based Evaluation of Large Language Models, arXiv, April 2026.
MPPorträt von Milan Petrovic

Über den Autor

Milan Petrovic

Data Engineer bei scieneers GmbH

milan.petrovic@scieneers.de

© Copyright scieneers – Impressum | Datenschutz
Nach oben scrollen Nach oben scrollen Nach oben scrollen