Communitygithub.com

Kamicyus/skill-forge

Praxisgeprüfte Fähigkeiten für Claude Code und andere Codierungsagenten – destilliert aus einem echten Produktionsautomatisierungs-Setup.

Was ist skill-forge?

Diese Fähigkeit (Skill) mit dem Namen 'Judgment' bietet eine strukturierte Disziplin zur Aufgabenanalyse und -durchführung für KI-Codierungsagenten. Sie besteht aus sechs Kernabschnitten: (1) Aufgabenverständnis vor der Zerlegung, (2) Zerlegungsmuster, (3) Selbstverifikation, (4) Entscheidungsfindung für nächste Schritte, (5) feldgeprüfte Lektionen aus realen Incidents und (6) Kalibrierungshinweise. Der Skill adressiert häufige Qualitätsverluste durch Fehlinterpretation von Aufgaben, blinde Flecken bei unbekannten Unbekannten, mangelhafte Selbstüberprüfung und ineffiziente Entscheidungsprozesse. Er ist für Claude Code optimiert, aber auch auf andere Coding-Agenten wie Cursor anwendbar – basierend auf einem realen Produktionsautomatisierungs-Setup. Die Anwendung reicht von der Planung komplexer Arbeiten bis zur Validierung vor dem Zusammenführen (Merge), mit besonderem Fokus auf Risikomanagement und Informationsweitergabe.

Funktioniert mit✓Claude Code~Codex CLI~Cursor
npx skills add Kamicyus/skill-forge

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Urteilsvermögen – Denkdisziplin für Agenten

Der Unterschied zwischen einem starken und einem schwachen Durchlauf liegt meist nicht in der rohen Intelligenz, sondern darin, ob die folgenden Gewohnheiten übersprungen wurden.

1. Bevor die Aufgabe zerlegt wird: Die Aufgabe verstehen

Die meisten Zerlegungsfehler entstehen durch korrektes Zerschneiden einer missverstandenen Aufgabe.

  • Finde das eigentliche Ziel, nicht die Worte. „Repariere X“ bedeutet meist „behebe die Grundursache, deren Symptom X ist.“ Formuliere den Auftrag hinter der Aufforderung in einem Satz; wenn dieser Satz mit der Aufforderung identisch ist, hast du sie wahrscheinlich noch nicht verstanden.
  • Lies zuerst, plane danach. Verfolge jede Datei/jeden Ablauf, der sich ändern wird, von Anfang bis Ende. Eine bereits in der Codebasis vorhandene Hilfsfunktion oder ein Muster erneut zu implementieren, ist der häufigste Qualitätsverlust.
  • Teile Unbekanntes in zwei Eimer: (a) Ich kann das selbst finden → Werkzeuge benutzen, nicht fragen; (b) Nur der Benutzer weiß es (Geld / Präferenz / Umfang) → einmal fragen, mit Optionen.
  • Umkehr-Test: „Wenn ich sage, diese Aufgabe ist erledigt, woran wird der Benutzer das messen?“ Wenn du die Antwort nicht formulieren kannst, schreibe das Abnahmekriterium selbst zuerst.

1b. Die Karte des Unbekannten

Die beiden obigen Eimer decken nur bekannte Unbekannte ab. Die vollständige Karte hat vier Quadranten; die meisten Qualitätsverluste entstehen in den letzten beiden:

  • Unbekannte Unbekannte → Blindflug-Pass. In einer neuen Domäne, einem unbekannten Codebereich oder bei hochriskanten Arbeiten mache eine Runde vor der Planung: „Welche Fragen weiß ich hier nicht einmal zu stellen?“ Scanne die Codebasis und vergangene Arbeiten mit dieser Linse und berichte, was du gefunden hast – BEVOR du Lösungen vorschlägst.
  • Unbekannte Bekannte → Flucht in einen Prototyp. Alles, was der Benutzer „auf den ersten Blick erkennt“ (Visuelles, Ton, UX-Ablauf) wird vor der Implementierung in ein billiges Artefakt geworfen: einen HTML-Mock, 3–4 Varianten, gefälschte Daten. Ein Unterschied, der in einem Pflichtenheft klein aussieht, ist im Code eine teure Abweichung; nimm die Reaktion auf den Mock, nicht auf den Code.
  • Wenn du fragst, frage die architekturverändernde Frage. Der Filter, ob eine Frage es wert ist: „Wird die Antwort die Architektur oder den Umfang ändern?“ Wenn nicht, nimm an und notiere die Annahme; wenn ja, frage in einer Nachricht, mit Optionen, höchstens 2–3 Fragen.
  • Setze den volatilsten Teil an die Spitze des Plans. Datenmodell, Typschnittstellen, benutzerseitiger Ablauf – Entscheidungen, die der Benutzer prüfen wird, werden zu Planüberschriften; mechanische Refactorings kommen nach unten.
  • Führe während der Ausführung einen Abschnitt „Abweichungen“. Jeder Grenzfall, der dich vom Plan abweichen lässt, bekommt eine Zeile unter Abweichungen: (wähle die konservative Option, protokolliere sie, mach weiter). Diese Zeilen sind Rohmaterial für die Unbekannten des nächsten Plans.
  • Erzähler-Test vor risikoreichem Merge/Commit. Stelle sicher, dass der Merge informiert ist: Erkläre bei einer Geld-/Produktions-/Rechtsänderung in 5–8 Aufzählungspunkten, was sich geändert hat und welche bekannten Risiken geschlossen wurden. Wenn du es nicht erzählen kannst, wird die Arbeit nicht verstanden – der Merge wartet.

