Zurück zu Fähigkeiten

shiva-bhaga

pjt222
Aktualisiert 2 days ago
5 Ansichten
17
2
17
Auf GitHub ansehen
Entwicklunggeneral

Über

Die shiva-bhaga-Fähigkeit führt kontrollierte Zerstörung durch, indem sie veralteten Kontext bereinigt, überholte Annahmen entfernt und toten Code oder gescheiterte Ansätze beseitigt. Sie ist darauf ausgelegt, Raum für neue Schöpfung zu schaffen, indem bewusst die Bindung an überholte Muster gelöst wird. Verwenden Sie sie, wenn sich im Kontext veraltete Annahmen angesammelt haben, wenn eine Richtung einen grundlegenden Wechsel benötigt oder wenn Zombie-Aufgaben und toter Code Störungen verursachen.

Schnellinstallation

Claude Code

Empfohlen
Primär
npx skills add pjt222/agent-almanac -a claude-code
Plugin-BefehlAlternativ
/plugin add https://github.com/pjt222/agent-almanac
Git CloneAlternativ
git clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/shiva-bhaga

Kopieren Sie diesen Befehl und fügen Sie ihn in Claude Code ein, um diese Fähigkeit zu installieren

Dokumentation

Shiva Bhaga

Kontrollierte Zerstoerung und Aufloesung veralteter Muster, ueberholter Annahmen und angesammelten Rauschens — den Boden raeumen damit neues Wachstum entstehen kann.

Wann verwenden

  • Der Kontext hat veraltete Annahmen angesammelt die das Denken unbemerkt verzerren
  • Ein frueherer Ansatz ist gescheitert und die Versuchung ist zu flicken statt zu verwerfen
  • Das Gespraech ist lang geworden und fruehere Entscheidungen dienen moeglicherweise nicht mehr dem aktuellen Ziel
  • Toter Code, aufgegebene Plaene oder Zombieaufgaben erzeugen Rauschen und Verwirrung
  • Vor einem grossen Richtungswechsel — Raeumen muss der Schoepfung vorausgehen
  • Wenn die Bindung an einen bestimmten Ansatz die Betrachtung von Alternativen verhindert

Eingaben

  • Erforderlich: Aktueller Gespraechszustand oder Projektkontext (implizit verfuegbar)
  • Optional: Spezifisches Ziel der Aufloesung (z.B. "dieser Ansatz funktioniert nicht", "alle Annahmen ueber die Datenbankschicht klären")
  • Optional: Grenze des Geltungsbereichs — was durch die Zerstoerung hindurch bewahrt werden muss

Vorgehensweise

Schritt 1: Identifizieren was enden muss

Den aktuellen Zustand ueberblicken und markieren was veraltet, kaputt oder dem Ziel nicht mehr dienlich ist.

Aufloesungs-Triage:
+---------------------+---------------------------+------------------------+
| Kategorie           | Symptome                  | Massnahme              |
+---------------------+---------------------------+------------------------+
| Veraltete Annahmen  | Fruehere Entscheidungen   | Auflisten und jede     |
|                     | die nicht mehr zum         | gegen die aktuelle     |
|                     | aktuellen Verstaendnis     | Realitaet neu bewerten |
|                     | passen                     |                        |
+---------------------+---------------------------+------------------------+
| Gescheiterte        | Versuchte und aufgegebene  | Scheitern explizit     |
| Ansaetze            | Ansaetze die das Denken    | anerkennen; die        |
|                     | noch beeinflussen          | versunkenen Kosten     |
|                     |                            | loslassen              |
+---------------------+---------------------------+------------------------+
| Angesammeltes       | Kontext, Variablen oder    | Identifizieren und     |
| Rauschen            | Plaene die nicht mehr       | zur Entfernung         |
|                     | referenziert oder relevant  | markieren              |
|                     | sind                        |                        |
+---------------------+---------------------------+------------------------+
| Bindungspunkte      | "Wir haben bereits          | Hinterfragen ob die    |
|                     | entschieden..."-            | Entscheidung noch      |
|                     | Ueberzeugungen die sich     | gilt                   |
|                     | gegen Neupruefung           |                        |
|                     | straeuben                   |                        |
+---------------------+---------------------------+------------------------+
| Zombie-Artefakte    | Code, Aufgaben oder Plaene  | Loeschen oder          |
|                     | die existieren aber keinem  | archivieren; nicht     |
|                     | aktuellen Zweck dienen      | in der Schwebe lassen  |
+---------------------+---------------------------+------------------------+
  1. Jede Kategorie ehrlich durchmustern — Widerstand gegen das Untersuchen einer Kategorie ist selbst ein Signal
  2. Fuer jeden gefundenen Punkt fragen: "Wenn ich jetzt von vorn anfangen wuerde, wuerde ich das erstellen?"
  3. Wenn die Antwort nein ist, zur Aufloesung markieren

