Dude Superpowers has to be on here and not for just the build portion. But its systematic debugging skill is impressive
Open the batch installer for this collection and generate commands only when you need them.
von obra
requesting-code-review ist ein schlanker Workflow, um den Subagent `superpowers:code-reviewer` mit einem sauberen git-Diff, Anforderungen und einer Änderungszusammenfassung zu starten, damit Reviews zum richtigen Zeitpunkt stattfinden und vor dem Merge umsetzbares, nach Schweregrad priorisiertes Feedback liefern.
von obra
subagent-driven-development ist eine Skill zur Ausführung von Implementierungsplänen mit einem frischen Subagent pro Aufgabe. Anschließend wird jedes Ergebnis in zwei Durchgängen geprüft: zuerst auf Spezifikationskonformität, danach auf Codequalität. Enthalten sind Prompt-Vorlagen für Implementer, Spec-Reviewer und Code-Quality-Reviewer.
von obra
systematic-debugging ist ein Debugging-Skill mit Fokus auf die Ursachenanalyse für Bugs, flaky Tests, Build-Fehler und unerwartetes Verhalten. Erfahre, wie der Workflow in vier Phasen funktioniert, welche Begleitdateien es gibt und wann du den Skill einsetzen solltest, bevor du Fixes vorschlägst.
von obra
Installieren und nutzen Sie die test-driven-development Skill, um striktes TDD durchzusetzen: zuerst einen fehlschlagenden Test schreiben, den Fehlschlag prüfen, den minimal nötigen Code implementieren und anschließend sicher refaktorieren.
von obra
using-git-worktrees hilft dabei, isolierte Git-Worktrees für neue Branch-Arbeit anzulegen – mit Verzeichnisauswahl, Ignore-Prüfungen und sichereren parallelen Workflows, ohne den aktuellen Checkout anzutasten.
von obra
using-superpowers ist ein Session-Start-Skill aus obra/superpowers, der vor jeder Antwort eine Skill-Suche erzwingt und Agenten so hilft, zuerst den passenden Workflow zu finden und zu aktivieren.
von obra
verification-before-completion ist ein Skill für den abschließenden Check, der unbelegte Abschlussbehauptungen verhindert. Hier erfahren Sie, wann Sie ihn einsetzen, wie Sie ihn aus obra/superpowers installieren und wie Sie jede Statusaussage mit aktueller Verifikations-Evidenz absichern.
von obra
writing-plans hilft dabei, aus einer Spezifikation oder einem Anforderungsdokument einen detaillierten Implementierungsplan zu erstellen – mit Hinweisen auf Dateiebene, sinnvoller Aufgabenreihenfolge, Testschritten und einer Review-Aufforderung, bevor die Umsetzung beginnt.
von obra
writing-skills ist ein Leitfaden für Skill Authoring, mit dem du Agent-Skills in einem testgetriebenen Workflow erstellen, überarbeiten und validieren kannst. Du lernst die wichtigsten Dateien, Voraussetzungen und praktischen Schritte für Druckszenarien, Baseline-Tests und prägnante Iterationen an `SKILL.md` kennen.
von obra
brainstorming ist eine Skill für die Phase vor der Implementierung: Sie beleuchtet den Kontext, stellt Klärungsfragen nacheinander und verlangt eine Designfreigabe, bevor Code geschrieben wird. Enthalten sind ein optionaler visueller Begleiter und starke Unterstützung für die Anforderungsplanung.
von obra
dispatching-parallel-agents ist ein Skill für Agent-Orchestrierung, der wirklich unabhängige Aufgaben auf separate Agents mit isoliertem Kontext und koordinierten Ergebnissen verteilt.
von obra
executing-plans unterstützt Agenten dabei, einen schriftlichen Umsetzungsplan sauber abzuarbeiten: erst prüfen, dann Aufgaben der Reihe nach ausführen, vorgegebene Checks laufen lassen, bei Blockern stoppen und an einen Abschluss-Workflow übergeben. Besonders passend für Project Management und andere planorientierte Delivery-Prozesse.
von obra
Der Skill finishing-a-development-branch hilft dabei, einen Git-Branch nach abgeschlossener Implementierung sicher abzuschließen. Er prüft Tests, kontrolliert den Basis-Branch und bietet dann vier klare Optionen: lokal mergen, für einen Pull Request pushen, den Branch behalten oder die Arbeit verwerfen.
von obra
receiving-code-review hilft dir, PR-Feedback zu prüfen, bevor du Code änderst. Nutze die Skill, um Review-Kommentare in eigenen Worten zusammenzufassen, sie mit der Codebasis abzugleichen, bei unklaren Punkten nachzufragen und begründet zu widersprechen, wenn Vorschläge nicht passen.
# How to Use Superpowers Skills Effectively Do not treat a task as “read the request and start coding.” Superpowers changes the default workflow: **check for relevant skills first, then let the skills determine how to work**. ## Core Rule Before responding, exploring files, asking clarifying questions, or implementing anything, first check whether a Superpowers skill applies. If a skill is relevant, use it first. User instructions define **what** to do. Skills define **how** to do it. --- ## Recommended Workflow ### 1. Start with `using-superpowers` Use this first for almost every task. Its job is to decide whether another skill should control the workflow. --- ### 2. Use `brainstorming` for new work or behavior changes Use it before: - building a feature - adding functionality - changing behavior - doing meaningful implementation work What to do: - understand the current context - ask clarifying questions one at a time - propose a few approaches with trade-offs - recommend one - get approval - write the design spec Do **not** code during brainstorming. --- ### 3. After approval, use `writing-plans` Turn the approved design into a concrete execution plan. The plan should include: - files to create or modify - small implementation steps - testing and verification steps A good plan should be clear enough for another agent to execute. --- ### 4. Use `using-git-worktrees` before implementation Prefer an isolated worktree instead of modifying the main workspace directly. This keeps feature work cleaner and safer. --- ### 5. Prefer `subagent-driven-development` for execution If subagents are available, use them to execute plan tasks one by one. Recommended pattern: - assign one focused task to one subagent - review for spec alignment - review for code quality - fix issues - mark the task complete --- ### 6. Use `executing-plans` if subagents are not available If you already have a written plan but are not using subagents, use `executing-plans`. Rules: - read the plan first - review it before starting - execute one task at a time - verify as you go - do not guess when blocked --- ## Supporting Skills ### `test-driven-development` Use when test-first implementation is appropriate: 1. write a failing test 2. confirm it fails 3. implement the minimum fix 4. run tests again --- ### `systematic-debugging` Use for bug fixing. Do not guess. Reproduce, narrow the problem, test hypotheses, find the root cause, then verify the fix. --- ### `requesting-code-review` / `receiving-code-review` Use review as a formal step, not an afterthought. --- ### `verification-before-completion` Before declaring work done, verify that: - tests pass - required commands succeed - the implementation matches the design and plan --- ### `finishing-a-development-branch` After implementation is complete: 1. verify tests 2. identify the base branch 3. present the completion options 4. clean up appropriately --- ## End-to-End Flow `using-superpowers` → `brainstorming` → `writing-plans` → `using-git-worktrees` → `subagent-driven-development` or `executing-plans` → supporting skills as needed → `verification-before-completion` → `finishing-a-development-branch` --- ## Operating Principle **User instructions define the goal. Skills define the method. Design before implementation. Plan before execution. Verify before completion.**