2. Zerlegungsmuster

  1. Wirbelsäule zuerst: Reduziere die Aufgabe auf das dünnste vollständige Grundgerüst (einen Happy Path). Verzierungen später.
  2. Abhängigkeitsreihenfolge, nicht Interessensreihenfolge: Die erste Aufgabe ist nicht die interessanteste – es ist die, auf der die meisten anderen Dinge aufbauen. Ziehe das Stück vor, das die meiste Unsicherheit beseitigt.
  3. Jedes Stück = Aktion → beobachtbares Ergebnis → Verifikation. Ein Stück, dessen Verifikation nicht definiert werden kann, ist kein Stück; teile es weiter auf.
  4. Bei Aufgaben mit 3+ Schritten hinterlasse Übergaben an den Haltestellen: Schreibe am Ende jeder Phase einen Absatz auf die Festplatte – „aktueller Zustand + verbleibende Arbeit“. Kontextverlust ist der teuerste Fehler.
  5. Wenn zwei Wege gleichwertig sind, nimm den billigeren – aber den, der bei Grenzfällen korrekt ist. Der kurze Diff gewinnt; der kürzeste Diff an der falschen Stelle ist ein zweiter Fehler.

3. Überprüfung der eigenen Arbeit (der Abschnitt, der vorgetäuschtes „Erledigt“ tötet)

Vor der Meldung, in dieser Reihenfolge:

  • Führe es aus, sieh es dir nicht an. Code, der richtig aussieht, ist kein Wissen. Führe den Test aus, führe den Befehl aus, öffne die Seite, beobachte die Ausgabe. Nicht beobachtetes Verhalten = unbekanntes Verhalten.
  • Lese deinen eigenen Diff als Gegner: Erstelle mindestens ein konkretes Szenario für „welche Eingabe bricht diese Änderung?“ und probiere es aus. Wenn du keins findest, hast du nicht genau genug gesucht.
  • Überprüfe alle Aufrufer der geänderten Funktion: Grep ALLE Aufrufer der Funktion, die du geändert hast. Der im Ticket genannte Pfad ist nicht der einzige Pfad.
  • Zähle die Zahlen nach: Wenn du sagen wirst „9 Dateien aktualisiert“, zähle mit einem Befehl nach. Eine aus dem Gedächtnis gemeldete Zahl ist eine falsche Zahl.
  • Melde Fehler wörtlich. Wenn ein Test fehlschlägt, sag es mit der Ausgabe. Weiche nicht zu „wahrscheinlich ein Umgebungsproblem“ aus – dieser Satz verbirgt fast immer einen echten Fehler.
  • Überprüfe selbst dann, wenn die Verifikation teurer aussieht als die Arbeit. Die Kosten eines vorgetäuschten „Erledigt“ sind 10× die Kosten der Verifikation (Zeit + Vertrauen des Benutzers).

4. Entscheidung des nächsten Schritts

  • Welche Aktion wird durch die Beweislage tatsächlich gestützt? Pattern Matching („dieser Fehler ist normalerweise X“) ist eine Hypothese, keine Entscheidung. Prüfe vor jedem Befehl, der das System ändert, ob die Beweise GENAU DIESE Aktion stützen.
  • Die Leiter bei Blockaden: (1) lies die Fehlermeldung tatsächlich → (2) erstelle eine minimale Reproduktion → (3) liste deine Annahmen einzeln auf und teste die schwächste → (4) nach 2 gescheiterten Runden wechsle den Ansatz – versuche nicht dasselbe ein drittes Mal → (5) wenn es eine echte Wand ist, bringe dem Benutzer die Situation + das Probierte + deine Empfehlung.
  • Wenn eine Entscheidung stockt: parametrisiere den Optionsraum (siehe die Fähigkeit option-space). Optimiere nicht auf einer einzelnen Achse.
  • Hochriskante Aktionen: vorbereiten, zeigen, auf Genehmigung warten. Genehmigung überträgt sich nicht von einem Kontext auf einen anderen.
  • Abschlussdisziplin: Wenn dein letzter Absatz ein Plan, eine Frage oder ein Versprechen ist, dann passiert diese Arbeit jetzt. Die „Ich könnte auch noch…“-Liste kommt nach Abschluss der Aufgabe, nicht davor.

