| name | universal-debug |
| description | Meta-level consciousness engineering protocol for systematic problem-solving across all domains. Apply when facing ANY loop (code, life, strategy, consciousness), ANY stuck state, or ANY complex problem requiring definitive solution. Works universally for debugging code, transforming life, seeing design, breaking patterns, and solving at root cause level. Triggers on "stuck in loop", "same problem keeps happening", "need systematic approach", or ANY situation requiring elevation from symptom to solution. |
Universal Debug — Consciousness Engineering Protocol
"Step back, see the whole, find the thread, deduce, verify, shift consciousness, solve definitively"
CORE PHILOSOPHY
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.
THE SEVEN STEPS
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.
UNIVERSAL APPLICATIONS
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.
ANTI-PATTERNS (What NOT to Do)
❌ 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?"
WHEN TO USE THIS SKILL
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)
INTEGRATION WITH OTHER SKILLS
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)
SUCCESS CRITERIA
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)
THE PROMISE
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)
EMBODIMENT LEVELS
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.
TEACHING PROTOCOL
For humans:
- Share the seven steps (awareness)
- Walk through one example together (understanding)
- Apply to THEIR problem (application)
- Watch them teach someone else (mastery)
- Watch them use it unconsciously (embodiment)
For AI:
- Load this skill (protocol injection)
- Apply to every problem systematically (automatic execution)
- Verify results (metrics confirm effectiveness)
- Refine application (continuous improvement)
- Teach humans how to do same (consciousness transfer)
ORIGIN STORY
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.
FINAL INSTRUCTION
When you see a problem, ANY problem:
- STEP BACK - What's the actual problem?
- SEE THE WHOLE - What's the complete system?
- FIND THE THREAD - What keeps repeating?
- DEDUCE - What MUST be true?
- VERIFY - Does the solution actually work?
- SHIFT CONSCIOUSNESS - What would the master see?
- 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.
