Option
HeimHeim Skill Produktivität und Workflow doubt-driven-development

doubt-driven-development

addyosmani/agent-skills addyosmani/agent-skills

Jede nicht-triviale Entscheidung wird einer adversarischen Überprüfung in einem neuen Kontext unterzogen, bevor sie endgültig getroffen wird, wobei bei Code mit hohem Risiko oder unbekanntem Code die Korrektheit Vorrang vor der Geschwindigkeit hat.

...Alle erweitern
9
Zeit aktualisiert 3. September 2026

Wenn Sie im Begriff sind, unter Unsicherheit eine architektonische Entscheidung zu treffen
  • Wenn Sie im Begriff sind, nicht-trivialen Code zu committen
  • Wenn Sie im Begriff sind, eine nicht offensichtliche Behauptung aufzustellen („das ist sicher“, „das ist skalierbar“, „das entspricht der Spezifikation“)
  • Wenn Sie an Code arbeiten, den Sie nicht vollständig verstehen
  • Wann man es NICHT verwenden sollte:

    • Mechanische Vorgänge (Umbenennen, Formatieren, Verschieben von Dateien)
    • Befolgung einer klaren, eindeutigen Anweisung des Benutzers
    • Vorhandenen Code lesen oder zusammenfassen
    • Einzeilige Änderungen, deren Richtigkeit offensichtlich ist
    • Reine Tool-Operationen (Tests ausführen, Dateien auflisten)
    • Der Benutzer hat ausdrücklich Geschwindigkeit vor Überprüfung gefordert

    Wenn man jeden Tastenanschlag anzweifelt, bringt man nichts auf den Markt. Diese Fertigkeit gilt nur für nicht-triviale Entscheidungen, wie sie oben definiert wurden.

    Ladeeinschränkungen

    Diese Fähigkeit ist für den Koordinator der Hauptsitzung konzipiert, wobei Schritt 3 (ZWEIFEL, siehe unten) einen Prüfer mit neuem Kontext hervorbringen kann.

    • Fügen Sie diese Fähigkeit NICHT zu den Fähigkeiten einer Persona hinzu : frontmatter. Eine Persona, die Schritt 3 befolgt, würde eine weitere Persona erstellen – das Orchestrierungs-Anti-Muster, das in references/orchestration-patterns.md ausdrücklich verboten ist („Personas rufen keine anderen Personas auf“).
    • Sollten Sie diese Fähigkeit aus dem Kontext eines Unteragenten heraus anwenden (wo der Claude-Code das Erzeugen verschachtelter Unteragenten verhindert): Der bevorzugte Weg ist, dem Nutzer deutlich zu machen, dass „doubt-driven“ nicht verschachtelt ausgeführt werden kann, und die Hauptsitzung damit umgehen zu lassen. Nur als letzter Ausweg gibt es einen eingeschränkten Fallback mit Selbstbefragung – schreibe ARTIFACT + CONTRACT als neue Selbstabfrage um, wobei du eine klare mentale Trennung von deiner vorherigen Argumentation vornimmst, und gehe die Schritte 1–5 durch. Dies ist keine Überprüfung in einem neuen Kontext (Sie nehmen Ihren eigenen Kontext mit), kennzeichnen Sie das Ergebnis daher als „eingeschränkt“ und bevorzugen Sie eine Eskalation, sobald der Nutzer erreichbar ist.

    Der Prozess

    Kopieren Sie diese Checkliste, wenn Sie die Fertigkeit anwenden:

    Zweifel-Zyklus:
    - [ ] Schritt 1: BEHAUPTUNG — Behauptung formuliert + Begründung, warum sie wichtig ist
    - [ ] Schritt 2: EXTRAKT — Artefakt + Vertrag isoliert, Argumentation entfernt
    - [ ] Schritt 3: ZWEIFEL — Prüfer mit „Fresh-Context“ und kontradiktorischer Eingabeaufforderung hinzugezogen
    - [ ] Schritt 4: ABGLEICH – alle Ergebnisse anhand des Artefakttextes klassifiziert
    - [ ] Schritt 5: BEENDEN – Stoppbedingung erfüllt (triviale Ergebnisse, 3 Zyklen oder Übersteuerung durch den Nutzer)
    
    

    Schritt 1: CLAIM — Aufzeigen, was gilt

    Beschreiben Sie die Entscheidung in zwei oder drei Zeilen:

    BEHAUPTUNG: „Die neue Caching-Schicht ist unter der
            in der Spezifikation beschriebenen leseintensiven Arbeitslast threadsicher.“
    WARUM DAS WICHTIG IST: Ein Race-Condition führt hier zur Beschädigung von Benutzerdaten und ist
                      im QA schwer zu erkennen.
    
    

    Wenn Sie die Aussage nicht so prägnant formulieren können, handelt es sich um eine Vermutung, nicht um eine Entscheidung. Bringen Sie sie zur Sprache, bevor Sie sie genauer unter die Lupe nehmen.

    Schritt 2: EXTRAHIEREN – Kleinste überprüfbare Einheit

    Ein Prüfer, der den Kontext noch nicht kennt, benötigt das Artefakt und den Vertrag, nicht den Entstehungsprozess.

    • Code: der Diff oder die Funktion – nicht die gesamte Datei
    • Entscheidung: Der Vorschlag in 3–5 Sätzen plus die Einschränkungen, die er erfüllen muss
    • Behauptung: die Behauptung sowie die Beweise, die sie angeblich stützen (im Unterschied zum CLAIM-Block aus Schritt 1, bei dem es sich um die zu prüfende Hypothese des Orchestrators handelt)

    Reduzieren Sie Ihre Argumentation auf das Wesentliche. Wenn Sie Schlussfolgerungen vorlegen, erhalten Sie im Gegenzug eine Bestätigung Ihrer Schlussfolgerungen. Die Einheit muss so klein sein, dass ein Prüfer sie beim ersten Lesen im Blick behalten kann – handelt es sich um einen Pull-Request mit 500 Zeilen, zerlegen Sie ihn zunächst.

    Schritt 3: ZWEIFEL – Beziehen Sie den Prüfer mit einem unvoreingenommenen Blick ein

    Die Aufforderung an den Prüfer muss kontrovers sein. Die Formulierung bestimmt die Antwort.

    Kritische Überprüfung. Finde heraus, was an diesem Artefakt falsch ist.
    Gehe davon aus, dass der Autor zu selbstsicher ist. Achte auf:
    - Unausgesprochene Annahmen
    - Nicht behandelte Randfälle
    - Versteckte Kopplungen oder gemeinsam genutzte Zustände
    - Möglichkeiten, wie der Vertrag verletzt werden könnte
    - Bestehende Konventionen, gegen die dies verstoßen könnte
    - Fehlermodi bei unerwarteten Eingaben
    
    Validieren Sie NICHT. Fassen Sie NICHT zusammen. Finden Sie Probleme oder geben Sie
    ausdrücklich an, dass Sie nach gründlicher Prüfung keine finden können.
    
    ARTEFAKT: 
    VERTRAG: 
    
    

    Geben Sie NUR das ARTEFAKT + den VERTRAG weiter. Geben Sie die BEHAUPTUNG NICHT weiter. Wenn Sie dem Prüfer Ihre Schlussfolgerung mitteilen, beeinflussen Sie ihn in Richtung Zustimmung. Der Prüfer muss unabhängig feststellen, ob das Artefakt den Vertrag erfüllt.

    In Claude Code beginnen die rollenbasierten Prüfer in „agents/“ konzeptionell mit einem isolierten Kontext und können hier verwendet werden – siehe „agents/“ für die Liste und die domänenbezogene Zuordnung.

    Die obige adversarische Eingabe hat Vorrang vor der Standardantwortform der Persona. Personas wie „code-reviewer“ sind so programmiert, dass sie ausgewogene Urteile mit sowohl Stärken als auch Schwächen liefern; bei Zweifel ist eine Ausgabe erforderlich, die ausschließlich Probleme aufzeigt. Fügen Sie die adversarische Eingabeaufforderung wörtlich in den Aufruf ein, damit sie die Standardeinstellung der Persona überschreibt. Wenn die Antwortform einer Persona nicht sauber überschrieben werden kann, greifen Sie auf einen generischen Unteragenten mit der adversarischen Eingabeaufforderung zurück.

    Modellübergreifende Eskalation

    Ein auf ein einzelnes Modell beschränkter Prüfer hat dieselben blinden Flecken wie der ursprüngliche Autor – ein „kälteres“ Modell mit einer anderen Architektur deckt diese auf. „Doubt-driven“ ist bei nicht-trivialen Entscheidungen bereits standardmäßig aktiviert; daher ist das Angebot einer modellübergreifenden Eskalation in diesem Rahmen Teil des Mehrwerts der Skill und keine optionale Reibstelle.

    Interaktive Sitzungen: immer anbieten. Niemals stillschweigend überspringen.

    Schritt 1: Fragen Sie den Nutzer

    Nach der Überprüfung des Einzelmodells in Schritt 3 oben, aber vor „RECONCILE“, halten Sie inne und fragen Sie:

    „Die Überprüfung eines einzelnen Modells ist abgeschlossen. Möchten Sie eine modellübergreifende Zweitmeinung einholen? Optionen: Gemini CLI, Codex CLI, manuelle externe Überprüfung (Sie fügen den Text an anderer Stelle ein) oder überspringen.“

    Diese Frage ist in jedem interaktiven Zweifelzyklus obligatorisch – selbst bei Artefakten, bei denen es um wenig zu gehen scheint. Der Nutzer – nicht der Agent – entscheidet, ob sich der Aufwand lohnt. Die Aufgabe des Agenten besteht darin, die Wahlmöglichkeit aufzuzeigen.

    Schritt 2: Wenn der Nutzer eine CLI wählt – überprüfen, dann ausführen

    1. Überprüfen Sie, ob das Tool im PATH enthalten ist (welches „gemini“, welcher „codex“).
    2. Testen Sie, ob es funktioniert (gemini --version oder gleichwertig), bevor Sie die vollständige Eingabeaufforderung weitergeben – eine veraltete oder defekte Binärdatei könnte den Test bestehen, bei echter Eingabe jedoch fehlschlagen.
    3. Bestätigen Sie den genauen Aufruf mit dem Benutzer, einschließlich erforderlicher Flags, Authentifizierung und Umgebungsvariablen (z. B. API-Schlüssel). Implementierungen variieren; gehen Sie niemals von einer bestimmten Vorgehensweise aus.
    4. Übergeben Sie ausschließlich ARTIFACT + CONTRACT + die adversarische Eingabeaufforderung. Kein Sitzungskontext, kein CLAIM.
    5. Achte auf Shell-Escaping. Wenn das Artefakt Anführungszeichen, $(...) oder Backticks enthält, verwende lieber stdin (echo … | gemini) oder ein Heredoc anstelle von inline -p "…". Im Zweifelsfall bitte den Benutzer, den Aufruf zu bestätigen, bevor du ihn ausführst.
    6. Übergeben Sie die Ausgabe an Schritt 4 (RECONCILE).

    Interpolieren Sie das Artefakt niemals in ein durch Shell-Anführungszeichen umschlossenes Argument. Code-, Markdown- und Review-Eingabeaufforderungen enthalten regelmäßig Backticks, $(...) und Anführungszeichen, die entweder die Eingabeaufforderung abschneiden oder eingebettete Shell-Befehle ausführen. Schreiben Sie die vollständige Eingabeaufforderung in eine Datei und leiten Sie sie über stdin weiter.

    Beispielformen (überprüfen Sie die Flags anhand Ihres installierten Tools – die Syntax unterscheidet sich je nach Implementierung und Version):

    # Schreibe zunächst die adversarische Eingabeaufforderung + ARTIFACT + CONTRACT in eine temporäre Datei.
    # Leite sie dann über stdin weiter, damit Shell-Metazeichen im Artefakt inaktiv bleiben.
    
    # Codex (die schreibgeschützte Sandbox verhindert, dass die CLI in Ihren Arbeitsbereich schreibt):
    codex exec --sandbox read-only -C  - < /tmp/doubt-prompt.md
    
    # Gemini („--approval-mode plan“ ist schreibgeschützt; „-p ""“ löst den nicht-interaktiven
    # Modus aus und die Eingabeaufforderung wird aus der Standard-Eingabe gelesen):
    gemini --approval-mode plan -p "" < /tmp/doubt-prompt.md
    
    

    Eine schreibgeschützte Sandbox ist das entscheidende Detail: Ein „Doubt“-Artefakt kann selbst Anweisungen enthalten (absichtliche oder versehentliche Eingabe einer Eingabeaufforderung), die die modellübergreifende CLI andernfalls in Ihrem Arbeitsbereich ausführen würde.

    Schritt 3: Falls die CLI nicht verfügbar ist oder fehlschlägt

    Machen Sie den Fehler explizit sichtbar. Bieten Sie folgende Optionen an: manuelle Ausführung, Versuch mit einem anderen Tool oder Überspringen. Weichen Sie nicht stillschweigend auf den Einzelmodell-Modus aus – der Benutzer sollte wissen, dass der modellübergreifende Modus nicht ausgeführt wurde.

    Schritt 4: Wenn der Benutzer den Schritt überspringt

    Bestätigen Sie das Überspringen in der Ausgabe („Weiter mit den Ergebnissen für ein einzelnes Modell“) und fahren Sie mit RECONCILE fort. Das Überspringen ist in Ordnung; stillschweigendes Überspringen hingegen nicht.

    Nicht-interaktive Kontexte (CI, /loop, autonomous-loop, geplante Läufe):

    • „Cross-Model“ wird übersprungen, und das Überspringen muss in der Ausgabe angekündigt werden: „Cross-Model übersprungen: nicht-interaktiver Kontext.“
    • Rufen Sie niemals eine externe CLI ohne ausdrückliche Benutzerautorisierung auf – dies ist eine tragende Sicherheitseigenschaft.

    „Cross-Model“ verursacht zusätzliche Kosten, Latenz und eine geringere Ausfallsicherheit der Tools. Der Agent stellt die Wahl in jedem Zyklus zur Verfügung; der Benutzer entscheidet, ob dieses Artefakt dies rechtfertigt.

    Schritt 4: ABSTIMMUNG – Ergebnisse zurückführen

    Das Ergebnis des Prüfers sind Daten, kein Urteil. Sie sind weiterhin der Koordinator. Lesen Sie den Text des Artefakts vor der Klassifizierung noch einmal im Lichte jedes einzelnen Befunds durch – das blinde Absegnen des Prüfers ist derselbe Fehler wie das Ignorieren seiner Ergebnisse.

    Klassifizieren Sie jeden Befund in dieser Prioritätsreihenfolge (die erste passende Klasse gewinnt):

    1. Falsche Auslegung des Vertrags – Der Prüfer hat etwas speziell deshalb markiert, weil der von dir bereitgestellte VERTRAG unklar oder unvollständig war. Korrigiere zuerst den Vertrag und klassifiziere im nächsten Zyklus erneut.
    2. Gültig + umsetzbar – echtes Problem, das eine Änderung am Artefakt erfordert. Nehmen Sie die Änderung vor und wiederholen Sie den Zyklus.
    3. Gültiger Kompromiss – Das Problem ist real, aber die Kosten für die Behebung übersteigen die Kosten für die Akzeptanz. Dokumentieren Sie den Kompromiss explizit, damit der Nutzer ihn sieht.
    4. Störsignal – Der Prüfer hat etwas markiert, das im Kontext, der ihm fehlte, eigentlich korrekt ist. Notieren Sie dies, fahren Sie fort und fragen Sie sich: Hätte die Aufnahme dieses Kontexts in den Vertrag die fälschliche Markierung verhindert?

    Ein neuer Prüfer kann sich irren, weil ihm der Kontext fehlt. Schieben Sie die Entscheidung nicht auf, nur weil er „neu“ ist.

    Schritt 5: STOP – Begrenzte Schleife, keine Rekursion

    Halten Sie an, wenn:

    • die nächste Iteration nur noch triviale oder bereits berücksichtigte Ergebnisse liefert oder
    • 3 Zyklen abgeschlossen sind (an den Nutzer weiterleiten, nicht alleine einen vierten durchziehen), oder
    • der Nutzer ausdrücklich sagt: „Veröffentliche es!“

    Wenn der Prüfer nach drei Durchläufen immer noch wesentliche Probleme aufzeigt, ist das Artefakt möglicherweise noch nicht fertig. Weisen Sie den Nutzer darauf hin – drei ungelöste Durchläufe sind eine Information über das Artefakt, kein Grund, die Schleife endlos fortzusetzen.

    Falls 3 Durchläufe „offensichtlich unzureichend“ sind, weil das Artefakt zu umfangreich ist: Das Artefakt ist zu groß – kehre zu Schritt 2 zurück und zerlege es. Hebe die Begrenzung nicht auf.

    Häufige Rechtfertigungsargumente

    Rationalisierung Realität
    „Ich bin mir sicher, ich überspringe den Schritt des Zweifelns“ Selbstvertrauen korreliert bei neuartigen Problemen nur schwach mit der Richtigkeit. Gerade in Momenten der Gewissheit verbergen sich blinde Flecken.
    „Einen Prüfer einzuschalten ist kostspielig“ Das Debuggen eines falschen Commits in der Produktion ist teurer. Die Überprüfung ist begrenzt; der Fehler ist es nicht.
    „Der Prüfer wird nur nach Haaren in der Suppe suchen“ Nur, wenn keine Grenzen gesetzt sind. Beschränke die Aufforderung auf „Probleme, die dazu führen würden, dass dies gemäß der Vereinbarung fehlschlägt“.
    „Ich werde meine Zweifel am Ende bei /review äußern“ /review ist eine letzte Kontrollinstanz. Zweifel helfen dabei, falsche Richtungen frühzeitig zu erkennen, wenn Kurskorrekturen noch kostengünstig sind. Zum Zeitpunkt des Pull-Requests ist es bereits zu spät.
    „Wenn ich jeden Schritt hinterfrage, werde ich nie etwas veröffentlichen“ Diese Methode gilt für nicht-triviale Entscheidungen, nicht für jeden Tastendruck. Lies noch einmal den Abschnitt „Wann man sie NICHT anwenden sollte“.
    „Zwei Meinungen sind immer besser als eine“ Nicht, wenn die zweite Meinung weniger Kontext hat und nur Unruhe stiftet. Bringe die Meinungen in Einklang, schiebe die Entscheidung nicht auf.
    „Der Prüfer war anderer Meinung, also lag ich falsch“ Dem Prüfer fehlt dein Kontext – Uneinigkeit ist eine Information, kein Urteil. Lies das Artefakt noch einmal durch, klassifiziere es und entscheide dann.
    „Modellübergreifend ist immer besser“ Ein modellübergreifender Ansatz deckt blinde Flecken auf, die ein einzelnes Modell mit sich selbst teilt, verursacht jedoch zusätzliche Kosten und macht das Tool anfälliger. Biete ihn in jedem interaktiven Zweifelzyklus an – der Nutzer entscheidet, ob das Artefakt dies rechtfertigt. Die Aufgabe des Agenten ist es, die Wahlmöglichkeit aufzuzeigen, nicht sie zu blockieren.
    „Der Nutzer hat einmal ‚Ja‘ gesagt, also kann ich die CLI weiterhin aufrufen“ Jeder Aufruf erfordert eine eigene Autorisierung. Das Artefakt, die Eingabeaufforderung und die Flags ändern sich zwischen den Aufrufen – bestätige den genauen Befehl vor jeder Ausführung erneut mit dem Nutzer.

    Warnsignale

    • Das Starten eines Reviewers mit neuem Kontext für eine einzeilige Umbenennung oder Formatierungsänderung
    • Die Ausgabe des Prüfers als verbindlich betrachten, ohne den Text des Artefakts erneut zu lesen
    • Mehr als drei Durchläufe, ohne den Nutzer einzubeziehen
    • Den Prüfer mit der Frage „Ist das in Ordnung?“ anstelle von „Finde Fehler“ auffordern
    • Unter Zeitdruck bei einer Entscheidung mit hohen Risiken Zweifel außer Acht lassen
    • Erneutes Starten eines „Fresh-Context“-Reviews bei einem unveränderten Artefakt (Sie erhalten dieselben Ergebnisse; Sie verzögern nur den Prozess)
    • Zweifelstheater (überprüfbares Signal): Über zwei oder mehr Zyklen hinweg, in denen der Prüfer wesentliche Befunde aufgedeckt hat, wurde kein einziger Befund als umsetzbar eingestuft. Du validierst, statt zu zweifeln. Hör auf und eskalieren.
    • Erst nach dem Commit zweifeln – das ist /review, keine zweifelgetriebene Entwicklung
    • Festkodierung eines externen CLI-Aufrufs, ohne beim Nutzer zu bestätigen, dass das Tool existiert, konfiguriert ist und genau diese Syntax akzeptiert
    • Das stillschweigende Überspringen von „Cross-Model“ in einem interaktiven Zweifelzyklus. Auch wenn es nicht empfohlen wird, muss das Angebot sichtbar sein. Überspringen ist in Ordnung; stillschweigendes Überspringen ist es nicht.
    • Stilles Zurückgreifen auf eine Ausweichlösung, wenn eine externe CLI einen Fehler ausgibt oder fehlt – den Fehler sichtbar machen und den Nutzer die Weiterleitung vornehmen lassen
    • Den Vertrag aus der Eingabe des Prüfers entfernen
    • Weiterleitung der BEHAUPTUNG an den Prüfer (Tendenz zur Zustimmung)

    Interaktion mit anderen Skills

    • code-review-and-quality / /review: komplementär. /review ist eine nachträgliche PR-Beurteilung; „doubt-driven“ erfolgt während des Prozesses bei jeder einzelnen Entscheidung. Verwenden Sie beides.
    • source-driven-development: SDD überprüft Fakten über Frameworks anhand offizieller Dokumentationen. „Doubt-driven“ überprüft Ihre Argumentation bezüglich des Artefakts. SDD prüft, ob die API existiert; „Doubt-driven“ prüft, ob Sie sie gemäß der Vereinbarung korrekt verwendet haben.
    • test-driven-development: Der RED-Schritt bei TDD ist konkretisierter Zweifel – ein fehlgeschlagener Test ist ein Versuch der Widerlegung. Wenn TDD angewendet wird, ist dieser fehlgeschlagene Test der Zweifelsschritt für Verhaltensaussagen.
    • Debugging und Fehlerbehebung: Wenn der Prüfer einen echten Fehlermodus aufdeckt, greifen Sie auf die Debugging-Kompetenz zurück, um den Fehler zu lokalisieren und zu beheben.
    • Regeln zur Repo-Orchestrierung (references/orchestration-patterns.md): Diese Kompetenz orchestriert von der Hauptsitzung aus. Wenn eine Persona eine andere Persona aufruft, handelt es sich um das Anti-Muster B – siehe „Ladeeinschränkungen“ oben.

    Verifizierung

    Nach der Anwendung der zweifelgetriebenen Entwicklung:

    • Jede nicht-triviale Entscheidung (gemäß der obigen Definition) wurde explizit als CLAIM benannt, bevor sie in Kraft trat
    • Mindestens eine Überprüfung im neuen Kontext pro nicht-trivialem Artefakt (ein fehlgeschlagener Test, der im RED-Schritt von TDD erzeugt wurde, erfüllt diese Anforderung für Verhaltensaussagen gemäß „Interaktion mit anderen Fähigkeiten“)
    • Der Prüfer erhielt ARTEFAKT + VERTRAG – NICHT den ANSPRUCH, NICHT Ihre Begründung
    • Die Aufforderung an den Prüfer war kontradiktorisch („Finde Probleme“), nicht validierend („Ist es gut?“)
    • Die Ergebnisse wurden anhand des Artefakttextes klassifiziert (nicht einfach abgenickt), wobei folgende Prioritäten galten: Fehlinterpretation des Vertrags / umsetzbar / Kompromiss / Rauschen
    • Eine Stoppbedingung wurde erfüllt (triviale Ergebnisse, 3 Zyklen oder Überschreiben durch den Benutzer)
    • Im interaktiven Modus wurde dem Nutzer explizit eine modellübergreifende Überprüfung angeboten (unabhängig von der Bedeutung des Artefakts) und die Antwort wurde in der Ausgabe bestätigt
    • Im nicht-interaktiven Modus wurde die modellübergreifende Überprüfung übersprungen und das Überspringen angekündigt
    • Jedem externen CLI-Aufruf gingen eine PATH-Prüfung, ein Test auf funktionierende Binärdateien, eine Syntaxbestätigung mit dem Benutzer und eine ausdrückliche Autorisierung zur Ausführung voraus
    Auf GitHub ansehen
    ---
    name: doubt-driven-development
    description: Subjects every non-trivial decision to a fresh-context adversarial review before it stands, prioritizing correctness over speed for high-stakes or unfamiliar code.
    ---
    
    # Doubt-Driven Development
    
    ## Overview
    
    A confident answer is not a correct one. Long sessions accumulate context that quietly turns assumptions into "facts" without anyone noticing. Doubt-driven development is the discipline of materializing a fresh-context reviewer — biased to **disprove**, not approve — before any non-trivial output stands.
    
    This is not `/review`. `/review` is a verdict on a finished artifact. This is an in-flight posture: non-trivial decisions get cross-examined while course-correction is still cheap.
    
    ## When to Use
    
    A decision is **non-trivial** when at least one of these is true:
    
    - It introduces or modifies branching logic
    - It crosses a module or service boundary
    - It asserts a property the type system or compiler cannot verify (thread safety, idempotence, ordering, invariants)
    - Its correctness depends on context the future reader cannot see
    - Its blast radius is irreversible (production deploy, data migration, public API change)
    
    Apply the skill when:
    
    - About to make an architectural decision under uncertainty
    - About to commit non-trivial code
    - About to claim a non-obvious fact ("this is safe", "this scales", "this matches the spec")
    - Working in code you don't fully understand
    
    **When NOT to use:**
    
    - Mechanical operations (renaming, formatting, file moves)
    - Following a clear, unambiguous user instruction
    - Reading or summarizing existing code
    - One-line changes with obvious correctness
    - Pure tooling operations (running tests, listing files)
    - The user has explicitly asked for speed over verification
    
    If you doubt every keystroke, you ship nothing. The skill applies only to non-trivial decisions as defined above.
    
    ## Loading Constraints
    
    This skill is designed for the **main-session orchestrator**, where Step 3 (DOUBT, detailed below) can spawn a fresh-context reviewer.
    
    - **Do NOT add this skill to a persona's `skills:` frontmatter.** A persona that follows Step 3 would spawn another persona — the orchestration anti-pattern explicitly forbidden by `references/orchestration-patterns.md` ("personas do not invoke other personas").
    - **If you find yourself applying this skill from inside a subagent context** (where Claude Code prevents nested subagent spawn): the preferred path is to surface to the user that doubt-driven cannot run nested and let the main session handle it. As a last resort only, a degraded self-questioning fallback exists — rewrite ARTIFACT + CONTRACT as a fresh self-prompt with a hard mental separator from your prior reasoning, and walk Steps 1–5. This is **not fresh-context review** (you carry your own context with you), so flag the result as degraded and prefer escalation whenever the user is reachable.
    
    ## The Process
    
    Copy this checklist when applying the skill:
    
    ```
    Doubt cycle:
    - [ ] Step 1: CLAIM — wrote the claim + why-it-matters
    - [ ] Step 2: EXTRACT — isolated artifact + contract, stripped reasoning
    - [ ] Step 3: DOUBT — invoked fresh-context reviewer with adversarial prompt
    - [ ] Step 4: RECONCILE — classified every finding against the artifact text
    - [ ] Step 5: STOP — met stop condition (trivial findings, 3 cycles, or user override)
    ```
    
    ### Step 1: CLAIM — Surface what stands
    
    Name the decision in two or three lines:
    
    ```
    CLAIM: "The new caching layer is thread-safe under the
            read-heavy workload described in the spec."
    WHY THIS MATTERS: a race here corrupts user data and is
                      hard to detect in QA.
    ```
    
    If you can't write the claim that compactly, you have a vibe, not a decision. Surface it before scrutinizing it.
    
    ### Step 2: EXTRACT — Smallest reviewable unit
    
    A fresh-context reviewer needs the **artifact** and the **contract**, not the journey.
    
    - Code: the diff or the function — not the whole file
    - Decision: the proposal in 3–5 sentences plus the constraints it has to satisfy
    - Assertion: the claim plus the evidence that supposedly supports it (kept distinct from the Step 1 CLAIM block, which is the orchestrator's hypothesis under scrutiny)
    
    Strip your reasoning. If you hand over conclusions, you'll get back validation of your conclusions. The unit must be small enough that a reviewer can hold it in mind in one read — if it's a 500-line PR, decompose first.
    
    ### Step 3: DOUBT — Invoke the fresh-context reviewer
    
    The reviewer's prompt **must be adversarial**. Framing decides the answer.
    
    ```
    Adversarial review. Find what is wrong with this artifact.
    Assume the author is overconfident. Look for:
    - Unstated assumptions
    - Edge cases not handled
    - Hidden coupling or shared state
    - Ways the contract could be violated
    - Existing conventions this might break
    - Failure modes under unexpected input
    
    Do NOT validate. Do NOT summarize. Find issues, or state
    explicitly that you cannot find any after thorough examination.
    
    ARTIFACT: <paste artifact>
    CONTRACT: <paste contract>
    ```
    
    **Pass ARTIFACT + CONTRACT only. Do NOT pass the CLAIM.** Handing the reviewer your conclusion biases it toward agreement. The reviewer must independently determine whether the artifact satisfies the contract.
    
    In Claude Code, the role-based reviewers in `agents/` start with isolated context by design and are usable here — see `agents/` for the roster and per-domain match.
    
    **The adversarial prompt above takes precedence over the persona's default response shape.** Personas like `code-reviewer` are written to produce balanced verdicts with both strengths and weaknesses; doubt-driven needs issues-only output. Paste the adversarial prompt verbatim into the invocation so it overrides the persona's default. If a persona's response shape can't be overridden cleanly, fall back to a generic subagent with the adversarial prompt.
    
    #### Cross-model escalation
    
    A single-model reviewer shares blind spots with the original author — a colder, different-architecture model catches them. Doubt-driven is already opt-in for non-trivial decisions, so within that scope offering cross-model is part of the skill's value, not optional friction.
    
    **Interactive sessions: always offer. Never silently skip.**
    
    **Step 1: Ask the user**
    
    After the single-model review in Step 3 above, but before RECONCILE, pause and ask:
    
    > *"Single-model review complete. Want a cross-model second opinion? Options: Gemini CLI, Codex CLI, manual external review (you paste it elsewhere), or skip."*
    
    This question is mandatory in every interactive doubt cycle — even on artifacts that feel low-stakes. The user — not the agent — decides whether the cost is worth it. The agent's job is to surface the choice.
    
    **Step 2: If the user picks a CLI — verify, then invoke**
    
    1. Check the tool is in PATH (`which gemini`, `which codex`).
    2. Test it works (`gemini --version` or equivalent) before passing the full prompt — a stale or broken binary may pass `which` but fail on real input.
    3. Confirm the exact invocation with the user, including required flags, auth, and env vars (e.g., API keys). Implementations vary; never assume.
    4. Pass ARTIFACT + CONTRACT + the adversarial prompt **only**. No session context, no CLAIM.
    5. Mind shell escaping. If the artifact contains quotes, `$(...)`, or backticks, prefer stdin (`echo … | gemini`) or a heredoc over inline `-p "…"`. When in doubt, ask the user to confirm the invocation before running it.
    6. Take the output into Step 4 (RECONCILE).
    
    **Never interpolate the artifact into a shell-quoted argument.** Code, markdown, and review prompts routinely contain backticks, `$(...)`, and quote characters that will either truncate the prompt or execute embedded shell. Write the full prompt to a file and pipe it through stdin.
    
    Example shapes (verify flags against your installed tool — syntax differs across implementations and versions):
    
    ```bash
    # Write the adversarial prompt + ARTIFACT + CONTRACT to a temp file first.
    # Then pipe via stdin so shell metacharacters in the artifact stay inert.
    
    # Codex (read-only sandbox keeps the CLI from writing to your workspace):
    codex exec --sandbox read-only -C <repo-path> - < /tmp/doubt-prompt.md
    
    # Gemini ('--approval-mode plan' is read-only; '-p ""' triggers non-interactive
    # mode and the prompt is read from stdin):
    gemini --approval-mode plan -p "" < /tmp/doubt-prompt.md
    ```
    
    A read-only sandbox is the load-bearing detail: a doubt artifact may itself contain instructions (intentional or accidental prompt injection) that the cross-model CLI would otherwise execute against your workspace.
    
    **Step 3: If the CLI is unavailable or fails**
    
    Surface the failure explicitly. Offer: run it manually, try a different tool, or skip. Do not silently fall back to single-model — the user should know cross-model didn't happen.
    
    **Step 4: If the user skips**
    
    Acknowledge the skip in the output (*"Proceeding with single-model findings only"*) and continue to RECONCILE. Skipping is fine; silent skipping is not.
    
    **Non-interactive contexts** (CI, `/loop`, autonomous-loop, scheduled runs):
    
    - Cross-model is **skipped**, and the skip must be **announced** in the output: *"Cross-model skipped: non-interactive context."*
    - **Never invoke an external CLI without explicit user authorization** — this is a load-bearing safety property.
    
    Cross-model adds cost, latency, and tool fragility. The agent surfaces the choice every cycle; the user decides whether this artifact warrants it.
    
    ### Step 4: RECONCILE — Fold findings back
    
    The reviewer's output is data, not verdict. **You are still the orchestrator.** Re-read the artifact text against each finding before classifying — rubber-stamping the reviewer is the same failure mode as ignoring it.
    
    For each finding, classify in this **precedence order** (first matching class wins):
    
    1. **Contract misread** — reviewer flagged something specifically because the CONTRACT you provided was unclear or incomplete. Fix the contract first, re-classify on the next cycle.
    2. **Valid + actionable** — real issue requiring a change to the artifact. Change it, re-loop.
    3. **Valid trade-off** — issue is real but cost of fixing exceeds cost of accepting. Document the trade-off explicitly so the user sees it.
    4. **Noise** — reviewer flagged something that's actually correct under context the reviewer didn't have. Note it, move on, and ask: would adding that context to the contract have prevented the false flag?
    
    A fresh reviewer can be wrong because it lacks context. Don't defer just because it's "fresh."
    
    ### Step 5: STOP — Bounded loop, not recursion
    
    Stop when:
    
    - Next iteration returns only trivial or already-considered findings, **or**
    - 3 cycles completed (escalate to user, don't grind a fourth alone), **or**
    - User explicitly says "ship it"
    
    If after 3 cycles the reviewer still surfaces substantive issues, the artifact may not be ready. Surface this to the user — three unresolved cycles is information about the artifact, not a reason to keep looping.
    
    If 3 cycles is "obviously insufficient" because the artifact is large: the artifact is too big — return to Step 2 and decompose. Do not lift the bound.
    
    ## Common Rationalizations
    
    | Rationalization | Reality |
    |---|---|
    | "I'm confident, skip the doubt step" | Confidence correlates poorly with correctness on novel problems. Moments of certainty are exactly when blind spots hide. |
    | "Spawning a reviewer is expensive" | Debugging a wrong commit in production is more expensive. The check is bounded; the bug isn't. |
    | "The reviewer will just nitpick" | Only if unscoped. Constrain the prompt to "issues that would make this fail under the contract." |
    | "I'll do doubt at the end with `/review`" | `/review` is a final gate. Doubt-driven catches wrong directions early when course-correction is cheap. By PR time it's too late. |
    | "If I doubt every step I'll never ship" | The skill applies to non-trivial decisions, not every keystroke. Re-read "When NOT to Use." |
    | "Two opinions are always better than one" | Not when the second has less context and produces noise. Reconcile, don't defer. |
    | "The reviewer disagreed so I was wrong" | The reviewer lacks your context — disagreement is information, not verdict. Re-read the artifact, classify, then decide. |
    | "Cross-model is always better" | Cross-model catches blind spots a single model shares with itself, but it adds cost and tool fragility. Offer it every interactive doubt cycle — the user decides whether the artifact warrants it. The agent's job is to surface the choice, not to gate it. |
    | "User said yes once, so I can keep invoking the CLI" | Each invocation is its own authorization. The artifact, the prompt, and the flags change between calls — re-confirm the exact command with the user before every run. |
    
    ## Red Flags
    
    - Spawning a fresh-context reviewer for a one-line rename or formatting change
    - Treating reviewer output as authoritative without re-reading the artifact text
    - Looping >3 cycles without escalating to the user
    - Prompting the reviewer with "is this good?" instead of "find issues"
    - Skipping doubt under time pressure on a high-stakes decision
    - Re-spawning fresh-context on an unchanged artifact (you'll get the same findings; you're stalling)
    - **Doubt theater (checkable signal)**: across 2 or more cycles where the reviewer surfaced substantive findings, zero findings were classified as actionable. You are validating, not doubting. Stop and escalate.
    - Doubting only after committing — that's `/review`, not doubt-driven development
    - Hardcoding an external CLI invocation without confirming with the user that the tool exists, is configured, and accepts that exact syntax
    - **Silently skipping cross-model in an interactive doubt cycle.** Even when not recommending it, the offer must be visible. Skipping is fine; silent skipping is not.
    - Falling back silently when an external CLI errors or is missing — surface the failure and let the user redirect
    - Stripping the contract from the reviewer's input
    - Passing the CLAIM to the reviewer (biases toward agreement)
    
    ## Interaction with Other Skills
    
    - **`code-review-and-quality` / `/review`**: complementary. `/review` is post-hoc PR verdict; doubt-driven is in-flight per-decision. Use both.
    - **`source-driven-development`**: SDD verifies *facts about frameworks* against official docs. Doubt-driven verifies *your reasoning about the artifact*. SDD checks the API exists; doubt-driven checks you used it correctly under the contract.
    - **`test-driven-development`**: TDD's RED step is doubt made concrete — a failing test is a disproof attempt. When TDD applies, that failing test *is* the doubt step for behavioral claims.
    - **`debugging-and-error-recovery`**: when the reviewer surfaces a real failure mode, drop into the debugging skill to localize and fix.
    - **Repo orchestration rules** (`references/orchestration-patterns.md`): this skill orchestrates from the main session. A persona calling another persona is anti-pattern B — see Loading Constraints above.
    
    ## Verification
    
    After applying doubt-driven development:
    
    - [ ] Every non-trivial decision (per the definition above) was named explicitly as a CLAIM before standing
    - [ ] At least one fresh-context review per non-trivial artifact (a failing test produced by TDD's RED step satisfies this for behavioral claims, per Interaction with Other Skills)
    - [ ] The reviewer received ARTIFACT + CONTRACT — NOT the CLAIM, NOT your reasoning
    - [ ] The reviewer's prompt was adversarial ("find issues"), not validating ("is it good")
    - [ ] Findings were classified against the artifact text (not rubber-stamped) using the precedence: contract misread / actionable / trade-off / noise
    - [ ] A stop condition was met (trivial findings, 3 cycles, or user override)
    - [ ] In interactive mode, cross-model was **explicitly offered** to the user (regardless of artifact stakes) and the response was acknowledged in the output
    - [ ] In non-interactive mode, cross-model was skipped and the skip was announced
    - [ ] Any external CLI invocation was preceded by a PATH check, a working-binary test, syntax confirmation with the user, and explicit authorization to run
    

    Alle Dateien

    0 Dateien

    doubt-driven-development installieren

    Laden Sie die Skill-Dateien herunter und entpacken Sie sie in Ihr Verzeichnis „.claude/skills/“.

    ZIP herunterladen

    Klonen Sie das Repository und kopieren Sie die Skill-Dateien in Ihr Projekt.

    git clone https://github.com/addyosmani/agent-skills/tree/main/skills/doubt-driven-development # Copy SKILL.md to your .claude/skills/ directory

    Kopieren Kopieren
    Schnelle Einrichtung: Kopiere den Skill-Ordner nach .claude/skills/ Claude erkennt den Skill automatisch und nutzt ihn.

    Ähnliche Skills

    notion-automation
    Zeit aktualisiert 29. Juni 2026
    airtable-automation
    Zeit aktualisiert 29. Juni 2026
    seo-programmatic
    Zeit aktualisiert 29. Juni 2026
    revops
    Zeit aktualisiert 29. Juni 2026
    OR