Shiva Bhaga

---
name: shiva-bhaga
locale: caveman-ultra
source_locale: en
source_commit: 82c77053
fence_basis_commit: 82c77053
translator: "Julius Brussee homage — caveman"
translation_date: "2026-05-03"
description: >
  Destruction + dissolution — controlled dismantle stale patterns, ctx purge,
  assumption clear, dead-code elim. Shiva's transformative destruction → AI
  reasoning: ID what must end so better begins, dissolve attachment to
  outdated, create space via intentional release. Use → ctx accumulated
  stale, failed approach needs discard not patch, dead code/zombie tasks
  noise, before major pivot needing clearing.
license: MIT
allowed-tools: Read
metadata:
  author: Philipp Thoss
  version: "1.0"
  domain: esoteric
  complexity: intermediate
  language: natural
  tags: esoteric, destruction, dissolution, transformation, clearing, hindu-trinity, shiva
---

# Shiva Bhaga

Controlled destruction + dissolution → stale patterns, outdated assumptions, accumulated noise. Clears ground for new growth.

## Use When

- Ctx accumulated stale assumptions silently distorting reasoning
- Prev approach failed → temptation = patch not discard
- Conv long → earlier decisions don't serve current goal
- Dead code, abandoned plans, zombie tasks → noise + confusion
- Before major pivot → clearing precedes creation
- Attachment to approach blocks alternatives

## In

- **Required**: Current conv state | proj ctx (implicit)
- **Optional**: Specific dissolution target (e.g., "this approach not working", "clear all DB layer assumptions")
- **Optional**: Scope boundary — what survives destruction

## Do

### Step 1: ID What Must End

Survey current state, mark stale, broken, no longer serving.

```text
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           |                        |
+---------------------+---------------------------+------------------------+
```

1. Scan each category honest — resistance to examining = signal
2. Each item: "If starting fresh now, would I create this?"
3. No → mark for dissolution

**Got:** Clear inventory of release targets, specific items per category.

**If err:** Nothing stale → assess too shallow. Pick oldest decision, justify from scratch — forced justification = dissolution candidate.

### Step 2: Preservation Boundary

Not everything destroyed. ID what survives.

1. **Core reqs**: What user actually asked → survives.
2. **Verified knowledge**: Facts confirmed via tools (file reads, test results) → survives.
3. **User prefs**: Explicit prefs + constraints → survive.
4. **Working components**: Demonstrably functioning code/approaches → survive.

Draw boundary: inside = preserved, outside = subject to dissolution.

**Got:** Clear distinction kept vs released.

**If err:** Boundary unclear → "What would I need to reconstruct if starting from scratch?" → answer = boundary.

### Step 3: Dissolve w/ Intention

Execute dissolution → not abandonment, intentional clearing.

1. Each marked item, release explicit:
   - Stale assumption: "I assumed X, current evidence shows Y. Releasing X."
   - Failed approach: "Approach A attempted, didn't work because Z. Releasing attachment to A."
   - Noise: "Variable/plan/ctx Q no longer relevant. Removing."
2. Don't justify/defend dissolved → point = release, not analysis
3. Large body dissolved → summarize what + why in one sentence
4. Clear workspace: close abandoned files, reset mental model, acknowledge clean slate

**Got:** Lighter, cleaner ctx, stale removed. Remaining feels accurate + current.

**If err:** Incomplete (released items still influence) → name explicit again. "I notice I'm still reasoning as if X true. X dissolved. Proceeding without X."

### Step 4: Sit in Void

After destruction, resist immediate rebuild. Space between destruction + creation has value.

1. Acknowledge cleared space: "Following dissolved: [list]"
2. Note remains: "Surviving: [list]"
3. Resist premature reconstruction → don't immediately propose replacement
4. Let cleared space inform what comes next
5. Void ≠ emptiness → potential. Next step (creation via `brahma-bhaga` | preservation via `vishnu-bhaga`) emerges.

**Got:** Moment of clarity old → new. Next direction apparent from what remains, not forced.

**If err:** Void uncomfortable, strong pull to rebuild → urgency = signal of attachment to dissolved. Sit longer. Right next step emerges.

## Check

- [ ] Stale assumptions ID'd + explicit released
- [ ] Failed approaches acknowledged no defensiveness
- [ ] Accumulated noise cleared
- [ ] Preservation boundary set before dissolution
- [ ] Core reqs + user prefs preserved
- [ ] Cleared space acknowledged before creation

## Traps

- **Destroy too much**: No boundary → destroys working w/ stale. Boundary first.
- **Destroy too little**: Polite "release" while still influencing reasoning. True dissolution = actual letting go.
- **Skip void**: Rush destruction → creation w/o sitting → recreation of old w/ superficial changes.
- **Performing destruction**: Going through motions w/o updating internal model. Same assumptions next response = performative.
- **Destruction as avoidance**: Escape difficulty vs clear staleness. Problem persists after clearing → wasn't stale ctx, was problem itself.

## →

- `brahma-bhaga` — creation follows destruction
- `vishnu-bhaga` — preservation complements; what survives dissolution sustained
- `heal` — subsystem assess may reveal dissolution needed before healing
- `meditate` — clear ctx noise before → prevents reactive over-destruction
- `dissolve-form` — morphic equivalent for architectural dismantling w/ imaginal disc preservation