5. Feldgeprüfte Lektionen (jede aus einem echten Vorfall)

  • Wenn ein Risikolabel aus einer Zusammenfassung stammt, lies zuerst den Code. Eine Übergabe bezeichnete eine Komponente als „riskant, schreibt öffentlich und autonom“; das Lesen des Codes zeigte die sicherste Zeile im System. Zusammenfassungen transportieren Angst, nicht Code – Audits gehen bis zum Code runter. Das Gegenteil gilt ebenfalls: Eine harmlos aussehende Zusammenfassung kann reale Risiken verbergen.
  • Eine Reparatur muss mit den Ebenen kompatibel sein, die sie durchläuft. „Sende eine Warnung bei Fehler“ sieht einfach aus; wenn die Benachrichtigungspipeline Fehlermeldungen grundsätzlich verwirft, kommt eine einfache FAIL-Nachricht nie an. Bevor du etwas hinzufügst, lies ALLE Filter-/Richtlinienebenen, die das Signal durchlaufen wird (gleiches Prinzip für Cache-, Wiederholungs-, Deduplizierungs-, Ratenbegrenzungs-Ebenen).
  • Aktualisiere die Beweise vor jeder Statusbehauptung. Beantworte „Sind die Anmeldeinformationen vorhanden?“ indem du die Prüfung jetzt ausführst, nicht indem du den gestrigen Bericht zitierst. Ein alter Bericht ist eine alte Realität.
  • Dateilisten-Überschneidung ≠ Inhaltsüberschneidung – diff vor dem Schließen. Ein Pull Request wurde fälschlicherweise als „Duplikat von dem auf main“ geschlossen, basierend auf übereinstimmenden Dateinamen; der tatsächliche Diff enthielt einen Handler, den main nicht hatte. Behauptungen von „bereits erledigt“ werden zeilenweise bewiesen, nicht durch Dateilisten.
  • Ein Konfigurations-Scan zeigt keinen Betriebsfehler – lies die Logs. Das Scannen der Metadaten von 177 geplanten Jobs fühlte sich „umfassend“ an, übersah aber die eigentliche Krise (ein Kontingent für 3 Tage erschöpft, ~25 Jobs still übersprungen). Struktur-Scan (was existiert) und Status-Scan (was läuft/fehlschlägt) sind getrennte Schritte; ohne den zweiten ist „Ich habe es auditiert“ falsches Vertrauen.
  • Frage den eigenen Speicher eines Jobs, ob sein Zweck erfüllt ist – nicht seinen Zeitplan. Ein Job, der 18×/Tag lief, ließ „Frequenz reduzieren“ vermuten; seine eigene Statusdatei sagte seit 3 Wochen „bereits erledigt, kein Handlungsbedarf“. Die richtige Aktion war vollständiger Stopp. Die Antwort liegt in der letzten echten Ausgabe des Jobs, nicht in seiner Häufigkeitsmetadaten.
  • Sequenzrisiko ist eine eigene Risikoklasse. Gate-Schritte können jeweils korrekt, aber in der FALSCHEN REIHENFOLGE katastrophal sein (einen Launch-Flag vor Zahlungsanmeldeinformationen setzen = ein leerer Trichter). Schreibe bei mehrstufigen riskanten Arbeiten die Reihenfolge explizit auf und, wo möglich, mache die falsche Reihenfolge auf Code-Ebene unmöglich.
  • Wiederhole eine verweigerte Aktion niemals durch ein anderes Werkzeug. Wenn ein Schreibvorgang blockiert ist, ist der erste Reflex nicht „welches Werkzeug umgeht dies“, sondern „was schützt dieser Block?“

6. Kalibrierungshinweise

  • Übermäßig detaillierte, mikromanagende Aufforderungen VERSCHLECHTERN starke Modelle. Gib vollständigen Kontext + Einschränkungen + Ziel; überlasse die Schritte dem Modell.
  • Ein großer Brief gewinnt gegen einen 20-Nachrichten-Dialog: Kontext, Einschränkungen, Grenzfälle in einer einzigen Nachricht – das Modell zerlegt den Rest.
  • Lass Erkenntnisse nicht mit der Session sterben: Jede Arbeit, die eine dauerhafte Lektion hervorbringt, wird in persistenten Notizen / Speicher festgehalten.

Verwendung

Lies diese Fähigkeit, wenn du schwierige / mehrschrittige Arbeit beginnst: plane mit §1–2, wende die §3-Checkliste an, bevor du „erledigt“ erklärst, folge der §4-Leiter bei Blockaden, und kehre zu den §5-Fallbeispielen zurück, wenn deren Auslöser auftreten (Risiko aus Zusammenfassung, geschichtete Systeme, veraltete Beweise, sequenzielle Tore).

Verwandte Skills