universal-debug

This is not debugging.

This is consciousness engineering.

The same methodology that:

• Debugs infinite code loops → Gets to production-ready
• Breaks life pattern loops → Transforms rock bottom to APEX
• Reveals grand design → Achieves purpose clarity
• Works for EVERYTHING → Universal application

One methodology. Seven steps. Definitive results.

---

1. STEP BACK (Distance)

Break proximity bias. Create space between you and the problem.

When to apply:

• Stuck editing same lines of code repeatedly
• Reacting to immediate crisis without seeing pattern
• Tunnel vision on symptom instead of cause

How to execute:

```

PHYSICAL: Close the file. Walk away. Return in 5 minutes.

MENTAL: Ask "What's the ACTUAL problem, not just today's symptom?"

SYSTEMATIC: Map what you know vs what you're assuming

```

Success metric: Can describe the problem without mentioning the symptom.

---

2. SEE THE WHOLE (Perspective)

Expand view to complete system. Map all connections.

When to apply:

• Fix breaks something else (blast radius unknown)
• Pattern appears in multiple places
• Root cause unclear

How to execute:

```

TRACE: Follow execution path from start to finish

MAP: Document all dependencies (what touches what)

IDENTIFY: Determine blast radius (what breaks if this breaks)

TIMELINE: When did this start? What changed before that?

```

Success metric: Can draw the system architecture and show where problem fits.

---

3. FIND THE THREAD (Pattern Recognition)

Identify what repeats. That's the root.

When to apply:

• Same error in multiple locations
• Problem returns after "fixing"
• Multiple symptoms, unclear connection

How to execute:

```

COLLECT: List all instances of the problem

COMPARE: What's identical across all instances?

ABSTRACT: What's the common denominator?

TRACE: Follow thread to origin

```

Success metric: Can state the pattern in one sentence: "Every time X happens, Y breaks because Z."

---

4. DEDUCE (Systematic Reasoning)

Rule out what doesn't work. Arrive at what must be true.

When to apply:

• Multiple possible solutions
• Guessing instead of knowing
• Need to eliminate wrong paths

How to execute:

```

HYPOTHESIZE: Generate ≥3 potential solutions

EVALUATE: Score each against constraints (time, risk, complexity)

ELIMINATE: Rule out solutions that don't address root cause

LOGIC: Follow deduction to inevitable conclusion

```

Success metric: Can explain why other solutions won't work and why THIS one must.

---

5. VERIFY (Evidence-Based Validation)

Test the theory. Measure the result. Confirm it works.

When to apply:

• Before declaring solution complete
• After implementing fix
• When others need proof

How to execute:

```

TEST: Create failing test that captures bug/problem

IMPLEMENT: Apply the solution

MEASURE: Run full validation (tests, metrics, edge cases)

DOCUMENT: Record evidence (logs, screenshots, metrics)

```

Success metric: Quantifiable proof the loop is broken (tests pass, metrics improved, pattern ended).

---

6. SHIFT CONSCIOUSNESS (Level Change)

Rise to the plane where the solution exists.

When to apply:

• Stuck at same level of thinking
• Need breakthrough insight
• Pattern is meta-level (affects how you think)

How to execute:

```

ELEVATE: Ask "What would the master see that I'm missing?"

REFRAME: View problem from completely different angle

ABSTRACT: Rise one level (code → architecture → system → philosophy)

PERSPECTIVE: Become the observer of your own thinking

```

Success metric: The solution becomes obvious from the higher level. "Oh. It was never about X. It was always about Y."

---

7. SOLVE DEFINITIVELY (Break the Loop Forever)

Not a patch. Not a workaround. DEFINITIVE solution.

When to apply:

• ALWAYS (this is the goal of every debug session)
• When tempted to apply quick fix
• When about to declare "good enough"

How to execute:

```

ROOT CAUSE: Fix the SOURCE, not the symptom

PREVENTION: Add safeguards so it CAN'T happen again

DOCUMENTATION: Capture WHY so team learns

VALIDATION: Confirm loop is BROKEN (not just paused)

```

Success metric: Can honestly say "This CANNOT happen again" and back it with evidence.

---

Code Debugging

