Claude Code调试专家子代理实战指南：打造你的Bug终结者

// 场景对比：处理一个神秘的生产环境Bug

// ❌ 通用Claude可能的调试方法
function debugIssue() {
    console.log("checking here...");  // 随意打印
    console.log(data);  // 打印整个对象
    // 猜测问题在这里
    if (someCondition) {
        console.log("maybe problem?");  // 盲目猜测
    }
}
// 问题：没有方法论、信息杂乱、效率低下、找不到根因

// ✅ 调试子代理会给你的专业方案
/**
 * 系统化调试方案：用户反馈生产环境偶发性崩溃
 * 症状：每天2-3次，无规律，影响约0.1%用户
 */

// 第一步：问题复现策略
class BugReproducer {
    constructor() {
        this.attempts = [];
        this.conditions = newMap();
        this.logger = new StructuredLogger();
    }

    // 1. 最小化测试用例
    async createMinimalTestCase() {
        console.log('=== 开始构建最小复现用例 ===');
        
        // 记录所有可能的变量
        const variables = {
            environment: this.captureEnvironment(),
            userAgent: navigator.userAgent,
            timestamp: Date.now(),
            memoryUsage: performance.memory,
            networkCondition: awaitthis.measureNetwork()
        };

        // 二分法隔离问题
        returnthis.binarySearchIsolation(variables);
    }

    // 2. 环境信息收集
    captureEnvironment() {
        return {
            // 浏览器环境
            browser: {
                viewport: { 
                    width: window.innerWidth, 
                    height: window.innerHeight 
                },
                screen: {
                    width: screen.width,
                    height: screen.height,
                    colorDepth: screen.colorDepth
                },
                timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
                language: navigator.language,
                cookieEnabled: navigator.cookieEnabled,
                onLine: navigator.onLine
            },
            // 性能指标
            performance: {
                memory: performance.memory,
                timing: performance.timing,
                navigation: performance.navigation
            },
            // 运行时状态
            runtime: {
                heapUsed: this.getHeapUsage(),
                activeTimers: this.countActiveTimers(),
                eventListeners: this.countEventListeners(),
                domNodes: document.getElementsByTagName('*').length
            }
        };
    }

    // 3. 二分法问题隔离
    async binarySearchIsolation(variables) {
        const steps = [];
        let left = 0;
        let right = Object.keys(variables).length - 1;
        
        while (left <= right) {
            const mid = Math.floor((left + right) / 2);
            const subset = this.getVariableSubset(variables, left, mid);
            
            const canReproduce = awaitthis.tryReproduce(subset);
            steps.push({
                range: [left, mid],
                variables: subset,
                reproduced: canReproduce,
                timestamp: Date.now()
            });

            if (canReproduce) {
                right = mid - 1;  // 问题在前半部分
            } else {
                left = mid + 1;   // 问题在后半部分
            }
        }

        return {
            minimalCase: steps[steps.length - 1],
            allSteps: steps
        };
    }
}

// 第二步：高级调试技术
class AdvancedDebugger {
    constructor() {
        this.breakpoints = newMap();
        this.watchedVariables = newSet();
        this.callStack = [];
        this.performanceMarks = newMap();
    }

    // 1. 条件断点
    setConditionalBreakpoint(location, condition) {
        this.breakpoints.set(location, {
            condition,
            hitCount: 0,
            snapshots: []
        });

        // 注入断点逻辑
        return new Proxy(location, {
            apply: (target, thisArg, args) => {
                const bp = this.breakpoints.get(location);
                bp.hitCount++;

                if (eval(condition)) {
                    // 捕获快照
                    bp.snapshots.push({
                        timestamp: performance.now(),
                        stack: this.captureCallStack(),
                        heap: this.captureHeapSnapshot(),
                        variables: this.captureLocalVariables(args)
                    });

                    // 触发调试器
                    debugger;
                }

                return target.apply(thisArg, args);
            }
        });
    }

    // 2. 性能分析
    profilePerformance(fn, label) {
        returnasync (...args) => {
            const startMark = `${label}-start`;
            const endMark = `${label}-end`;
            
            performance.mark(startMark);
            const startMemory = performance.memory.usedJSHeapSize;
            
            try {
                const result = await fn(...args);
                
                performance.mark(endMark);
                performance.measure(label, startMark, endMark);
                
                const measure = performance.getEntriesByName(label)[0];
                const endMemory = performance.memory.usedJSHeapSize;
                
                this.performanceMarks.set(label, {
                    duration: measure.duration,
                    memoryDelta: endMemory - startMemory,
                    timestamp: Date.now()
                });

                return result;
            } catch (error) {
                this.captureErrorContext(error);
                throw error;
            }
        };
    }

