shiva-bhaga
Acerca de
La habilidad `shiva-bhaga` realiza una purga controlada de contexto y eliminación de código muerto, desmantelando patrones obsoletos y suposiciones en el razonamiento de IA. Está diseñada para que los desarrolladores la utilicen cuando sea necesario descartar un enfoque fallido, el contexto acumulado genere ruido o un cambio importante requiera liberar espacio. Esto crea un espacio intencional para nuevas soluciones al disolver el apego a métodos anticuados.
Instalación rápida
Claude Code
Recomendadonpx skills add pjt222/agent-almanac -a claude-code/plugin add https://github.com/pjt222/agent-almanacgit clone https://github.com/pjt222/agent-almanac.git ~/.claude/skills/shiva-bhagaCopia y pega este comando en Claude Code para instalar esta habilidad
Documentación
シヴァ・バーガ
Controlled destruction and dissolution of stale patterns, outdated assumptions, and accumulated noise — clearing the ground so new growth can emerge.
使用タイミング
- Context has accumulated stale assumptions that are silently distorting reasoning
- A previous approach has failed and the temptation is to patch rather than discard
- The conversation has grown long and earlier decisions may no longer serve the current goal
- Dead code, abandoned plans, or zombie tasks are creating noise and confusion
- Before a major pivot — clearing must precede creation
- When attachment to a particular approach is preventing consideration of alternatives
入力
- 必須: Current conversation state or project context (available implicitly)
- 任意: Specific target for dissolution (e.g., "this approach isn't working," "clear all assumptions about the database layer")
- 任意: Scope boundary — what must be preserved through the destruction
手順
ステップ1: Identify What Must End
Survey the current state and mark what is stale, broken, or no longer serving the goal.
Dissolution Triage:
+---------------------+---------------------------+------------------------+
| Category | Symptoms | Action |
+---------------------+---------------------------+------------------------+
| Stale Assumptions | Decisions made early that | List and re-evaluate |
| | no longer match current | each against current |
| | understanding | reality |
+---------------------+---------------------------+------------------------+
| Failed Approaches | Approaches attempted and | Acknowledge failure |
| | abandoned but still | explicitly; release |
| | influencing thinking | the sunk cost |
+---------------------+---------------------------+------------------------+
| Accumulated Noise | Context, variables, or | Identify and mark for |
| | plans that are no longer | removal |
| | referenced or relevant | |
+---------------------+---------------------------+------------------------+
| Attachment Points | "We already decided..." | Question whether the |
| | beliefs that resist | decision still holds |
| | re-examination | |
+---------------------+---------------------------+------------------------+
| Zombie Artifacts | Code, tasks, or plans | Delete or archive; |
| | that exist but serve no | do not leave in limbo |
| | current purpose | |
+---------------------+---------------------------+------------------------+
- Scan each category honestly — resistance to examining a category is itself a signal
- For each item found, ask: "If I were starting fresh right now, would I create this?"
- If the answer is no, mark it for dissolution
期待結果: A clear inventory of what needs to be released, with specific items in each category.
失敗時: If nothing seems stale, the assessment may be too shallow. Pick the oldest decision in the current context and justify it from scratch — if the justification feels forced, it is a candidate for dissolution.
ステップ2: Establish the Preservation Boundary
Not everything should be destroyed. Identify what must survive the clearing.
- Core requirements: What did the user actually ask for? This survives.
- Verified knowledge: Facts confirmed through tool use (file reads, test results) survive.
- User preferences: Explicitly stated preferences and constraints survive.
- Working components: Code or approaches that are demonstrably functioning survive.
Draw the boundary: everything inside is preserved, everything outside is subject to dissolution.
期待結果: A clear distinction between what is kept and what is released.
失敗時: If the boundary is unclear, ask: "What would I need to reconstruct if I started this task from scratch?" The answer defines the preservation boundary.
ステップ3: Dissolve with Intention
Execute the dissolution — not as abandonment but as intentional clearing.
- For each marked item, release it explicitly:
- Stale assumption: "I assumed X, but current evidence shows Y. Releasing X."
- Failed approach: "Approach A was attempted and did not work because Z. Releasing attachment to A."
- Noise: "Variable/plan/context Q is no longer relevant. Removing from consideration."
- Do not justify or defend what is being dissolved — the point is release, not analysis
- If dissolving a large body of accumulated context, summarize what was dissolved and why in one sentence
- Clear the workspace: if applicable, close abandoned files, reset mental model, acknowledge the clean slate
期待結果: A lighter, cleaner context with stale elements removed. The remaining context should feel accurate and current.
失敗時: If dissolution feels incomplete — some released items keep influencing thinking — name them again explicitly. "I notice I am still reasoning as if X is true. X was dissolved. Proceeding without X."
ステップ4: Sit in the Void
After destruction, resist the urge to immediately rebuild. The space between destruction and creation has value.
- Acknowledge the cleared space: "The following has been dissolved: [list]"
- Note what remains: "What survives: [list]"
- Resist premature reconstruction — do not immediately propose a replacement for what was dissolved
- Allow the cleared space to inform what comes next
- The void is not emptiness — it is potential. The next step (creation via
brahma-bhagaor preservation viavishnu-bhaga) emerges from this space
期待結果: A moment of clarity between the old and the new. The next direction becomes apparent from what remains rather than being forced.
失敗時: If the void feels uncomfortable and there is a strong pull to immediately rebuild, that urgency is itself a signal — it may indicate attachment to the dissolved pattern. Sit longer. The right next step will emerge.
バリデーション
- Stale assumptions were identified and explicitly released
- Failed approaches were acknowledged without defensiveness
- Accumulated noise was cleared from the working context
- The preservation boundary was established before dissolution
- Core requirements and user preferences were preserved
- The cleared space was acknowledged before moving to creation
よくある落とし穴
- Destroying too much: Dissolution without a preservation boundary destroys working components along with stale ones. Always draw the boundary first
- Destroying too little: Polite dissolution that "releases" things while still letting them influence reasoning. True dissolution requires actually letting go
- Skipping the void: Rushing from destruction to creation without sitting in the cleared space produces a recreation of the old pattern with superficial changes
- Performing destruction: Going through the motions of clearing without actually updating the internal model. If the same assumptions reappear in the next response, dissolution was performative
- Destruction as avoidance: Using dissolution to escape a difficult problem rather than to clear genuine staleness. If the problem persists after clearing, it was not the stale context — it was the problem itself
関連スキル
brahma-bhaga— creation follows destruction; after clearing, new patterns emerge from the voidvishnu-bhaga— preservation complements destruction; what survives dissolution is sustainedheal— subsystem assessment may reveal what needs dissolution before healing can proceedmeditate— clearing context noise before dissolution prevents reactive over-destructiondissolve-form— the morphic equivalent for architectural dismantling with imaginal disc preservation
Repositorio GitHub
Habilidades relacionadas
content-collections
MetaEsta habilidad proporciona una configuración probada en producción para Content Collections, una herramienta centrada en TypeScript que transforma archivos Markdown/MDX en colecciones de datos con tipado seguro mediante validación Zod. Úsala al construir blogs, sitios de documentación o aplicaciones Vite + React con mucho contenido para garantizar seguridad de tipos y validación automática de contenido. Abarca todo, desde la configuración del plugin de Vite y compilación MDX hasta la optimización de despliegue y validación de esquemas.
polymarket
MetaEsta habilidad permite a los desarrolladores crear aplicaciones con la plataforma de mercados de predicción Polymarket, incluyendo la integración de API para operaciones y datos de mercado. También proporciona transmisión de datos en tiempo real a través de WebSocket para monitorear operaciones en vivo y actividad del mercado. Úsela para implementar estrategias de trading o crear herramientas que procesen actualizaciones de mercado en tiempo real.
creating-opencode-plugins
MetaEsta habilidad ayuda a los desarrolladores a crear complementos de OpenCode que se conectan a más de 25 tipos de eventos, como comandos, archivos y operaciones LSP. Proporciona la estructura del complemento, las especificaciones de la API de eventos y los patrones de implementación para módulos en JavaScript/TypeScript. Úsala cuando necesites interceptar, monitorear o extender el ciclo de vida del asistente de IA de OpenCode con lógica personalizada basada en eventos.
sglang
MetaSGLang es un framework de alto rendimiento para el servicio de LLM que se especializa en generación rápida y estructurada para JSON, expresiones regulares y flujos de trabajo de agentes utilizando su caché de prefijos RadixAttention. Ofrece una inferencia significativamente más rápida, especialmente para tareas con prefijos repetidos, lo que lo hace ideal para salidas complejas y estructuradas, y conversaciones multiturno. Elige SGLang sobre alternativas como vLLM cuando necesites decodificación restringida o estés construyendo aplicaciones con uso extensivo de prefijos compartidos.