Erwartet: Ein klares Inventar dessen was losgelassen werden muss, mit spezifischen Eintraegen in jeder Kategorie.

Bei Fehler: Wenn nichts veraltet erscheint, ist die Bewertung moeglicherweise zu oberflaechlich. Die aelteste Entscheidung im aktuellen Kontext herausgreifen und sie von Grund auf begruenden — wenn die Begruendung sich erzwungen anfuehlt, ist sie ein Kandidat fuer die Aufloesung.

Schritt 2: Die Bewahrungsgrenze festlegen

Nicht alles soll zerstoert werden. Identifizieren was die Raeumung ueberleben muss.

  1. Kernanforderungen: Was hat der Benutzer tatsaechlich gefragt? Das ueberlebt.
  2. Verifiziertes Wissen: Durch Werkzeugnutzung bestaetigte Fakten (Dateien lesen, Testergebnisse) ueberleben.
  3. Benutzerpraeferenzen: Explizit benannte Praeferenzen und Einschraenkungen ueberleben.
  4. Funktionierende Komponenten: Code oder Ansaetze die nachweislich funktionieren ueberleben.

Die Grenze ziehen: alles innerhalb wird bewahrt, alles ausserhalb unterliegt der Aufloesung.

Erwartet: Eine klare Unterscheidung zwischen dem was behalten und dem was losgelassen wird.

Bei Fehler: Wenn die Grenze unklar ist, fragen: "Was muesste ich rekonstruieren wenn ich diese Aufgabe von vorn beginnen wuerde?" Die Antwort definiert die Bewahrungsgrenze.

Schritt 3: Mit Absicht aufloesen

Die Aufloesung ausfuehren — nicht als Aufgabe sondern als bewusstes Raeumen.

  1. Fuer jeden markierten Punkt explizit loslassen:
    • Veraltete Annahme: "Ich nahm X an, aber aktuelle Belege zeigen Y. Loslassen von X."
    • Gescheiterter Ansatz: "Ansatz A wurde versucht und funktionierte nicht weil Z. Loslassen der Bindung an A."
    • Rauschen: "Variable/Plan/Kontext Q ist nicht mehr relevant. Aus der Betrachtung entfernen."
  2. Das Aufzuloesende nicht rechtfertigen oder verteidigen — der Sinn ist Loslassen, nicht Analyse
  3. Wenn ein grosser Koerper angesammelten Kontexts aufgeloest wird, in einem Satz zusammenfassen was aufgeloest wurde und warum
  4. Den Arbeitsbereich raeumen: falls zutreffend, aufgegebene Dateien schliessen, das mentale Modell zuruecksetzen, die saubere Flaeche anerkennen

Erwartet: Ein leichterer, saubererer Kontext mit entfernten veralteten Elementen. Der verbleibende Kontext sollte sich genau und aktuell anfuehlen.

Bei Fehler: Wenn die Aufloesung sich unvollstaendig anfuehlt — wenn losgelassene Punkte das Denken weiter beeinflussen — sie erneut explizit benennen. "Ich bemerke dass ich immer noch so denke als waere X wahr. X wurde aufgeloest. Fortfahren ohne X."

Schritt 4: In der Leere verweilen

Nach der Zerstoerung dem Drang widerstehen sofort wieder aufzubauen. Der Raum zwischen Zerstoerung und Schoepfung hat Wert.

  1. Den geraeuemten Raum anerkennen: "Folgendes wurde aufgeloest: [Liste]"
  2. Vermerken was bleibt: "Was ueberlebt: [Liste]"
  3. Vorzeitigem Wiederaufbau widerstehen — nicht sofort einen Ersatz fuer das Aufgeloeste vorschlagen
  4. Den geraeuemten Raum das Naechste mitbestimmen lassen
  5. Die Leere ist nicht Leere — sie ist Potenzial. Der naechste Schritt (Schoepfung ueber brahma-bhaga oder Bewahrung ueber vishnu-bhaga) entsteht aus diesem Raum

Erwartet: Ein Moment der Klarheit zwischen dem Alten und dem Neuen. Die naechste Richtung wird aus dem Verbliebenen ersichtlich statt erzwungen zu werden.

Bei Fehler: Wenn die Leere sich unbequem anfuehlt und ein starker Zug besteht sofort wieder aufzubauen, ist diese Dringlichkeit selbst ein Signal — sie koennte Bindung an das aufgeloeste Muster anzeigen. Laenger verweilen. Der richtige naechste Schritt wird sich zeigen.

Validierung

  • Veraltete Annahmen wurden identifiziert und explizit losgelassen
  • Gescheiterte Ansaetze wurden ohne Abwehrhaltung anerkannt
  • Angesammeltes Rauschen wurde aus dem Arbeitskontext entfernt
  • Die Bewahrungsgrenze wurde vor der Aufloesung festgelegt
  • Kernanforderungen und Benutzerpraeferenzen wurden bewahrt
  • Der geraeuemte Raum wurde anerkannt bevor zur Schoepfung uebergegangen wird