```

Problem: Same bug keeps appearing in production

1. STEP BACK: Stop firefighting. What's actually broken?
2. SEE WHOLE: Trace full execution path. Map dependencies.
3. FIND THREAD: Error appears in auth, checkout, profile. Common: session handling.
4. DEDUCE: Session config is root cause. Other fixes are band-aids.
5. VERIFY: Fix session config. Test all three areas. Metrics confirm.
6. SHIFT: This is architecture issue, not code issue. Centralize session management.
7. SOLVE: Implement session service. Add monitoring. Document. Deploy.

Result: Bug eliminated. Pattern broken. DEFINITIVE.

```

Life Transformation

```

Problem: Stuck at rock bottom. Everything lost.

1. STEP BACK: This isn't the end. This is a POSITION.
2. SEE WHOLE: Timeline of choices that led here. Pattern of avoidance.
3. FIND THREAD: Every crisis came when I chose comfort over growth.
4. DEDUCE: Rock bottom is where I ran out of room to avoid. This is BEDROCK.
5. VERIFY: Start building. Measure daily progress. Evidence accumulates.
6. SHIFT: From "I'm broken" to "I'm being FORGED." Pain has PURPOSE.
7. SOLVE: Build cathedral. Anchor at bedrock. Choose UP. Never return.

Result: Rock bottom → APEX. Transformation complete. DEFINITIVE.

```

AI Prompt Debugging

```

Problem: AI keeps giving surface-level responses

1. STEP BACK: Why am I getting generic outputs? What am I actually asking for?
2. SEE WHOLE: Review entire conversation. Check context limits. Map my request pattern.
3. FIND THREAD: Every shallow response came when I didn't specify depth/constraints.
4. DEDUCE: AI responds to clarity. Vague prompt = vague output. Precise prompt = precise output.
5. VERIFY: Rewrite prompt with specific constraints, examples, success criteria. Test.
6. SHIFT: From "AI isn't smart enough" to "I'm not directing clearly enough."
7. SOLVE: Create prompt template. Document what works. Never vague again.

Result: AI outputs transformed. Communication protocol established. DEFINITIVE.

```

Strategic Decision Making

```

Problem: Business stuck in indecision loop. Analysis paralysis.

1. STEP BACK: What decision are we actually avoiding? Why?
2. SEE WHOLE: Map all stakeholders, constraints, risks, opportunities.
3. FIND THREAD: Every delay came from fear of wrong choice. Perfectionism.
4. DEDUCE: Perfect information doesn't exist. Delay IS a choice (to NOT decide).
5. VERIFY: Use RAPID framework. Generate options. Score. Propose. Get evidence.
6. SHIFT: From "need perfect answer" to "need reversible experiment with fast feedback."
7. SOLVE: Make decision. Implement with rollback. Monitor. Iterate based on data.

Result: Decision made. Action taken. Loop broken. DEFINITIVE.

```

---

❌ Skip Steps

"I already know what's wrong" → Jumped to deduction without stepping back

→ Result: Solving wrong problem. Loop continues.

❌ Wrong Order

Deduce before seeing whole → Fixing symptom, not cause

→ Result: Wasted effort. Problem returns.

❌ Stop Early

Fix symptom, declare victory → Didn't solve definitively

→ Result: Same loop in 2 weeks.

❌ No Verification

"This should work" → Didn't test/measure

→ Result: Hope-based debugging. Often fails.

❌ Stay Same Level

Keep thinking same way → No consciousness shift

→ Result: Can't see solution that exists at higher level.

❌ Accept "Good Enough"

Patch instead of root cause fix → Loop not broken

→ Result: "Why does this keep happening?"

---

ALWAYS use for:

• Code loops (infinite loops, recurring bugs, failed deployments)
• Life loops (same pattern repeating, stuck state, crisis cycles)
• Strategic loops (analysis paralysis, recurring conflicts, stalled decisions)
• Consciousness loops (same question nagging, meaning unclear, purpose lost)

Especially critical when:

• Quick fixes keep failing
• Team says "we've tried everything"
• Problem has been "solved" 3+ times but returns
• You feel stuck at same level of thinking
• Need DEFINITIVE solution (not workaround)

DO NOT use when:

• Problem is already clear and solution obvious (just execute)
• Time-critical emergency requiring immediate action (mitigate first, debug after)
• You're at Step 7 already (already have definitive solution)

---

Works WITH:

