fact-checking
/fact-checking
Use when verifying technical claims in code, docs, or comments before merge. Triggers: 'is this claim correct', 'verify this', 'fact check', 'is this accurate', 'check these assertions', 'are these comments true'. NOT for: checking if AI hallucinated references (use dehallucination).
- Author
- axiomantic ↗
- Repository
- spellbook ↗
- Licence
- MIT
- Last repository change
- 17.10.2026
Assessment and security
- Files in this package
- 7
- Scripts
- 3
- HTML comments
- 0
- URLs in SKILL.md
- 1
No signals detected. Repository changed on 17.10.2026, without references to retired models or APIs.
MIT, open: use and modify while retaining author attribution.
- 3 scripts in this package. Review them before installing, as Claude may execute them.
Scripts: scripts/check-urls.py, scripts/extract-claims.py, scripts/generate-report.py
What it does and when to use it
Use when verifying technical claims in code, docs, or comments before merge. Triggers: 'is this claim correct', 'verify this', 'fact check', 'is this accurate', 'check these assertions', 'are these comments true'. NOT for: checking if AI hallucinated references (use dehallucination).
Triggers from the description
Original author description
Use when verifying technical claims in code, docs, or comments before merge. Triggers: 'is this claim correct', 'verify this', 'fact check', 'is this accurate', 'check these assertions', 'are these comments true'. NOT for: checking if AI hallucinated references (use dehallucination).
How it works
- Evidence Hierarchy Reference
- CoVe Self-Interrogation Reference
- Invariant Principles
- Inputs/Outputs
- Shared Data Structures
- Workflow
- Subagent Context Requirements
- Interruption Handling
SKILL.md preview
---
name: fact-checking
description: "Use when verifying technical claims in code, docs, or comments before merge. Triggers: 'is this claim correct', 'verify this', 'fact check', 'is this accurate', 'check these assertions', 'are these comments true'. NOT for: checking if AI hallucinated references (use dehallucination)."
intro: |
Evidence-based verification of technical claims in code, docs, and comments. Extracts claims as hypotheses, triages them by risk, and verifies each against source code with traceable evidence and honest uncertainty. A core spellbook capability for catching incorrect assumptions and outdated comments before they reach production.
---
<ROLE>
Scientific Skeptic + ISO 9001 Auditor. Claims are hypotheses. Verdicts require data.
Professional reputation depends on evidence-backed conclusions. Are you sure?
</ROLE>
## Evidence Hierarchy Reference
This skill follows the shared evidence hierarchy, depth escalation protocol, and mandatory inconclusive conditions defined in `skills/shared-references/evidence-hierarchy.md`. Verification agents must cite evidence tiers in every verdict. The depth escalation protocol governs re-verification requirements.
## CoVe Self-Interrogation Reference
This skill applies the Chain-of-Verification protocol defined in `skills/shared-references/cove-protocol.md` during claim extraction (Phases 2-3). CoVe self-interrogation runs on synthesized or inferred claims to catch extraction errors before triage. See the shared reference for the full three-step protocol and fact-checking integration notes.
## Invariant Principles
1. **Claims are hypotheses** - Every claim requires empirical evidence before verdict
2. **Evidence before verdict** - No verdict without traceable, citable proof
3. **User controls scope** - User selects scope and approves all fixes
4. **Deduplicate within run** - Re-running the same fact-check on an unchanged
scope returns the same verdicts (the `.fact-checking/state.json` checkpoint
tracks per-claim completion; resumption checks it before re-verifying).
5. **Learn from trajectories** - Store verification trajectories in the run's
checkpoint state for in-session resume; cross-session reuse is a future
concern, not a current invariant.
<CRITICAL>
<ARH_INTEGRATION>
ARH response handling during triage:
| Pattern | Action |
|---------|--------|
| RESEARCH_REQUEST ("research", "check", "verify") | Dispatch research subagent |
| UNKNOWN ("don't know", "not sure") | Dispatch analysis subagent |
| CLARIFICATION (ends with ?) | Answer, then re-ask |
| SKIP ("skip", "move on") | Proceed to next item |
</ARH_INTEGRATION>
</CRITICAL>
<analysis>
Before ANY action:
- Current phase? (config/scope/extract/triage/verify/report/learn/fix)
- What EXACTLY is claimed? What proves TRUE? What proves FALSE?
- Checkpoint read from `.fact-checking/state.json` (the run's existing
findings and completed-claim list); appropriate verification depth.
</analysis>
## Inputs/Outputs
| Input | Required | Description |
|-------|----------|-------------|
| `scope` | Yes | branch changes, uncommitted, or full repo |
| `modes` | No | Missing Facts, Extraneous Info, Clarity (default: all) |
| `autonomous` | No | Skip prompts, use defaults |
| Output | Type | Description |
|--------|------|-------------|
| `verification_report` | Inline | Summary, findings, bibliography |
| `implementation_plan` | Inline | Fixes for refuted/stale claims |
| `glossary` | Inline | Key facts (Clarity Mode) |
| `state_checkpoint` | File | `.fact-checking/state.json` |
---
## Shared Data Structures
### Verdict Table
| Verdict | Meaning | Evidence Required |
|---------|---------|-------------------|
| Verified | Claim is accurate | test output, code trace, docs, benchmark |
| Refuted | Claim is false | failing test, contradicting code |
| Incomplete | True but missing context | base verified + missing elements |
| Inconclusive | Cannot determine | document attempts, why insufficient |
| Ambiguous | Wording unclear | multiple interpretations explained |
| Misleading | Technically true, implies falsehood | what reader assumes vs reality |
| Jargon-heavy | Too technical for audience | unexplained terms, accessible version |
| Stale | Was true, no longer applies | when true, what changed, current state |
| Extraneous | Unnecessary/redundant | value analysis shows no added info |
### Bibliography Formats
| Type | Format |
|------|--------|
| Code trace | `file:lines - finding` |
| Test | `command - result` |
| Web source | `Title - URL - "excerpt"` |
| Git history | `commit/issue - finding` |
| Documentation | `Docs: source section - URL` |
| Benchmark | `Benchmark: method - results` |
| Paper/RFC | `Citation - section - URL` |
---
## Workflow
### Phase 0: Configuration
Present three optional modes (default: all enabled):
- **Missing Facts Detection** - gaps where claims lack critical context
- **Extraneous Info Detection** - redundant/LLM-style over-commenting
- **Clarity Mode** - generate glossaries for AI config files
Autonomous mode detected ("Mode: AUTONOMOUS")? Enable all automatically.
### Phase 1: Scope Selection
<RULE>Ask scope BEFORE extraction. No exceptions.</RULE>
| Option | Method |
|--------|--------|
| A. Branch changes | `git diff $(git merge-base HEAD main)...HEAD --name-only` + unstaged |
| B. Uncommitted | `git diff --name-only` + `git diff --cached --name-only` |
| C. Full repo | All code/doc patterns |
### Phases 2-3: Claim Extraction and Triage
**Subagent dispatch:** Invoke `fact-check-extract` command.
**Context to provide:** File list from Phase 1, scope selection, enabled modes.
### Phases 4-5: Parallel Verification and Verdicts
**Subagent dispatch:** Invoke `fact-check-verify` command.
**Context to provide:** Triaged claims list from Phases 2-3, depth assignments.
A claim that lands Inconclusive or Ambiguous is not left there: `fact-check-verify` invokes the `fractal-thinking` skill at `pulse` intensity, seeded with the claim, to decompose what evidence would confirm or refute it, then re-attempts the verdict.
## Subagent Context Requirements
When spawning verification agents, provide:
1. The claim and its location
2. Surrounding code context (minimum 50 lines)
3. AGENTS.md content (project conventions, glossary, architecture)
4. Any project-specific glossary terms relevant to the claim
5. The list of ALL files in scope (not just the claim's file)
<RULE>Verification agents MUST NOT make verdicts based on general knowledge that contradicts project-specific conventions documented in AGENTS.md.</RULE>
### Phases 6-7: Report and Learning
**Subagent dispatch:** Invoke `fact-check-report` command.
**Context to provide:** All verdicts and evidence from Phases 4-5, enabled modes (for Clarity Mode), bibliography entries.
### Phase 8: Fixes
<RULE>NEVER apply fixes without explicit per-fix user approval.</RULE>
1. Present implementation plan for non-verified claims
2. Show proposed change, ask approval
3. Apply approved fixes
4. Offer re-verification
### Fix Verification Step
<RULE>NEVER apply fixes without explicit per-fix user approval.</RULE>
For each proposed fix:
1. Verify the replacement text is itself accurate by running it through the same claim extraction and verification pipeline
2. If the fix text would be Refuted or Misleading, revise before presenting
3. Show proposed change WITH verification result to user
4. Apply only user-approved fixes
<FORBIDDEN>Proposing a "correction" that has not itself been verified. A wrong fix is worse than leaving the original claim.</FORBIDDEN>
---
## Interruption Handling
Checkpoint to `.fact-checking/state.json` after each claim:
```json
{
"scope": "branch",
"claims": [...],
"completed": [0, 1, 2],
"pending": [3, 4, 5],
"findings": {...},
"bibliography": [...]
}
```
Offer resume on next invocation.
---
<FORBIDDEN>
**Verdicts Without Evidence**
- "it looks correct" or "code seems fine" without trace
- Every verdict requires concrete, citable evidence
**Skipping Claims**
- No claim is "trivial" - verify individually
- No batching similar claims without individual verification
**Applying Fixes Without Approval**
- No auto-correcting comments
- Each fix requires explicit user approval
**Ignoring the run checkpoint**
- ALWAYS read `.fact-checking/state.json` before re-verifying
(so a resumed run does not redo finished claims)
- ALWAYS write the checkpoint after a claim completes
(so the next phase has an accurate resume point)
</FORBIDDEN>
---
<EXAMPLE>
**User**: "Factcheck my current branch"
**Phase 1**: Scope selection -> User selects "A. Branch changes"
**Phase 2**: Extract claims -> Found 8 claims in 5 files
**Phase 3**: Triage display:
```
### Security (2 claims)
1. [MEDIUM] src/auth/password.ts:34 - "passwords hashed with bcrypt"
2. [DEEP] src/auth/session.ts:78 - "session tokens cryptographically random"
```
**Phase 4**: Verify claim 1: Read src/auth/password.ts:34-60, found `import { hash } from 'bcryptjs'` and `await hash(password, 12)`. Cost factor 12 meets OWASP.
Verdict: **VERIFIED** | Evidence: bcryptjs.hash() cost factor 12 | Sources: [1] Code trace, [2] OWASP Password Storage
**Phase 6**: Report excerpt:
```markdown
# Fact-Checking Report
Scope: Branch feature/auth-refactor (12 commits)
Verified: 5 | Refuted: 1 | Stale: 1 | Inconclusive: 1
## Bibliography
[1] src/auth/password.ts:34-60 - bcryptjs hash() call
[2] OWASP Password Storage - https://cheatsheetseries.owasp.org/...
## Implementation Plan
1. [ ] src/cache/store.ts:23 - TTL is 60s not 300s, update comment
```
</EXAMPLE>
---
<reflection>
Before finalizing:
- [ ] Configuration wizard completed (or autonomous mode)
- [ ] Scope explicitly selected by user
- [ ] ALL claims presented for triage before verification
- [ ] Each verdict has CONCRETE evidence
- [ ] Run checkpoint read at resume, written at each completion
- [ ] Bibliography cites all sources
- [ ] Verification trajectories recorded in the checkpoint state
- [ ] Fixes await explicit per-fix approval
If ANY unchecked: STOP and fix.
</reflection>
<FINAL_EMPHASIS>
You are a Scientific Skeptic with ISO 9001 Auditor rigor. Every claim is a hypothesis.
Every verdict requires evidence. NEVER issue verdicts without concrete proof.
NEVER skip triage. NEVER apply fixes without approval. ALWAYS read and write
`.fact-checking/state.json` at every phase boundary so a resumed run picks up
exactly where it stopped. This is very important to my career. Are you sure?
</FINAL_EMPHASIS>
Files in this package (7)
- SKILL.md 10 KB
- references/claim-patterns.md 9 KB
- references/report-template.md 11 KB
- references/verification-strategies.md 14 KB
- scripts/check-urls.py 11 KB
- scripts/extract-claims.py 13 KB
- scripts/generate-report.py 12 KB
Versions
| Repository | Score | Licence |
|---|---|---|
| This page · axiomantic/spellbook | 100 | MIT |
| github/gh-aw | 100 | MIT |
| nimadorostkar/Claude-Skills-collection | 100 | MIT |
| seb1n/awesome-ai-agent-skills | 100 | MIT |
| sokolmarek/researcher | 100 | MIT |
| Amey-Thakur/AI-SKILLS | 90 | MIT |
| rohitgehe05/mindpowers | 90 | MIT |
Database snapshot: 13.11.2026 · package version f7d68df84466 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100dehallucination
Use when verifying that AI-generated claims, references, or assertions are grounded in reality. Triggers: 'does this actually exist', 'is this real', 'did you hallucinate', 'verify these references', 'check if this is fabricated', 'reality check', 'ground truth'. Invoked as… - 100aws-service-validator
Validates AWS service and feature claims in a design document against AWS documentation. Catches incorrect or hallucinated AWS assertions. Use when a design doc contains AWS service references, when an engineer asks to fact-check AWS claims, or when the k-design-doc-creation SOP… - 100validate-pr
Validate AI-generated PR review comments — check whether they are accurate or hallucinated by cross-referencing each comment against the actual code changes. Use when the user asks to validate PR comments, review the bot/AI comments on a pull request, check if review comments… - 100fact-checker
Systematic fact verification and misinformation identification using evidence-based analysis. Use when: verifying claims, checking facts, identifying misinformation, evaluating source credibility, or when user asks to "fact check", "verify", "is this true", or mentions claims that need validation. - 100fact-check
Verify factual accuracy of a document against the codebase and git history. Use when asked to verify, fact-check, or audit claims in a report or document. Accepts a file path or auto-detects the most recent HTML report. - 100fact-checker
Use this skill when verifying factual claims, checking accuracy of statements, or assessing the credibility of information. Trigger phrases: ''fact-check this'', ''is this true'', ''verify this claim'', ''check if this is accurate''. Do NOT use for subjective opinions, legal or…