From episteme
Exposes Claude's reasoning as auditable traces with atomic claims, assumption ratings, weakest links, decision branches, confidence decomposition, and falsification conditions. Use on 'reasoning', 'why', 'trace' queries or /swing-trace.
npx claudepluginhub junjslee/episteme --plugin epistemeThis skill is limited to using the following tools:
Anti-black-box engine that makes reasoning chains visible, auditable, and decomposable.
Exposes Claude's reasoning as auditable traces with atomic claims, assumption ratings, weakest links, confidence decomposition, and falsification conditions. Triggers on 'reasoning', 'why', 'trace'.
Facilitates Socratic questioning to surface assumptions, challenge positions, debug mental models, and resolve uncertainty in decisions, designs, or debugging.
Performs Analysis of Competing Hypotheses (ACH) to evaluate multiple hypotheses against evidence: builds disconfirmation matrix, ranks by least disconfirming evidence, adds diagnosticity, sensitivity analysis, and falsification milestones.
Share bugs, ideas, or general feedback.
Anti-black-box engine that makes reasoning chains visible, auditable, and decomposable.
Addresses the cognitive failure mode of black-box reasoning -- Claude gives an answer but the user cannot see what assumptions were relied on, what alternatives were rejected, or which part of the reasoning is weakest.
When invoked without --full, execute only:
Skip Stages 3 (Decision Tree) and 4 (Confidence Decomposition).
Quick mode output format:
## Reasoning Trace: [Claim]
### Atomic Claims
1. [Claim 1]
2. [Claim 2]
### Assumption Inventory
| # | Assumption | Criticality | Verifiability |
|---|-----------|-------------|---------------|
| A1 | ... | High/Med/Low | Direct/Indirect/Unverifiable |
### Weakest Link
**Assumption [A#]:** [restate]
- **Why weakest:** [explanation]
- **If wrong:** [alternative conclusion]
- **How to verify:** [concrete steps]
When invoked with --full, execute all 5 stages as documented below.
Execute these 5 stages sequentially. Do NOT skip stages.
Identify the exact claim(s) being traced. Separate compound questions into atomic claims.
Input: "Why did you recommend microservices over a monolith?"
Atomic claims:
1. Microservices are a better architectural fit for this project
2. The team can handle microservices operational complexity
3. The migration cost is justified by long-term benefits
Each atomic claim gets its own assumption inventory and confidence score.
For each atomic claim, enumerate every assumption the reasoning depends on. Each assumption gets three attributes:
| # | Assumption | Criticality | Verifiability |
|---|---|---|---|
| A1 | [Statement] | High -- conclusion changes if wrong | Directly Verifiable -- can test/measure |
| A2 | [Statement] | Medium -- conclusion weakens if wrong | Indirectly Verifiable -- can infer from proxy data |
| A3 | [Statement] | Low -- conclusion survives if wrong | Unverifiable -- must be accepted or rejected on judgment |
Criticality scale:
Verifiability scale:
At each significant fork in the reasoning, document:
Decision Point: Database selection
├─ Option A: PostgreSQL [CHOSEN]
│ Strengths: ACID compliance, JSON support, ecosystem maturity
│ Evidence type: Empirical (benchmarks) + Authority (industry adoption data)
│
├─ Option B: SQLite [REJECTED]
│ Strengths: Zero-config, embedded, fast for reads
│ Rejection: Write concurrency limit (~5 writers) incompatible with
│ multi-instance deployment requirement (Assumption A2)
│ Reversal: If deployment is single-instance AND write volume < 100/sec,
│ SQLite becomes the simpler, better choice
│
└─ Option C: MongoDB [REJECTED]
Strengths: Schema flexibility, horizontal scaling
Rejection: Data has strong relational structure (7 FK relationships);
denormalization cost outweighs flexibility benefit
Reversal: If schema changes weekly or data is primarily document-shaped
Break overall confidence into independent sub-components. Minimum 3, recommended 4-6.
Each sub-component gets:
Overall Confidence: 72%
Sub-components:
Technical Feasibility: 90% [Empirical] -- proven in similar systems (refs: X, Y benchmarks)
Timeline Estimate: 45% [Theoretical] -- based on analogy to past project, but team composition differs
Cost Projection: 60% [Mixed] -- infrastructure costs are empirical, opportunity cost is estimated
Team Capability Match: 75% [Authority] -- based on stated team skills; not independently verified
Risk Assessment: 80% [Theoretical] -- standard failure modes well-understood; novel integration untested
Weighted Overall: (90*0.3 + 45*0.25 + 60*0.15 + 75*0.15 + 80*0.15) = 71.5% ≈ 72%
The overall confidence is NOT the average. Weight sub-components by their importance to the conclusion.
Weakest Link Identification: Which single assumption or sub-conclusion, if wrong, would MOST change the final answer?
Criteria for selecting the weakest link:
Alternative Conclusion: "If [weakest link assumption] is wrong, then the conclusion changes to [X]."
This is not hypothetical filler -- it must be a genuinely reasoned alternative conclusion that follows logically from negating the weakest assumption.
## Reasoning Trace: [Claim/Question]
### Atomic Claims
1. [Claim 1]
2. [Claim 2]
3. [Claim N]
### Assumption Inventory
| # | Assumption | Criticality | Verifiability | Tied to Claim |
|---|-----------|-------------|---------------|---------------|
| A1 | [Statement] | High | Directly Verifiable | Claim 1 |
| A2 | [Statement] | High | Unverifiable | Claim 2 |
| A3 | [Statement] | Medium | Indirectly Verifiable | Claim 1, 3 |
| ... | ... | ... | ... | ... |
### Decision Forks
#### Fork 1: [Decision Point]
- **Chosen:** [Option] -- [rationale with evidence type label]
- **Rejected:** [Option] -- [specific rejection reason]
- *Reversal condition:* [what would make this the right choice]
- **Rejected:** [Option] -- [specific rejection reason]
- *Reversal condition:* [what would make this the right choice]
#### Fork 2: [Decision Point]
...
### Confidence Decomposition
| Dimension | Confidence | Evidence Type | Basis |
|-----------|-----------|---------------|-------|
| [Dimension 1] | XX% | Empirical | [specific justification] |
| [Dimension 2] | XX% | Theoretical | [specific justification] |
| [Dimension 3] | XX% | Authority | [specific justification] |
| [Dimension N] | XX% | Mixed | [specific justification] |
**Overall Confidence: XX%** (weighted by dimension importance)
### Weakest Link
**Assumption [A#]:** [restate the assumption]
- **Criticality:** High
- **Verifiability:** [rating]
- **Current confidence in this assumption:** XX%
- **Why this is the weakest link:** [explanation]
- **How to verify:** [concrete steps the user can take]
### Alternative Conclusion
> If **[weakest assumption]** is wrong, then:
> [Alternative conclusion with reasoning -- not a throwaway sentence but a genuinely traced alternative]
### Falsification Conditions
The main conclusion is wrong if ANY of these turn out to be true:
1. [Condition 1]
2. [Condition 2]
3. [Condition N]
Q: "Why did you recommend React over Vue?"
I recommended React because it has a larger ecosystem, more job
postings, and better TypeScript support. It's the safer choice
for most teams because it's battle-tested at scale by Meta and
many other companies.
Confidence: High.
Problems:
## Reasoning Trace: Why React over Vue for this project?
### Atomic Claims
1. React is a better framework fit for this project's requirements
2. The team will be more productive with React than Vue
3. React's ecosystem advantage outweighs Vue's simplicity advantage
### Assumption Inventory
| # | Assumption | Criticality | Verifiability | Tied to Claim |
|---|-----------|-------------|---------------|---------------|
| A1 | Team has 2+ engineers with React experience | High | Directly Verifiable | Claim 2 |
| A2 | Project requires complex state management | Medium | Directly Verifiable | Claim 1 |
| A3 | Hiring pipeline will favor React candidates | High | Indirectly Verifiable | Claim 2 |
| A4 | Project will need SSR capabilities | Medium | Directly Verifiable | Claim 1 |
| A5 | TypeScript will be used project-wide | Low | Directly Verifiable | Claim 3 |
### Decision Forks
#### Fork 1: Framework Selection
- **Chosen:** React -- larger component ecosystem (npm: 90k+ packages
tagged "react" vs 25k+ "vue"), more mature SSR story (Next.js 15 stable
vs Nuxt 4 recent), team has existing React experience (A1)
- **Rejected:** Vue -- lower learning curve, better developer ergonomics
for smaller teams, Composition API is excellent
- *Reversal condition:* If team has 0 React experience AND project is
< 6 month lifespan AND no SSR needed, Vue's faster onboarding wins
- **Rejected:** Svelte -- best DX, smallest bundle, genuinely better
reactivity model
- *Reversal condition:* If team is greenfield (no framework experience),
project is performance-critical consumer app, and hiring is not a
constraint (small, stable team)
### Confidence Decomposition
| Dimension | Confidence | Evidence Type | Basis |
|-----------|-----------|---------------|-------|
| Framework capability match | 85% | Empirical | Feature comparison against requirements doc |
| Team productivity | 55% | Mixed | Based on stated skills (A1); not observed |
| Ecosystem longevity | 80% | Authority | Meta backing, npm download trends, State of JS 2025 |
| Hiring advantage | 50% | Indirectly Empirical | LinkedIn job postings (3:1 React:Vue ratio, but market shifts) |
**Overall Confidence: 68%** (productivity and hiring are uncertain
but heavily weighted)
### Weakest Link
**Assumption A1:** Team has 2+ engineers with React experience
- **Criticality:** High
- **Verifiability:** Directly Verifiable
- **Current confidence:** 70% (stated by PM, not verified via code review)
- **Why this is the weakest link:** If the team lacks real React
experience, the productivity advantage evaporates and Vue's lower
learning curve becomes the dominant factor
- **How to verify:** Review team members' recent commits; conduct
brief technical screen on React patterns (hooks, context, suspense)
### Alternative Conclusion
> If **team React experience (A1)** is overstated, then Vue is the
> better choice: its gentler learning curve (Composition API maps
> well to React hooks mental model but with less boilerplate),
> better documentation, and faster time-to-productive offset the
> smaller ecosystem. The recommendation flips to Vue with Nuxt.
### Falsification Conditions
1. Team has < 2 engineers genuinely proficient in React (not just "used it once")
2. Project scope shrinks to < 6 months with no SSR requirement
3. Hiring is not a concern (stable team, no growth planned)
swing-options)deep-dive-analyzer)swing-review -- it attacks; this skill exposes)swing-research for facts; this skill traces reasoning about facts)swing-research -> swing-trace -> swing-review (gather facts -> trace reasoning -> stress-test conclusion).whynowlab/swing-skills