---

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.

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