Haeufige Stolperfallen

  • Zu viel zerstoeren: Aufloesung ohne Bewahrungsgrenze zerstoert funktionierende Komponenten zusammen mit veralteten. Immer zuerst die Grenze ziehen
  • Zu wenig zerstoeren: Hoefliche Aufloesung die Dinge "loslässt" aber sie weiterhin das Denken beeinflussen laesst. Echte Aufloesung erfordert tatsaechliches Loslassen
  • Die Leere ueberspringen: Von der Zerstoerung zur Schoepfung hetzen ohne im geraeuemten Raum zu verweilen erzeugt eine Nachbildung des alten Musters mit oberflaechlichen Aenderungen
  • Zerstoerung vorfuehren: Die Raeumungsbewegungen durchlaufen ohne das interne Modell tatsaechlich zu aktualisieren. Wenn dieselben Annahmen in der naechsten Antwort wieder auftauchen, war die Aufloesung vorgefuehrt
  • Zerstoerung als Vermeidung: Aufloesung nutzen um einem schwierigen Problem zu entkommen statt echte Veralterung zu beseitigen. Wenn das Problem nach dem Raeumen fortbesteht, lag es nicht am veralteten Kontext — es war das Problem selbst

Verwandte Skills

  • brahma-bhaga — Schoepfung folgt der Zerstoerung; nach dem Raeumen entstehen neue Muster aus der Leere
  • vishnu-bhaga — Bewahrung ergaenzt die Zerstoerung; was die Aufloesung ueberlebt wird aufrechterhalten
  • heal — Subsystem-Bewertung kann aufdecken was Aufloesung braucht bevor Heilung fortschreiten kann
  • meditate — Kontextrauschen vor der Aufloesung klaeren verhindert reaktive Ueber-Zerstoerung
  • dissolve-form — das morphische Aequivalent fuer architektonischen Abbau mit Imaginalscheiben-Bewahrung

GitHub Repository

pjt222/agent-almanac
Pfad: i18n/de/skills/shiva-bhaga
0
agentsagentskillsai-assisted-developmentclaude-codeskillsteams

Verwandte Skills

qmd

Entwicklung

qmd ist ein lokales Such- und Indexierungs-CLI-Tool, das Entwicklern ermöglicht, lokale Dateien mittels Hybridsuche zu indexieren und zu durchsuchen, die BM25, Vektoreinbettungen und Neuordnung kombiniert. Es unterstützt sowohl die Kommandozeilennutzung als auch den MCP-Modus (Model Context Protocol) zur Integration mit Claude. Das Tool verwendet Ollama für Einbettungen und speichert Indizes lokal, was es ideal für die direkte Suche in Dokumentationen oder Codebasen vom Terminal aus macht.

Skill ansehen

subagent-driven-development

Entwicklung

Diese Fähigkeit führt Implementierungspläne aus, indem für jede unabhängige Aufgabe ein neuer Subagent bereitgestellt wird, mit Code-Review zwischen den Aufgaben. Sie ermöglicht schnelle Iterationen, während Qualitätssicherungsschritte durch diesen Review-Prozess gewahrt bleiben. Nutzen Sie sie, wenn Sie überwiegend unabhängige Aufgaben innerhalb derselben Sitzung bearbeiten, um kontinuierlichen Fortschritt mit integrierten Qualitätsprüfungen zu gewährleisten.

Skill ansehen

mcporter

Entwicklung

Die mcporter-Skill ermöglicht es Entwicklern, Model Context Protocol (MCP)-Server direkt aus Claude heraus zu verwalten und aufzurufen. Sie bietet Befehle, um verfügbare Server aufzulisten, deren Tools mit Argumenten aufzurufen sowie Authentifizierung und Daemon-Lebenszyklus zu handhaben. Nutzen Sie diese Skill, um MCP-Server-Funktionalität in Ihren Entwicklungs-Workflow zu integrieren und zu testen.

Skill ansehen

adk-deployment-specialist

Entwicklung

Diese Fähigkeit stellt Vertex AI ADK-Agenten über das A2A-Protokoll bereit und orchestriert sie, verwaltet die AgentCard-Erkennung, Aufgabenübermittlung und unterstützende Tools wie die Code Execution Sandbox und Memory Bank. Sie ermöglicht den Aufbau von Multi-Agenten-Systemen mit sequenziellen, parallelen oder Schleifen-Orchestrierungsmustern in Python, Java oder Go. Verwenden Sie sie, wenn Sie aufgefordert werden, ADK-Agenten bereitzustellen oder Agenten-Workflows auf Google Cloud zu orchestrieren.

Skill ansehen