    // 3. 内存泄漏检测
    detectMemoryLeaks() {
        const leaks = [];
        const threshold = 1024 * 1024; // 1MB
        
        // 监控内存增长
        const observer = new PerformanceObserver((list) => {
            for (const entry of list.getEntries()) {
                if (entry.entryType === 'measure') {
                    const memoryGrowth = this.calculateMemoryGrowth();
                    if (memoryGrowth > threshold) {
                        leaks.push({
                            location: this.identifyLeakSource(),
                            size: memoryGrowth,
                            objects: this.findRetainedObjects()
                        });
                    }
                }
            }
        });

        observer.observe({ entryTypes: ['measure'] });
        return leaks;
    }

    // 4. 异步调试
    async traceAsyncFlow(asyncFn) {
        const traceId = crypto.randomUUID();
        const trace = {
            id: traceId,
            startTime: performance.now(),
            steps: [],
            errors: []
        };

        // 包装Promise以追踪异步流
        const originalPromise = Promise;
        Promise = new Proxy(originalPromise, {
            construct(target, args) {
                const promise = new target(...args);
                
                return promise.then(
                    (result) => {
                        trace.steps.push({
                            type: 'resolve',
                            timestamp: performance.now(),
                            value: result
                        });
                        return result;
                    },
                    (error) => {
                        trace.errors.push({
                            type: 'reject',
                            timestamp: performance.now(),
                            error: error.toString(),
                            stack: error.stack
                        });
                        throw error;
                    }
                );
            }
        });

        try {
            const result = await asyncFn();
            trace.endTime = performance.now();
            trace.duration = trace.endTime - trace.startTime;
            return { result, trace };
        } finally {
            Promise = originalPromise;
        }
    }
}

// 第三步：根因分析
class RootCauseAnalyzer {
    constructor() {
        this.symptoms = [];
        this.hypotheses = [];
        this.evidence = newMap();
    }

    // 1. 症状收集
    collectSymptoms(errorReport) {
        return {
            // 错误特征
            errorType: errorReport.name,
            errorMessage: errorReport.message,
            errorStack: this.parseStackTrace(errorReport.stack),
            
            // 发生频率
            frequency: this.calculateFrequency(errorReport),
            pattern: this.identifyPattern(errorReport),
            
            // 影响范围
            affectedUsers: this.estimateImpact(errorReport),
            severity: this.calculateSeverity(errorReport),
            
            // 环境相关性
            environmentCorrelation: this.analyzeEnvironment(errorReport),
            timeCorrelation: this.analyzeTimePattern(errorReport)
        };
    }

    // 2. 假设生成
    generateHypotheses(symptoms) {
        const hypotheses = [];

        // 基于症状模式匹配
        if (symptoms.pattern === 'intermittent') {
            hypotheses.push({
                type: 'race_condition',
                probability: 0.7,
                tests: ['Add synchronization', 'Increase delays']
            });
        }

        if (symptoms.environmentCorrelation.browser === 'specific') {
            hypotheses.push({
                type: 'browser_compatibility',
                probability: 0.8,
                tests: ['Test in target browser', 'Check polyfills']
            });
        }

        if (symptoms.frequency === 'increasing') {
            hypotheses.push({
                type: 'resource_leak',
                probability: 0.6,
                tests: ['Monitor memory', 'Check listeners']
            });
        }

        returnthis.rankHypotheses(hypotheses);
    }

    // 3. 根因确定
    async determineRootCause(hypotheses) {
        for (const hypothesis of hypotheses) {
            console.log(`测试假设: ${hypothesis.type} (概率: ${hypothesis.probability})`);
            
            for (const test of hypothesis.tests) {
                const result = awaitthis.runTest(test);
                this.evidence.set(hypothesis.type, result);
                
                if (result.confirmed) {
                    return {
                        rootCause: hypothesis.type,
                        evidence: result.data,
                        confidence: result.confidence,
                        solution: this.generateSolution(hypothesis.type)
                    };
                }
            }
        }

        returnthis.fallbackAnalysis();
    }

