MCP HubMCP Hub
Retour aux compétences

shiva-bhaga

pjt222
Mis à jour Yesterday
4 vues
17
2
17
Voir sur GitHub
Développementgeneral

À propos

La compétence shiva-bhaga effectue une destruction contrôlée en effaçant le contexte obsolète, en supprimant les hypothèses dépassées et en éliminant le code mort ou les approches ayant échoué. Elle est conçue pour créer un espace à une nouvelle création en dissolvant consciemment l'attachement à des schémas dépassés. Utilisez-la lorsque le contexte a accumulé des hypothèses périmées, lorsqu'une direction nécessite un pivot majeur, ou lorsque des tâches zombies et du code mort génèrent du bruit.

Installation rapide

Claude Code

Recommandé
Principal
npx skills add pjt222/agent-almanac -a claude-code
Commande PluginAlternatif
/plugin add https://github.com/pjt222/agent-almanac
Git CloneAlternatif
git clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/shiva-bhaga

Copiez et collez cette commande dans Claude Code pour installer cette compétence

Documentation

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

Dépôt GitHub

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

Compétences associées

qmd

Développement

qmd est un outil CLI de recherche et d'indexation locale qui permet aux développeurs d'indexer et de rechercher dans des fichiers locaux en utilisant une recherche hybride combinant BM25, des embeddings vectoriels et du reranking. Il prend en charge à la fois une utilisation en ligne de commande et un mode MCP (Model Context Protocol) pour l'intégration avec Claude. L'outil utilise Ollama pour les embeddings et stocke les index localement, ce qui le rend idéal pour rechercher dans de la documentation ou des bases de code directement depuis le terminal.

Voir la compétence

subagent-driven-development

Développement

Cette compétence exécute des plans de mise en œuvre en déployant un nouveau sous-agent pour chaque tâche indépendante, avec une revue de code entre les tâches. Elle permet une itération rapide tout en maintenant des contrôles de qualité grâce à ce processus de revue. Utilisez-la lorsque vous travaillez sur des tâches principalement indépendantes au sein d'une même session pour assurer une progression continue avec des vérifications de qualité intégrées.

Voir la compétence

mcporter

Développement

La compétence mcporter permet aux développeurs de gérer et d'appeler des serveurs Model Context Protocol (MCP) directement depuis Claude. Elle fournit des commandes pour lister les serveurs disponibles, appeler leurs outils avec des arguments, et gérer l'authentification ainsi que le cycle de vie du démon. Utilisez cette compétence pour intégrer et tester les fonctionnalités des serveurs MCP dans votre flux de travail de développement.

Voir la compétence

adk-deployment-specialist

Développement

Cette compétence déploie et orchestre des agents Vertex AI ADK en utilisant le protocole A2A, gérant la découverte d'AgentCard, la soumission de tâches, et prenant en charge des outils tels que le bac à sable d'exécution de code et la banque de mémoire. Elle permet de construire des systèmes multi-agents avec des modèles d'orchestration séquentiels, parallèles ou en boucle en Python, Java ou Go. Utilisez-la lorsqu'on vous demande de déployer des agents ADK ou d'orchestrer des flux de travail d'agents sur Google Cloud.

Voir la compétence