npbuilds Claim Decomposer — The Splitter
Every complex question is built from simpler claims stacked together. This skill takes a research question apart, surfaces hidden assumptions, and produces a numbered list of atomic claims that can each be independently verified.
The decomposer prevents the most common research failure: investigating a compound question as if it were a single thing, then producing a muddled answer that conflates distinct issues.
How to Run
Input
From the Spelunker orchestrator:
- The restated research question
- The detected domain (affects decomposition strategy)
- Any user-specified constraints
Steps
Step 1 — Identify the Claim Structure
Read references/decomposition-patterns.md for the pattern catalog.
Scan the question for structural signals:
| Signal | Structure | Action |
|---|---|---|
| "and", "as well as", "also" | Compound — multiple claims joined | Split at each conjunction |
| "because", "since", "therefore" | Causal chain — claim depends on premise | Separate premise from conclusion |
| "if", "assuming", "given that" | Conditional — claim has prerequisite | Extract the prerequisite as its own claim |
| "better than", "more effective than", "compared to" | Comparative — two things measured | Decompose into claims about each thing + the comparison |
| "always", "never", "everyone" | Universal — sweeping scope | Note the scope as a testable claim |
| No signals, but question is broad | Implicit compound — topic has multiple facets | Break into the 2-4 most important facets |
Step 2 — Surface Hidden Assumptions
Every question carries assumptions. Make them explicit:
- Definitional assumptions — Does the question assume a specific meaning for a term? ("Is AI dangerous?" assumes we agree on what "AI" and "dangerous" mean)
- Existence assumptions — Does the question assume something exists or is true? ("Why did X cause Y?" assumes X did cause Y)
- Scope assumptions — Does the question assume a time period, population, or context? ("Is X safe?" — safe for whom? at what dose? over what time period?)
- Value assumptions — Does the question embed a judgment? ("Is X the best approach?" — best by what criteria?)
Each surfaced assumption becomes a separate verifiable claim unless it's a pure definitional choice (in which case, note it as a framing decision).
Step 3 — Classify Each Atomic Claim
Assign a type and a domain to each claim. The type determines the verification strategy. The domain determines which tools the source-triangulator should use (see ../spelunker/references/domain-routing.md for the full tool chain mapping).
Domain assignment: Use the domain detected in Phase 1 as the default, but override per-claim when a specific claim belongs to a different domain. Multi-domain questions are common — "Is intermittent fasting good for software developers?" has biomedical claims (fasting's health effects) and behavioral claims (productivity impact). Each claim gets the domain that matches its evidence needs.
| Claim Type | Description | Verification Strategy |
|---|---|---|
| Factual | A specific, checkable assertion of fact | Look for authoritative sources, official data, direct evidence |
| Causal | X causes/leads to/results in Y | Look for experimental evidence (RCTs), controlled studies, mechanism explanations |
| Comparative | X is more/less/better/worse than Y | Look for head-to-head comparisons, benchmarks, meta-analyses |
| Predictive | X will happen / X is likely | Look for forecasting models, historical precedents, expert predictions |
| Definitional | What X means or how it's classified | Look for authoritative definitions, standard classifications, consensus usage |
| Existential | Whether X exists or has occurred | Look for direct evidence, records, documentation |
| Evaluative | Whether X is adequate, sufficient, or good (judgment-dependent) | Look for established criteria/standards, expert assessments, outcome-based evidence |
Step 4 — Assign Priority
Each claim gets a priority that determines how much investigative effort it receives:
- Critical — The conclusion depends on this claim. If this claim falls, the answer changes. Premises in causal chains, core factual assertions, and the main comparison in comparative questions are typically critical.
- Supporting — Strengthens a critical claim but isn't load-bearing on its own. Background context, corroborating facts, and secondary comparisons are typically supporting.
- Contextual — Useful background that helps the user understand the answer but doesn't affect the conclusion's validity. Definitional claims and scope-setting facts are typically contextual.
Rule of thumb: If you removed this claim from the brief, would the conclusion change? Yes → critical. Would the conclusion weaken? → supporting. Would only the framing change? → contextual.
Step 5 — Order by Dependency
Some claims depend on others. Map the dependency graph:
- If Claim B assumes Claim A is true, verify A first
- If Claim C is independent of A and B, it can be verified in parallel
- If the conclusion depends on all premises, note that the conclusion's confidence cannot exceed the weakest premise
Step 6 — Output the Claim List
Produce a structured output:
CLAIM DECOMPOSITION
───────────────────
Original question: [the restated question]
Atomic Claims:
1. [Claim text] — Type: [factual/causal/etc.] — Domain: [biomedical/technical/etc.] — Depends on: [none/claim#] — Priority: [critical/supporting/contextual] — Strategy: [brief guidance]
2. [Claim text] — Type: [type] — Domain: [domain] — Depends on: [dependencies] — Priority: [priority] — Strategy: [guidance]
...
Hidden Assumptions Surfaced:
A1. [Assumption text] — Status: [needs verification / framing decision / common ground]
A2. ...
Dependency Graph:
[Claim 1] → [Claim 3] (Claim 3 depends on Claim 1)
[Claim 2] ── (independent, can run in parallel)
Recommended Investigation Order:
Wave 1 (parallel): Claims [2, 4] (independent)
Wave 2 (sequential): Claim [1] then Claim [3] (dependency)
Wave 3: Assumptions [A1] (if not common ground)
Output
A structured claim list ready for the source-triangulator to process. Each claim is:
- Atomic (cannot be meaningfully split further)
- Typed (so the triangulator knows what kind of evidence to seek)
- Domain-tagged (so the triangulator knows which tools to use)
- Priority-ranked: critical (conclusion depends on this), supporting (strengthens a critical claim), or contextual (useful background but not load-bearing)
- Ordered (so dependencies are respected)
- Annotated with verification strategy
Error Handling
Question is already atomic: Return it as a single claim with type classification. Note that no decomposition was needed.
Question is too vague to decompose: Return to the orchestrator requesting clarification. Suggest 2-3 specific interpretations for the user to choose from.
Decomposition produces 15+ claims: Flag to the orchestrator that the question is extremely broad. Suggest grouping claims into priority tiers (must-verify, should-verify, nice-to-verify) and let the user prioritize.
Circular dependencies detected: Flag the logical circularity. This often reveals a flawed question structure that the user should be made aware of.