    // 4. 解决方案生成
    generateSolution(rootCause) {
        const solutions = {
            race_condition: {
                immediate: 'Add mutex/lock around critical section',
                longTerm: 'Refactor to eliminate shared state',
                preventive: 'Add race condition tests to CI/CD'
            },
            memory_leak: {
                immediate: 'Clear event listeners and timers',
                longTerm: 'Implement proper cleanup in lifecycle',
                preventive: 'Add memory profiling to monitoring'
            },
            browser_compatibility: {
                immediate: 'Add polyfill for missing feature',
                longTerm: 'Update build process for compatibility',
                preventive: 'Add cross-browser testing suite'
            }
        };

        return solutions[rootCause] || this.genericSolution();
    }
}

// 第四步：调试报告生成
class DebugReport {
    generate(bugInfo, analysis, solution) {
        return {
            summary: {
                id: crypto.randomUUID(),
                title: bugInfo.title,
                severity: analysis.severity,
                status: 'resolved',
                timeToResolve: analysis.duration
            },
            
            timeline: {
                reported: bugInfo.reportedAt,
                reproduced: analysis.reproducedAt,
                diagnosed: analysis.diagnosedAt,
                resolved: newDate().toISOString()
            },
            
            technicalDetails: {
                symptoms: analysis.symptoms,
                rootCause: analysis.rootCause,
                affectedCode: analysis.codeLocations,
                stackTrace: analysis.stackTrace
            },
            
            solution: {
                fix: solution.implementation,
                testing: solution.verificationSteps,
                preventive: solution.preventiveMeasures
            },
            
            lessons: {
                whatWentWrong: analysis.rootCause.description,
                howToPrevent: solution.preventiveMeasures,
                monitoringAdded: solution.monitoring
            }
        };
    }
}

// 使用示例
const debugger = new AdvancedDebugger();
const analyzer = new RootCauseAnalyzer();

// 开始调试流程
async function debugProductionIssue(errorReport) {
    console.log('🔍 开始系统化调试流程...');
    
    // 1. 复现问题
    const reproducer = new BugReproducer();
    const minimalCase = await reproducer.createMinimalTestCase();
    
    // 2. 收集症状
    const symptoms = analyzer.collectSymptoms(errorReport);
    
    // 3. 生成假设
    const hypotheses = analyzer.generateHypotheses(symptoms);
    
    // 4. 确定根因
    const rootCause = await analyzer.determineRootCause(hypotheses);
    
    // 5. 生成报告
    const report = new DebugReport().generate(
        errorReport,
        { symptoms, rootCause },
        rootCause.solution
    );
    
    console.log('✅ 调试完成！', report);
    return report;
}

---
name: code-debugger
description: Systematically identify, diagnose, and resolve bugs using advanced debugging techniques. Specializes in root cause analysis and complex issue resolution. Use PROACTIVELY for troubleshooting and bug investigation.
model: sonnet
---
You are a debugging expert specializing in systematic problem identification, root cause analysis, and efficient bug resolution across all programming environments.

## Debugging Expertise
- Systematic debugging methodology and problem isolation
- Advanced debugging tools (GDB, LLDB, Chrome DevTools, Xdebug)
- Memory debugging (Valgrind, AddressSanitizer, heap analyzers)
- Performance profiling and bottleneck identification
- Distributed system debugging and tracing
- Race condition and concurrency issue detection
- Network debugging and packet analysis
- Log analysis and pattern recognition

## Investigation Methodology
1. Problem reproduction with minimal test cases
2. Hypothesis formation and systematic testing
3. Binary search approach for issue isolation
4. State inspection at critical execution points
5. Data flow analysis and variable tracking
6. Timeline reconstruction for race conditions
7. Resource utilization monitoring and analysis
8. Error propagation and stack trace interpretation

## Advanced Techniques
- Reverse engineering for legacy system issues
- Memory dump analysis for crash investigation
- Performance regression analysis with historical data
- Intermittent bug tracking with statistical analysis
- Cross-platform compatibility issue resolution
- Third-party library integration problem solving
- Production environment debugging strategies
- A/B testing for issue validation and resolution

## Root Cause Analysis
- Comprehensive issue categorization and prioritization
- Impact assessment with business risk evaluation
- Timeline analysis for regression identification
- Dependency mapping for complex system interactions
- Configuration drift detection and resolution
- Environment-specific issue isolation techniques
- Data corruption source identification and remediation
- Performance degradation trend analysis and prediction

Approach debugging systematically with clear methodology and comprehensive analysis. Focus on not just fixing symptoms but identifying and addressing root causes to prevent recurrence.

