Skip to main content
skill CX Codex

022-root-cause-analysis — Claude Code skill: root cause analysis

022-root-cause-analysis — a skill for Claude Code, Codex, Cursor, GitHub Copilot, and Gemini CLI that runs structured root cause analysis using Five Whys, Fishbone (Ishikawa), and Current Reality Tree.

Apache-2.0 144 installs ★ 465 updated 2026-10-21

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add jabrena/plinth --skill 022-root-cause-analysis -a claude-code
Open on GitHub

What 022-root-cause-analysis does

The skill draws a hard line between a symptom — the observed effect — and the root cause that produces it, and refuses to recommend a fix until that distinction is made.

Four techniques are applied in sequence or selectively, depending on complexity. Five Whys chains "why" questions from the symptom toward an evidenced cause, stopping when the next step would require guessing. Fishbone (Ishikawa) organises candidate causes into categories such as people, process, technology, and environment when more than one dimension is plausible. Current Reality Tree connects multiple symptoms to one or a few shared core problems through cause-effect relationships. Finally, the skill names the constraint keeping the system in its current state — which is often not the most recently reported cause.

Before each session the skill reads references/022-root-cause-analysis.md from the repository; that file must be present or the analysis will not run. Findings feed forward into 023-assumption-analysis and the remaining Functional Specification lenses in the Plinth Toolkit.

What it helps with

  • trace a bug to its root cause instead of patching the visible symptom
  • build a Fishbone diagram when a problem spans people, process, and technology
  • connect multiple related symptoms to a single core problem via Current Reality Tree
  • identify the constraint holding a system in a broken state
  • write the Root Cause Analysis section of a Functional Specification

Example prompts for the agent

  • Find the root cause of this problem using Five Whys
  • Build a Fishbone diagram for this issue and break down causes by category
  • Use Current Reality Tree to link these symptoms and find the shared core problem

How to install 022-root-cause-analysis

1Skills CLI (Vercel)

npx skills add jabrena/plinth --skill 022-root-cause-analysis -a claude-code

2Manually: put the files in place

~/.claude/skills/022-root-cause-analysis/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/022-root-cause-analysis/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about 022-root-cause-analysis

How do I install 022-root-cause-analysis in Claude Code?

Run npx skills add jabrena/plinth --skill 022-root-cause-analysis -a claude-code. The skill lands at ~/.claude/skills/022-root-cause-analysis/SKILL.md.

What does the 022-root-cause-analysis skill do?

It guides an interactive root cause investigation: asks clarifying questions, builds Five Whys chains, Fishbone diagrams, and a Current Reality Tree, then names the system constraint. It flags any finding that needs more evidence before a fix can be proposed.

Is the file references/022-root-cause-analysis.md required?

Yes. The skill must read that file before applying any guidance — without it, the analysis will not start.

Source text

SKILL.md · Apache-2.0
---
name: 022-root-cause-analysis
description: Use when a framed problem needs root-cause investigation rather than a symptom-level fix, applying Five Whys, Fishbone (Ishikawa), Current Reality Tree, and constraint identification. This should trigger when an issue's Root Cause Analysis point of view needs evaluation, or when a maintainer directly asks to find the root cause of a problem before proposing a fix. Part of Plinth Toolkit
license: Apache-2.0
metadata:
  author: Juan Antonio Breña Moral
  version: 0.19.0
---
# Root Cause Analysis

Guide the identification of root causes, not symptoms, for a framed problem, using Five Whys, Fishbone (Ishikawa), Current Reality Tree, and constraint identification. **This is an interactive SKILL**.

**What is covered in this Skill?**

- Five Whys for a linear causal chain from a symptom to a root cause
- Fishbone (Ishikawa) for categorized candidate causes across multiple dimensions
- Current Reality Tree for interconnected causes and effects with a small number of core problems
- Constraint identification for the limiting factor holding the current state in place
- Choosing the technique(s) proportionate to the problem's complexity
- Feeding root-cause findings into `023-assumption-analysis` and the remaining Functional Specification lenses