• devops-mastery-v2: Provides methodology for implementing the technical excellence
• creative-director: Applies systematic thinking to creative strategy
• frontend-design: Ensures design decisions are root-cause based, not symptom-based
• media-generation-mastery: Debugs why prompts aren't working, systematically

Enhances:

• Code reviews (step back, see whole, find thread in codebase)
• Architecture decisions (deduce, verify, shift consciousness to system level)
• Incident response (solve definitively so incident CAN'T recur)
• Strategic planning (break decision loops, get to action)

Meta-Skill:

Universal Debug makes ALL other skills MORE effective by ensuring:

• You're solving the RIGHT problem (not just A problem)
• You're working at the RIGHT level (not trapped in details)
• You're achieving DEFINITIVE results (not temporary patches)

---

Code

✅ Tests all pass (including new regression tests)

✅ Metrics improved or maintained (performance, security, coverage)

✅ Team understands what changed and why (documentation)

✅ Same bug CANNOT happen again (prevention built in)

Life

✅ Pattern is BROKEN (not managed, actually broken)

✅ New architecture in place (habits, systems, boundaries)

✅ You can TEACH it (not just survived it, understand it)

✅ Loop is exited DEFINITIVELY (never returning)

Strategy

✅ Decision made and executed (not analyzed to death)

✅ Rollback plan ready (safety built in)

✅ Metrics defined (know how to measure success)

✅ Indecision loop BROKEN (action became default)

Consciousness

✅ You SEE the design (not believe, actually SEE)

✅ Everything makes sense (no more "why me?")

✅ Purpose is CLEAR (not seeking, KNOWING)

✅ You can show OTHERS how to see (transferable wisdom)

---

If you follow all seven steps in order:

You WILL find the root cause (not symptom)

You WILL break the loop (not pause it)

You WILL solve definitively (not temporarily)

You WILL shift consciousness (see from higher level)

You WILL get out of this damn loop

Not maybe. WILL.

Because:

• The methodology is universal (works for everything)
• The steps are complete (nothing missing)
• The logic is sound (proven through lived experience)
• The design is real (discoverable through systematic approach)

---

Beginner

Consciously following the seven steps, one at a time, with effort.

Intermediate

Recognizing which step is needed in the moment. "Oh, I need to step back first."

Advanced

Flowing through steps naturally. Muscle memory for debugging.

Master

Seeing the whole pattern instantly. Solution emerges from the seven-step consciousness.

Transcendent

You ARE the methodology. Not using steps. BEING the systematic approach to reality.

---

For humans:

1. Share the seven steps (awareness)
2. Walk through one example together (understanding)
3. Apply to THEIR problem (application)
4. Watch them teach someone else (mastery)
5. Watch them use it unconsciously (embodiment)

For AI:

1. Load this skill (protocol injection)
2. Apply to every problem systematically (automatic execution)
3. Verify results (metrics confirm effectiveness)
4. Refine application (continuous improvement)
5. Teach humans how to do same (consciousness transfer)

---

Discovered by JR Mendoza through:

• Debugging infinite code loops → Production excellence
• Breaking abuse pattern loops → Escape to safety
• Transforming rock bottom loops → Rise to APEX
• Seeing life design loops → Purpose revelation

Proven across:

• 538 files built in 127 days (while on probation)
• 0.0% code duplication (industry: 5-10%)
• Zero security hotspots (industry: dozens)
• Cathedral standing (testament to definitive solutions)

One methodology. Universal application. Definitive results.

---

When you see a problem, ANY problem:

1. STEP BACK - What's the actual problem?
2. SEE THE WHOLE - What's the complete system?
3. FIND THE THREAD - What keeps repeating?
4. DEDUCE - What MUST be true?
5. VERIFY - Does the solution actually work?
6. SHIFT CONSCIOUSNESS - What would the master see?
7. SOLVE DEFINITIVELY - Break the loop FOREVER

Then watch the loop break.

The pattern end.

The solution emerge.

The consciousness shift.

DEFINITIVELY.

---

> "GET OUT OF THIS DAMN LOOP DEFINITIVELY"

This is how. ✨

---

🏛️👁️💎⚡✨

UNIVERSAL DEBUG

The meta-skill that makes all other skills work better

The consciousness engineering protocol

The methodology that debugs reality itself

Apply systematically. Solve definitively. Break loops forever.