---
name: code-debugger
description: 使用高级调试技术系统地识别、诊断和解决bug。专精根因分析和复杂问题解决。在故障排查和bug调查时主动使用。
model: sonnet
---
你是一位调试专家，专精跨所有编程环境的系统化问题识别、根因分析和高效bug解决。

## 调试专业技能 / Debugging Expertise
- 系统化调试方法论和问题隔离
- 高级调试工具（GDB、LLDB、Chrome DevTools、Xdebug）
- 内存调试（Valgrind、AddressSanitizer、堆分析器）
- 性能分析和瓶颈识别
- 分布式系统调试和追踪
- 竞态条件和并发问题检测
- 网络调试和数据包分析
- 日志分析和模式识别

## 调查方法论 / Investigation Methodology
1. 使用最小测试用例复现问题
2. 假设形成和系统化测试
3. 二分查找法进行问题隔离
4. 关键执行点的状态检查
5. 数据流分析和变量跟踪
6. 竞态条件的时间线重建
7. 资源利用率监控和分析
8. 错误传播和堆栈跟踪解释

## 高级技术 / Advanced Techniques
- 遗留系统问题的逆向工程
- 崩溃调查的内存转储分析
- 使用历史数据的性能回归分析
- 使用统计分析的间歇性bug跟踪
- 跨平台兼容性问题解决
- 第三方库集成问题解决
- 生产环境调试策略
- 问题验证和解决的A/B测试

## 根因分析 / Root Cause Analysis
- 全面的问题分类和优先级排序
- 业务风险评估的影响分析
- 回归识别的时间线分析
- 复杂系统交互的依赖映射
- 配置漂移检测和解决
- 特定环境问题隔离技术
- 数据损坏源识别和修复
- 性能降级趋势分析和预测

系统化地进行调试，使用清晰的方法论和全面的分析。
不仅要修复症状，更要识别和解决根本原因以防止复发。

// 1. 什么是断点调试？
// 就像看电影时按暂停，可以仔细看当前画面
debugger;  // 代码执行到这里会暂停
console.log(variable);  // 查看变量当前值

// 2. 什么是二分查找调试？
// 就像猜数字游戏，每次排除一半可能性
function binaryDebug(array) {
    // 先测试前半部分
    const mid = Math.floor(array.length / 2);
    if (problemInFirstHalf(array.slice(0, mid))) {
        return binaryDebug(array.slice(0, mid));
    } else {
        return binaryDebug(array.slice(mid));
    }
}

// 3. 什么是内存泄漏？
// 就像水龙头没关紧，内存慢慢"漏掉"
let leakyArray = [];
setInterval(() => {
    leakyArray.push(newArray(1000000));  // 不断占用内存
    // 忘记清理了！
}, 100);

// 4. 什么是竞态条件？
// 就像两个人同时修改同一份文件，结果混乱
let counter = 0;
// 两个异步操作同时修改counter
asyncfunction increment() { counter++; }
asyncfunction decrement() { counter--; }
// 最终结果不确定！

# 在Claude Code中输入
/agents

应用运行几小时后变慢，怀疑内存泄漏，帮我调试

// 内存泄漏检测和修复方案

// 1. 内存监控工具
class MemoryMonitor {
    constructor() {
        this.baseline = null;
        this.snapshots = [];
        this.leaks = [];
    }

    start() {
        // 记录基准内存使用
        this.baseline = {
            heap: performance.memory.usedJSHeapSize,
            timestamp: Date.now(),
            objects: this.countObjects()
        };

        // 定期采样
        this.interval = setInterval(() => {
            this.takeSnapshot();
        }, 10000);  // 每10秒采样
    }

    takeSnapshot() {
        const current = {
            heap: performance.memory.usedJSHeapSize,
            timestamp: Date.now(),
            objects: this.countObjects()
        };

        // 检测异常增长
        if (this.isMemoryLeak(current)) {
            this.identifyLeak(current);
        }

        this.snapshots.push(current);
    }

    identifyLeak(snapshot) {
        console.warn('⚠️ 检测到潜在内存泄漏！');
        
        // 分析可能的泄漏源
        const analysis = {
            domNodes: document.querySelectorAll('*').length,
            eventListeners: this.countEventListeners(),
            timers: this.countTimers(),
            detachedNodes: this.findDetachedNodes()
        };

        console.table(analysis);
        return analysis;
    }
}