## Constraints

Distinguish root causes from symptoms before recommending a fix. When this technique is orchestrated by another workflow, the orchestrator owns clarifying-question sequencing; when applied standalone, ask directly.

- **MUST** read `references/022-root-cause-analysis.md` before applying Root Cause Analysis guidance
- **MUST** distinguish a symptom (an observed effect) from a root cause (the condition that produces it)
- **MUST** apply Five Whys as a chain of "why" questions grounded in evidence from the problem frame, not assumption
- **MUST** apply Fishbone to organize candidate causes into categories (for example people, process, technology, environment) when more than one causal dimension is plausible
- **MUST** apply Current Reality Tree when multiple symptoms may share one or a small number of core problems connected by cause-effect relationships
- **MUST** identify the constraint limiting the current state, not only the most visible cause
- **MUST NOT** invent a root cause when the available evidence is vague or ambiguous; flag the gap for a clarifying question instead

## When to use this skill

- Find the root cause of this problem
- Apply Five Whys to this issue
- Build a Fishbone diagram for this problem
- Use Current Reality Tree to connect these symptoms
- Identify the constraint limiting the current state
- Draft the Root Cause Analysis section of a Functional Specification

## Workflow

1. **Read the Reference**

Read `references/022-root-cause-analysis.md`, then identify the symptom(s) evidenced by the problem frame.

2. **Apply Five Whys**

Chain "why" questions from the symptom toward an evidenced root cause, stopping when further "why" steps would require guessing.

3. **Apply Fishbone When Multiple Dimensions Are Plausible**

Organize candidate causes into categories when more than one causal dimension (people, process, technology, environment) is plausible.

4. **Apply Current Reality Tree When Symptoms Interconnect**

Connect multiple symptoms to a small number of shared core problems through cause-effect relationships when the symptoms appear related.

5. **Identify the Constraint**

Name the constraint limiting the current state, distinct from the most visible or most recently reported cause.

6. **Report the Root Cause Findings**

Report findings using Five Whys, Fishbone, Current Reality Tree, and the identified constraint, and flag any finding left open pending a clarifying answer.

## Reference

For detailed guidance, examples, and constraints, see [references/022-root-cause-analysis.md](references/022-root-cause-analysis.md).

© Juan Antonio Breña Moral · Apache-2.0 · jabrena/plinth

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set123

The whole set →
811-regulations-eu-market-abuse-regulation The 811-regulations-eu-market-abuse-regulation skill reviews Java systems for EU Market Abuse Regulation controls, reviewable evidence, alert decisions, and escalation paths. CX Codex +1 166installs 813-regulations-iso-42001 813-regulations-iso-42001 reviews Java systems that use GenAI against ISO/IEC 42001 concerns and turns findings into engineering controls, evidence, and owner handoffs. CX Codex +1 165installs 812-regulations-eu-product-liability-directive 812-regulations-eu-product-liability-directive turns EU Product Liability Directive 2024/2853 checks into engineering artefacts: scope inventory, hazardous-scenario tests, update history and user warnings for Java and AI products. CX Codex +1 165installs 810-regulations-eu-mifid-ii 810-regulations-eu-mifid-ii reviews Java enterprise applications for MiFID II investment service controls and audit evidence prior to release. CX Codex +1 165installs 025-quality-attribute-discovery The 025-quality-attribute-discovery skill finds and ranks a solution’s quality attributes before architecture work begins. It ties each candidate to evidence from the problem and its context. CX Codex +1 143installs 024-context-mapping 024-context-mapping is a Claude Code skill that maps existing systems, integrations, owners, and external dependencies before design when system boundaries are undefined. CX Codex +1 142installs 023-assumption-analysis 023-assumption-analysis is a skill that identifies and ranks assumptions and unknowns in a framed problem before design, then outlines validation checks. CX Codex +1 140installs 021-problem-framing 021-problem-framing structures problem statements, current and desired states, stakeholders, and success criteria before engineers jump into implementation. CX Codex +1 139installs

Project sponsors

Companies that keep this analytics open