
root-cause-analysis
Conducts systematic root cause analysis using proven methodologies including Toyota's 5 Whys, Ishikawa fishbone diagrams, Pareto analysis, and fault tree analysis. Use when investigating bugs, debugging code, troubleshooting systems, diagnosing equipment failures, analyzing life problems, or identifying underlying causes of any issue across software engineering, hardware maintenance, process failures, or personal challenges.
- Installs
- 105
- Last 24h
- —
- Trending rank
- —
- Security
- Not audited
Install
Works with every agent the skills CLI supports.
npx skills add https://github.com/markpitt/claude-skills --skill root-cause-analysis- 01
Install
Run the command in your project. The CLI asks which agents to install for.
- 02
Describe the task
Ask your agent for something this skill covers. It loads root-cause-analysis automatically when relevant.
- 03
Review the result
The agent follows the SKILL.md steps, scripts and references bundled with the skill.
SKILL.md
The instructions your agent reads when the skill is triggered.
Root Cause Analysis Orchestration Skill
This skill helps you systematically identify the root cause of any problem using proven methodologies from the Toyota Production System and other industry-standard techniques.
Quick Reference: When to Load Which Resource
| Your Problem Type | Load Resource | Why |
|---|---|---|
| Need to understand 5 Whys, Fishbone, Pareto, Fault Tree methodology | resources/rca-methodologies.md | Learn each method step-by-step with examples |
| Looking for common root causes in your domain | resources/common-root-causes.md | Pattern match against known causes: software, hardware, process, personal |
| Want to see complete worked examples | resources/example-analyses.md | Study real cases: software bugs, vehicle maintenance, system failures, personal problems |
| Advanced: need barrier analysis, complex cause mapping | resources/advanced-techniques.md | Formal methods: Fault Tree, Barrier Analysis, multi-methodology chains |
Core Principle
Do not treat symptoms—find and fix the root cause. As Taiichi Ohno, architect of the Toyota Production System, said: "By repeating why five times, the nature of the problem as well as its solution becomes clear."
Orchestration Protocol
Phase 1: Problem Classification
Quickly identify your problem domain and complexity:
Problem Domain:
- Software: Code bugs, system failures, performance, deployment
- Hardware: Equipment, mechanical, electrical, maintenance
- Process: Workflow, procedures, organizational, communication
- Personal: Life challenges, productivity, habits, wellbeing
Complexity Level:
- Simple: Clear failure chain, 1-2 likely causes → Use 5 Whys
- Complex: Multiple possible causes, unknown scope → Start with Fishbone
- Critical/Safety: High stakes, needs rigor → Use Fault Tree
- Multiple Issues: Many competing problems → Use Pareto first
Action: Load appropriate resource file(s) based on classification.
Phase 2: Methodology Selection
Based on problem type, select your approach:
| Situation | Recommended | Load |
|---|---|---|
| Single clear failure | 5 Whys | methodologies.md |
| Complex/multiple possibilities | Fishbone → 5 Whys | methodologies.md |
| Competing priorities | Pareto → 5 Whys | methodologies.md |
| Safety/high-stakes | Fault Tree | advanced-techniques.md |
| Process breakdown | Barrier Analysis | advanced-techniques.md |
| Pattern matching | Common causes + 5 Whys | common-root-causes.md |
Phase 3: Execution & Verification
During Analysis:
- Define problem clearly (What/Where/When/Impact)
- Gather evidence systematically
- Apply selected methodology
- Document reasoning at each step
- Verify root cause with Forward/Backward tests
Before Finalizing:
- Validate conclusion against evidence
- Check for red flags (see common-root-causes.md)
- Confirm actionability (can you fix this?)
- Develop solutions addressing root cause
Problem Definition Framework
Create a clear problem statement before analysis:
Essential Elements:
- What: Observable symptom (not assumed cause)
- Where: Location/system/component affected
- When: Timeline, frequency, pattern
- Impact: Users/systems affected, severity
Example: "Users in EU region experience 3-5 second dashboard load delays during 9-11 AM UTC peak hours, affecting ~2,000 daily active users. Started after v2.4 deployment on Nov 18th."
Evidence Gathering (Go and See)
Follow Toyota's principle—collect facts, not opinions:
Key Evidence Sources:
- Logs, metrics, monitoring data
- Timeline of events and changes
- System/code/configuration changes before problem
- Environmental factors (load, traffic, season)
- User reports and reproduction steps
- System state before/during/after
RCA Methodologies
See resources/rca-methodologies.md for complete methodology guide.
Resource Files Summary
resources/rca-methodologies.md
Comprehensive methodology guide covering:
- 5 Whys: Step-by-step process with software examples
- Fishbone Diagram: Structure, 6 M's categories, process
- Pareto Analysis: Prioritization using 80/20 rule
- Fault Tree Analysis: Top-down formal analysis
- Barrier Analysis: Control failure examination
- Structured 6-phase RCA process, domain-specific guidance, templates
resources/common-root-causes.md
Pattern reference catalog by domain:
- Software Engineering: Code defects, configuration, dependencies, deployment
- Hardware & Equipment: Mechanical, electrical, operational, maintenance
- Process & Operations: Workflow, design, resources
- Personal/Life: Health, habits, environment, skills
- Red flags, recurring themes, pattern recognition
resources/example-analyses.md
Four worked examples with full analysis:
- Software Bug: JWT authentication (5 Whys)
- Vehicle Maintenance: Overheating (5 Whys)
- System Failure: E-commerce checkout (Fishbone + 5 Whys)
- Personal Productivity: Missed deadlines (Fishbone + 5 Whys)
resources/advanced-techniques.md
Formal methods for complex problems:
- Fault Tree Analysis: Boolean logic, safety systems
- Barrier Analysis: Control failures
- Multi-Methodology Chains: Complex orchestration
- Verification Frameworks: Comprehensive testing
How This Skill Works
- Clarify your situation: Domain, observations, evidence, time
- Recommend approach: Complexity analysis, methodology, resources
- Guide through analysis: Problem statement, evidence, methodology, verification
- Deliver output: Analysis, root cause, solutions, implementation
Quick Start: 5-Minute RCA
- State problem (What/Where/When/Impact)
- First Why: fact-based answer
- Second Why: dig deeper
- Third Why: dig deeper again
- Verify: would fixing this prevent it?
Templates & Examples
- 5 Whys Template in
resources/rca-methodologies.md - Fishbone Template in
resources/rca-methodologies.md - Worked Examples in
resources/example-analyses.md - Solution Structures in
resources/example-analyses.md
Next Steps
- Identify problem domain (software/hardware/process/personal)
- Load appropriate resource from table above
- Select methodology based on complexity
- Follow step-by-step process in resource
- Verify root cause (Forward/Backward tests)
- Develop actionable solutions
Remember: Goal is systematic investigation—disciplined questioning until you reach a cause you can actually fix.
FAQ
What does the root-cause-analysis skill do?
Conducts systematic root cause analysis using proven methodologies including Toyota's 5 Whys, Ishikawa fishbone diagrams, Pareto analysis, and fault tree analysis. Use when investigating bugs, debugging code, troubleshooting systems, diagnosing equipment failures, analyzing life problems, or identifying underlying causes of any issue across software engineering, hardware maintenance, process failures, or personal challenges.
How do I install root-cause-analysis?
Run npx skills add https://github.com/markpitt/claude-skills --skill root-cause-analysis in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/root-cause-analysis/ (personal) or .claude/skills/root-cause-analysis/ (project).
Which AI agents can use root-cause-analysis?
Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.
Is root-cause-analysis safe to install?
No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.
Who maintains root-cause-analysis?
It is published by markpitt in markpitt/claude-skills. It has 105 recorded installs.
More from markpitt/claude-skills
blazor-expert
markpitt/claude-skills
Comprehensive Blazor development expertise covering Blazor Server, WebAssembly, and Hybrid apps. Use when building Blazor components, implementing state management, handling routing, JavaScript interop, forms and validation, authentication, or optimizing Blazor applications. Includes best practices, architecture patterns, and troubleshooting guidance.
microsoft-graph
markpitt/claude-skills
Orchestration hub for Microsoft Graph API across Microsoft 365 services. Use for Graph API integrations, querying Microsoft 365 data, and building applications that interact with Azure AD.
kiss-principle
markpitt/claude-skills
Apply the K.I.S.S principle (Keep It Simple, Stupid) to reduce complexity, improve maintainability, and solve problems elegantly. Use when designing systems, writing code, planning solutions, creating documentation, architecting features, or making decisions where simplicity drives quality and efficiency.
markdown-formatter
markpitt/claude-skills
Formats markdown files according to best practices and common style guidelines. Use when cleaning up markdown documentation, ensuring consistent formatting, or standardizing README files.
azure-devops
markpitt/claude-skills
Comprehensive skill for working with Azure DevOps REST API across all services including Boards (work items, queries, backlogs), Repos (Git, pull requests, commits), Pipelines (builds, releases, deployments), Test Plans, Artifacts, organizations, projects, security, extensions, and more. Use when implementing Azure DevOps integrations, automating DevOps workflows, or building applications that interact with Azure DevOps services.
Popular code quality & workflow skills
grill-me
mattpocock/skills
A relentless interview to sharpen a plan or design.
improve-codebase-architecture
mattpocock/skills
Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.
handoff
mattpocock/skills
Compact the current conversation into a handoff document for another agent to pick up.
domain-modeling
mattpocock/skills
Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.
codebase-design
mattpocock/skills
Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.
diagnosing-bugs
mattpocock/skills
Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.