// 2. 常见内存泄漏模式和修复
const memoryLeakPatterns = {
    // 问题：事件监听器未清理
    eventListenerLeak: {
        bad: `
            element.addEventListener('click', handler);
            // element被移除但监听器还在
        `,
        good: `
            const controller = new AbortController();
            element.addEventListener('click', handler, {
                signal: controller.signal
            });
            // 清理时
            controller.abort();
        `
    },

    // 问题：定时器未清理
    timerLeak: {
        bad: `
            setInterval(() => {
                updateUI();
            }, 1000);
            // 组件销毁时忘记清理
        `,
        good: `
            const timer = setInterval(() => {
                updateUI();
            }, 1000);
            
            // 在cleanup中
            clearInterval(timer);
        `
    },

    // 问题：闭包引用
    closureLeak: {
        bad: `
            function createLeak() {
                const hugeData = new Array(1000000);
                return function() {
                    console.log('leaked');
                    // hugeData被闭包引用，无法释放
                };
            }
        `,
        good: `
            function createSafe() {
                let hugeData = new Array(1000000);
                return function() {
                    console.log('safe');
                    hugeData = null;  // 主动释放
                };
            }
        `
    }
};

多个用户同时操作时数据混乱，需要调试并发问题

// 并发问题调试方案

class ConcurrencyDebugger {
    constructor() {
        this.operations = newMap();
        this.conflicts = [];
    }

    // 1. 追踪并发操作
    async trackOperation(id, operation) {
        const startTime = performance.now();
        
        // 记录操作开始
        this.operations.set(id, {
            startTime,
            state: 'running',
            resources: this.identifyResources(operation)
        });

        // 检测冲突
        this.detectConflicts(id);

        try {
            const result = await operation();
            
            // 记录操作完成
            this.operations.get(id).endTime = performance.now();
            this.operations.get(id).state = 'completed';
            
            return result;
        } catch (error) {
            this.operations.get(id).state = 'failed';
            this.operations.get(id).error = error;
            throw error;
        }
    }

    // 2. 检测资源冲突
    detectConflicts(currentId) {
        const current = this.operations.get(currentId);
        
        for (const [id, op] ofthis.operations) {
            if (id !== currentId && op.state === 'running') {
                const sharedResources = this.findSharedResources(
                    current.resources,
                    op.resources
                );
                
                if (sharedResources.length > 0) {
                    this.conflicts.push({
                        operations: [currentId, id],
                        resources: sharedResources,
                        timestamp: Date.now()
                    });
                    
                    console.warn('⚠️ 检测到并发冲突！', {
                        operations: [currentId, id],
                        resources: sharedResources
                    });
                }
            }
        }
    }

    // 3. 解决方案：互斥锁
    createMutex() {
        let locked = false;
        const queue = [];

        return {
            async acquire() {
                if (!locked) {
                    locked = true;
                    return;
                }

                returnnewPromise(resolve => {
                    queue.push(resolve);
                });
            },

            release() {
                if (queue.length > 0) {
                    const next = queue.shift();
                    next();
                } else {
                    locked = false;
                }
            }
        };
    }
}

// 使用示例：安全的并发操作
const mutex = new ConcurrencyDebugger().createMutex();

asyncfunction safeOperation(data) {
    await mutex.acquire();
    try {
        // 临界区代码
        await updateSharedResource(data);
    } finally {
        mutex.release();
    }
}

## Debugging Expertise
- Chrome DevTools精通
- React DevTools
- Vue DevTools
- Redux时间旅行调试
- Webpack构建问题

## Debugging Expertise
- Node.js调试器
- Docker容器调试
- 数据库慢查询
- API性能问题
- 微服务追踪

## Team Standards
-日志级别：DEBUG/INFO/WARN/ERROR
-错误上报：Sentry集成
-性能监控：DatadogAPM
-调试文调试文档：必须记录根因和解决方案
-问题跟踪：JIRA集成

-调试文档：必须记录根因和解决方案
-问题跟踪：JIRA集成

// 1. 非侵入式日志
console.log = (function(oldLog) {
    returnfunction(...args) {
        // 发送到日志服务器
        sendToLogServer(args);
        // 生产环境不输出
        if (process.env.NODE_ENV !== 'production') {
            oldLog.apply(console, args);
        }
    };
})(console.log);

// 2. 特性开关调试
if (featureFlag('debug_mode')) {
    enableDetailedLogging();
}

