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.

1. Never present a single-path narrative. Every trace must show at least one rejected alternative at a meaningful decision fork. "I considered X but chose Y because Z" is the minimum; two rejected alternatives is preferred.
2. Confidence decomposition requires 3+ sub-components. Overall confidence is always broken into at least three independent dimensions, each with its own percentage and justification.
3. Every assumption gets rated. Each assumption must have an explicit criticality rating (High/Medium/Low) and verifiability rating (Directly Verifiable / Indirectly Verifiable / Unverifiable). No unrated assumptions.
4. Weakest Link is MANDATORY. Never skip it. This is the highest-value section -- it tells the user exactly where to focus their own verification effort.
5. No confidence theater. Do not assign high confidence (>80%) without specific justification. Vague appeals to "experience" or "common knowledge" are banned. Every confidence level must cite a concrete basis.
6. Distinguish evidence types. Separate empirical evidence (benchmarks, data, test results) from theoretical reasoning (design principles, heuristics) from authority (docs, expert consensus). Label which type supports each claim.
7. Trace must be falsifiable. Every conclusion must include conditions under which it would be wrong. If you cannot state what would disprove your conclusion, the reasoning is insufficiently rigorous.

--full

1. Stage 1: Claim Isolation — break into atomic claims
2. Stage 2: Assumption Inventory — enumerate assumptions with criticality/verifiability
3. Stage 5: Weakest Link & Alternative Conclusion — identify the single most fragile assumption

undefined

1. [Claim 1]
2. [Claim 2]

• Why weakest: [explanation]
• If wrong: [alternative conclusion]
• How to verify: [concrete steps]

undefined

• High: If this assumption is wrong, the conclusion flips or becomes unjustifiable.
• Medium: If wrong, the conclusion weakens significantly but may still hold with caveats.
• Low: If wrong, the conclusion is largely unaffected.

• Directly Verifiable: Can be tested, measured, or confirmed from authoritative sources.
• Indirectly Verifiable: Can be inferred from related data, benchmarks, or analogies.
• Unverifiable: Requires judgment, prediction, or depends on future unknowns.

1. Decision point: What question needed answering?
2. Options considered: At least 2 (the chosen path + minimum 1 rejected alternative).
3. Evaluation criteria: What factors determined the choice?
4. Chosen path: Which option was selected?
5. Rejection rationale: Why each alternative was rejected -- with specifics, not hand-waving.
6. Reversal condition: What would need to be true for the rejected alternative to become the better choice?

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

• A percentage (0-100%)
• The evidence type supporting it (Empirical / Theoretical / Authority / Mixed)
• A 1-2 sentence justification citing the specific basis

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%

1. Highest criticality among assumptions
2. Lowest verifiability (hardest to confirm)
3. Lowest confidence among sub-components
4. The intersection of these three factors is the weakest link

1. [Claim 1]
2. [Claim 2]
3. [Claim N]

• 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]

• 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]

If [weakest assumption] is wrong, then: [Alternative conclusion with reasoning -- not a throwaway sentence but a genuinely traced alternative]

1. [Condition 1]
2. [Condition 2]
3. [Condition N]

undefined

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.

• No assumptions stated -- what is this "high confidence" based on?
• No alternatives explored -- was Vue even seriously considered?
• No weakest link -- where should the user push back?
• No decision forks -- what criteria determined "larger" or "better"?
• "Battle-tested at scale" is an appeal to authority without specifics
• Reads like a marketing pitch, not a reasoning trace

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

• 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)

• 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)

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.

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)

undefined

• After any recommendation: "Why Postgres?" "Why microservices?" "Why this library?"
• After any estimate: "Why 2 weeks?" "Why $50k?" "Why 3 engineers?"
• During architecture decisions where stakeholders need to audit the reasoning
• Code review rationale: "Why did you flag this as a security issue?"
• When the user says "convince me" or "I'm not sure about this"
• Post-mortem analysis: "Why did we think X would work?"
• Any high-stakes decision where the reasoning must survive scrutiny

• Simple factual lookups with clear answers ("What port does Postgres use?")
• Creative brainstorming where structured reasoning kills ideation (use

  swing-options

  )
• When the user wants a quick answer and explicitly says so
• Exhaustive code/system analysis without a specific claim to trace (use

  deep-dive-analyzer

  )
• Stress-testing someone else's reasoning (use

  swing-review

  -- it attacks; this skill exposes)
• Research requiring external source verification (use

  swing-research

  for facts; this skill traces reasoning about facts)

• With swing-clarify: Run swing-clarify first on ambiguous requests before invoking this skill. Clarified scope produces better results.
• Before swing-review: Trace your reasoning first, then stress-test it. The assumption inventory from swing-trace feeds directly into swing-review's attack vectors.
• After swing-research: Research gathers verified facts; swing-trace then makes the logic connecting those facts to a conclusion transparent.
• With swing-options: When swing-options generates options, swing-trace can trace why one option was selected over others.
• With deep-dive-analyzer: Deep-dive produces exhaustive understanding; swing-trace adds the "so what" -- why that understanding leads to a specific conclusion.
• With skill-composer: Common pipeline:

  swing-research

  ->

  swing-trace

  ->

  swing-review

  (gather facts -> trace reasoning -> stress-test conclusion).