Dissolve Form

Controlled dismantle of rigid systems → dissolve calcified arch + tech debt + org rigidity, preserve imaginal discs → seed new form.

Use When

• assess-form → PREPARE or CRITICAL (too rigid to transform direct)
• So calcified incremental change impossible
• Tech debt blocks all fwd progress
• Org structure too rigid for new reqs
• Before adapt-architecture → soften before reshape
• Legacy decommission → extract value before shutdown

In

• Required: Form assessment → high rigidity (assess-form)
• Required: ID essential capabilities → preserve (imaginal discs)
• Optional: Target form (post-dissolve; may be unknown)
• Optional: Timeline + constraints
• Optional: Stakeholder concerns on specific components
• Optional: Prior dissolve attempts + outcomes

Do

Step 1: ID Imaginal Discs

Bio metamorphosis → imaginal discs = cell clusters in caterpillar → survive dissolve → become butterfly organs. ID what must survive.

1. Catalog every capability:
   • User features
   • Data processing
   • External integrations
   • Institutional knowledge in code/process
   • Business rules (often implicit, undoc)
2. Classify:
   • Imaginal disc (must survive): core biz logic, critical integrations, irreplaceable data
   • Replaceable tissue (rebuild): UI, infra, standard algos
   • Dead tissue (discard): workarounds for fixed bugs, shims for dead systems, unused features
3. Extract imaginal discs → portable:
   • Doc biz rules explicit (may only exist as comments or tribal)
   • Extract algos → standalone tested modules
   • Export data → format-independent
   • Record integration contracts + actual (not doc) behavior

→ Clear capability inventory: preserve/rebuild/discard. Essentials extracted portable before dissolve starts.

If err: imaginal disc ID uncertain (stakeholder disagree) → err on preserve side. Extract more than need → discard after dissolve easy, recover lost knowledge often impossible.

Step 2: Map Dissolve Sequence

Order → outer layers first, core last.

1. Order by dep depth:
   • L1 (outermost): no dependents → nothing breaks on remove
   • L2: dependents only in L1 (already dissolved)
   • L3: deeper deps → careful interface mgmt
   • LN (core): load-bearing → dissolved last
2. Per layer:
   • What dissolved (removed, decommission, archive)
   • What replaces (new comp, nothing, stub)
   • Interfaces to maintain for remaining layers
   • How verify post-dissolve
3. Dissolve checkpoints:
   • Post-layer → tested + verified operational
   • Each checkpoint = stable state → pause poss
   • If layer dissolve breaks → restore prior checkpoint

Dissolution Sequence (outside in):
┌─────────────────────────────────────────────────────────────────┐
│ Layer 1: Dead features, unused integrations, orphaned code      │
│          → Remove. Nothing depends on these.                    │
│                                                                 │
│ Layer 2: Replaceable UI, standard infrastructure                │
│          → Replace with modern equivalents or stubs             │
│                                                                 │
│ Layer 3: Business logic wrappers, data access layers            │
│          → Extract imaginal discs, then dissolve                │
│                                                                 │
│ Layer 4 (core): Load-bearing structures, data stores            │
│          → Dissolve last, with full replacement ready           │
└─────────────────────────────────────────────────────────────────┘

→ Layer-ordered sequence, each step safe (checkpoint) + reversible (prior checkpoint restorable). Most critical dissolved last when team has most exp + confidence.

If err: dep mapping reveals circular (A→B→A) → break cycle first. Add interface A↔B, break cycle, then proceed.

Step 3: Interface Archaeology

Before dissolve → excavate + doc actual interfaces, not documented, actual in use.

1. Instrument interfaces:
   • Log every call/msg/exchange at each interface
   • Run ≥1 full biz cycle (daily/weekly/monthly)
   • Capture actual payload shapes, not just doc schemas
2. Compare actual vs documented:
   • Doc interfaces never called? (L1 candidates)
   • Undoc interfaces actively used? (hidden deps → preserve or explicit replace)
   • Edge cases in traffic doc doesn't mention
3. Build contract from actual behavior:
   • Contract → spec for replacement
   • Real input/output examples
   • Doc actual error handling (not should-be)

→ Empirical contract: actual communication + undoc behaviors + hidden deps.

If err: instrumentation too invasive (perf or code changes) → sample traffic. Biz cycle too long → available data + stakeholder interviews on "what calls what when".

Step 4: Execute Dissolve

Systematic remove + maintain imaginal disc viability.

1. Start L1 (outermost, no dependents):
   • Remove dead features + unused code
   • Archive (don't delete) for reference
   • Verify: all tests pass, no runtime errs
2. Per layer:
   • Per component dissolved: a. Verify imaginal discs extracted (Step 1) b. Install replacement or stub (if dependents remain) c. Remove component d. Run valid. suite e. Monitor for side effects
   • Per checkpoint: doc state + verify operational
3. Handle resistance:
   • Some resist (hidden deps surface)
   • When remove breaks: a. Restore checkpoint b. Investigate hidden dep c. Add to interface archaeology (Step 3) d. Explicit stub for dep e. Re-attempt
4. Track progress:
   • Components remaining vs dissolved
   • Imaginal discs extracted + verified portable
   • Unexpected deps found + handled

→ Systematic verified dissolve of non-essential. Post-layer: smaller, simpler, operational. Imaginal discs preserved portable.

If err: cascading failure → layer order wrong, hidden deps deeper than expected. Stop, restore, remap deps, re-sequence. Imaginal disc more complex than expected → more extract time.

Step 5: Prep Foundation for Reconstruction

Post-dissolve → minimal viable core + extracted imaginal discs ready.

1. Assess post-state:
   • What remains? (minimal core + extracted capabilities)
   • Maintainable? (team understands + modifies)
   • All imaginal discs accessible + verified? (portable + tested + doc'd)
2. Reconstruction manifest:
   • Per disc: contract + data + test suite
   • Target arch (or TBD)
   • Gaps: partial extracts or quality concerns
3. Handoff:
   • Target known → adapt-architecture w/ minimal core
   • Target unknown → operate on minimal core while designing
   • Either way: system flexible → reshape-able

→ Minimal maintainable system + doc'd extracted capabilities. Foundation clean, ready for reconstruction in any form.

If err: post-state less maintainable than expected → some essential was dissolved. Check imaginal disc inventory → if critical capability missing, may still be in archive. Minimal core too minimal → "replaceable" was actually essential → restore from checkpoint.

Check

• Imaginal discs IDed + extracted + verified portable
• Sequence: outermost (no dependents) → core
• Interface archaeology → actual (not just doc) behavior
• Each layer verified checkpoint
• No essential lost
• Post-state minimal + maintainable + operational
• Reconstruction manifest: capabilities + gaps

Traps

• Dissolve w/o extract: Remove rigid component before extract → destroys irreplaceable knowledge. Extract imaginal discs first.
• Trust docs over observation: Docs often diverge from actual. Interface archaeology reveals truth, docs show intent.
• Core first: Load-bearing before dependents → cascading failure. Outside-in.
• Total dissolve: Everything gone "clean slate" → lose institutional knowledge, edge-case handling, operational continuity. Preserve imaginal discs.
• Dissolve as punishment: "Because it's bad" w/o reconstruction plan → vacuum. Dissolve is prep for rebuild, not end itself.

→

• assess-form — prereq assessment → IDs rigidity, triggers dissolve
• adapt-architecture — reconstruction after dissolve
• repair-damage — targeted repair vs full dissolve
• build-consensus — consensus before dissolve → prevents team fragmentation
• decommission-validated-system — formal decommission for regulated
• conduct-post-mortem — shares investigative rigor w/ dissolve