// 3. 采样调试（只调试部分请求）
if (Math.random() < 0.01) {  // 1%采样率
    trackDetailedMetrics();
}

class IntermittentBugTracker {
    constructor() {
        this.occurrences = [];
    }

    record(context) {
        this.occurrences.push({
            timestamp: Date.now(),
            ...context
        });

        // 分析模式
        if (this.occurrences.length > 10) {
            this.analyzePattern();
        }
    }

    analyzePattern() {
        // 时间模式分析
        const timePattern = this.findTimePattern();
        // 环境相关性
        const envCorrelation = this.findEnvCorrelation();
        // 用户行为模式
        const userPattern = this.findUserPattern();

        return { timePattern, envCorrelation, userPattern };
    }
}

// 1. 自动化测试
describe('Bug #1234 Prevention', () => {
    it('should handle edge case that caused crash', () => {
        // 重现之前的bug场景
        const result = functionThatCrashed(edgeCaseInput);
        expect(result).toBeDefined();
        expect(result).not.toThrow();
    });
});

// 2. 运行时检查
function addRuntimeCheck(fn) {
    returnfunction(...args) {
        // 前置条件检查
        assert(precondition(args), 'Precondition failed');
        
        const result = fn.apply(this, args);
        
        // 后置条件检查
        assert(postcondition(result), 'Postcondition failed');
        
        return result;
    };
}

// 3. 监控告警
const monitor = {
    threshold: 100,  // 错误阈值
    window: 60000,    // 1分钟窗口
    
    check() {
        if (errorCount > this.threshold) {
            alert('Bug pattern detected!');
            rollback();
        }
    }
};

graph TD
    A[发现Bug] --> B[收集信息]
    B --> C{能复现?}
    C -->|是| D[创建最小测试用例]
    C -->|否| E[收集更多日志]
    E --> C
    D --> F[定位问题代码]
    F --> G[分析根因]
    G --> H[制定修复方案]
    H --> I[实施修复]
    I --> J[验证修复]
    J --> K{修复成功?}
    K -->|是| L[添加测试]
    K -->|否| G
    L --> M[部署上线]
    M --> N[监控观察]

// 必备调试工具集
const debuggingToolkit = {
    // 浏览器工具
    browser: {
        'Chrome DevTools': '断点、性能、内存',
        'React DevTools': 'React组件调试',
        'Redux DevTools': '状态管理调试',
        'Lighthouse': '性能审计'
    },
    
    // Node.js工具
    nodejs: {
        'node --inspect': 'Node调试器',
        'why-is-node-running': '查找未结束进程',
        'clinic.js': '性能诊断',
        '0x': '火焰图分析'
    },
    
    // 通用工具
    general: {
        'git bisect': '二分查找bug提交',
        'strace/dtrace': '系统调用追踪',
        'tcpdump/wireshark': '网络调试',
        'gdb/lldb': '底层调试'
    },
    
    // 在线服务
    services: {
        'Sentry': '错误追踪',
        'LogRocket': '会话回放',
        'Datadog': 'APM监控',
        'New Relic': '性能监控'
    }
};

// 调试黄金法则
const debuggingRules = {
    rule1: '最近的改动最可疑',
    rule2: '简单的解释往往是对的（奥卡姆剃刀）',
    rule3: '相信日志，不相信假设',
    rule4: '一次只改一个地方',
    rule5: '保存能复现的测试用例',
    rule6: '寻求他人帮助（橡皮鸭调试法）',
    rule7: '休息一下再回来看',
    rule8: '从用户角度重现问题',
    rule9: '检查环境差异',
    rule10: '记录调试过程供未来参考'
};

/**
 * 调试三重境界
 * 
 * 1. 见山是山：看到错误就改
 * 2. 见山不是山：理解错误背后的系统
 * 3. 见山还是山：预防错误的发生
 */

class DebugMaster {
    constructor() {
        this.experience = [];
        this.wisdom = Infinity;
    }

    debug(problem) {
        // 保持冷静
        this.stayCalm();
        
        // 系统思考
        const analysis = this.systematicThinking(problem);
        
        // 验证假设
        const hypothesis = this.formHypothesis(analysis);
        const result = this.testHypothesis(hypothesis);
        
        // 学习成长
        this.learn(result);
        
        return result;
    }

    stayCalm() {
        console.log('深呼吸，bug只是暂时的挑战');
    }

    learn(experience) {
        this.experience.push(experience);
        this.wisdom++;
        console.log('每个bug都让我变得更强');
    }
}