Skill UI

A rigorous, blameless framework for conducting post-mortems after major failures, such as missed quarterly targets, failed launches, or poor hires. It guides users through defining the event, applying the 5 Whys to find root causes, distinguishing between contributing factors and core causes, identifying ignored warning signs, and creating actionable, owned change registers to ensure systemic improvement and prevent recurrence.

This module is designed to document, track, and manage quality nonconformance issues found during manufacturing or process audits. It is essential for root cause analysis, implementing corrective and preventive actions (CAPA), and ensuring compliance with industry quality standards. Use it when recording deviations from specified requirements.

This skill enforces rigorous governance and discipline when AI modifies systems, debugs code, or makes root-cause claims. It mandates safety gates (e.g., backup, blast radius check), demands evidence for every diagnosis, and prevents common AI shortcuts like guessing or deflecting. Use this for critical code modifications, complex debugging, and high-stakes deployments to ensure thoroughness and safety.

A forensic tool for performing post-mortem analysis on AI-assisted coding sessions. It goes beyond simply stating what was done, determining *why* work deviated (e.g., spec ambiguity, repo friction, agent error), identifying scope creep, and classifying rework patterns. It provides evidence-backed recommendations to improve prompts, codebase health, and future development workflows.

A comprehensive guide for collecting volatile forensic evidence from a compromised host while adhering to the order of volatility. This process captures critical data—including memory dumps, network connections, running processes, and system state—before the host is isolated or powered down. Essential for root cause analysis, fileless malware investigation, and maintaining a defensible chain of custody for legal proceedings.

A structured guide for conducting blameless post-mortem reviews after any security incident. This process helps identify root causes using techniques like the 5 Whys, calculates critical metrics (MTTD, MTTR), and generates actionable recommendations to continuously improve incident response playbooks and procedures.

This skill provides a comprehensive, structured workflow for diagnosing performance bottlenecks in SwiftUI applications. It guides users through a code-first review to detect common issues like invalidation storms, layout thrash, or heavy main-thread work. When code review is insufficient, it provides detailed guidance on collecting runtime evidence using Instruments, enabling precise root cause analysis and targeted remediation strategies.

This skill enforces a rigorous, 5-phase debugging protocol (Reproduce, Isolate, Root Cause, Fix, Verify) for AI coding agents. It forces a disciplined approach, preventing agents from guessing fixes or making premature edits. Use this when debugging complex, intermittent, or hard-to-isolate bugs to ensure the root cause is fully confirmed before any code changes are applied, maximizing debugging accuracy.

This skill provides a systematic, four-phase workflow for diagnosing and recovering from AI agent failures. It guides the agent to first capture the failure state, diagnose the root cause (e.g., loop, context overflow, state drift), apply minimal containment recovery actions, and finally generate a detailed introspection report, minimizing the need for human intervention.

Guides systematic root-cause debugging when tests fail, builds break, or behavior unexpectedly changes. It covers stop-the-line discipline, a triage checklist, git bisection for regressions, minimal reproduction, root-cause fixes, regression tests, and end-to-end verification. Ideal for turning confusing errors into reliable recovery workflows.

A comprehensive guide for systematically debugging Golang programs. This skill helps users find and fix the root cause of bugs, crashes, deadlocks, race conditions, and performance bottlenecks. It covers advanced techniques like pprof profiling, using Delve, implementing test-driven debugging, and follows a rigorous methodology to ensure deep root cause analysis before proposing any fix. Ideal for production environments and complex concurrency issues.

This skill teaches users to apply the scientific method to software debugging. Instead of random changes, it guides the process through five steps: Observation, Hypothesizing, Prediction, Testing, and Analysis. By systematically forming and testing specific, measurable hypotheses, users can efficiently isolate failing components and confirm the true root cause of technical issues.