agentleFS
axiomanticaxiomantic/spellbook/skills/fact-checking/SKILL.md

fact-checking

Skill11 starsChanged 3 months agoMITView on GitHub

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

We split this skill into the rules it gives an agent

15 rules. 0 are common, 11 are distinctive, and 4 are very specific to this project.

  • 0

    Common

    Most of the 6 edited versions we read keep these.

  • 11

    Distinctive

    This author's own choices. Worth a look.

  • 4

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Claims are hypotheses: - Every claim requires empirical evidence before verdict

    line 23
  2. Distinctive:

    Evidence before verdict: - No verdict without traceable, citable proof

    line 24
  3. Distinctive:

    When spawning verification agents, provide:

    line 136
  4. Distinctive:

    Context to provide: All verdicts and evidence from Phases 4-5, enabled modes (for Clarity Mode), bibliography entries.

    line 148
  5. Distinctive:

    Verify the replacement text is itself accurate by running it through the same claim extraction and verification pipeline

    line 164
  6. Distinctive:

    If the fix text would be Refuted or Misleading, revise before presenting

    line 165
  7. Distinctive:

    Every verdict requires concrete, citable evidence

    line 194
  8. Distinctive:

    No claim is "trivial" - verify individually

    line 197
  9. Distinctive:

    No batching similar claims without individual verification

    line 198
  10. Very specific:

    ALWAYS read .fact-checking/state.json before re-verifying (so a resumed run does not redo finished claims)

    line 205
  11. Distinctive:

    ALWAYS write the checkpoint after a claim completes (so the next phase has an accurate resume point) </FORBIDDEN>

    line 207
  12. Very specific:

    Phase 4: Verify claim 1: Read src/auth/password.ts:34-60, found import { hash } from 'bcryptjs' and await hash(password, 12).

    line 224
  13. Distinctive:

    If ANY unchecked: STOP and fix.

    line 253
  14. Very specific:

    Every verdict requires evidence.

    line 258
  15. Very specific:

    NEVER skip triage. NEVER apply fixes without approval.

    line 259

“Common” is measured: kept by at least 6 in 10 of the 6 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md
<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:
PatternAction
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

InputRequiredDescription
scopeYesbranch changes, uncommitted, or full repo
modesNoMissing Facts, Extraneous Info, Clarity (default: all)
autonomousNoSkip prompts, use defaults
OutputTypeDescription
verification_reportInlineSummary, findings, bibliography
implementation_planInlineFixes for refuted/stale claims
glossaryInlineKey facts (Clarity Mode)
state_checkpointFile.fact-checking/state.json

Shared Data Structures

Verdict Table

VerdictMeaningEvidence Required
VerifiedClaim is accuratetest output, code trace, docs, benchmark
RefutedClaim is falsefailing test, contradicting code
IncompleteTrue but missing contextbase verified + missing elements
InconclusiveCannot determinedocument attempts, why insufficient
AmbiguousWording unclearmultiple interpretations explained
MisleadingTechnically true, implies falsehoodwhat reader assumes vs reality
Jargon-heavyToo technical for audienceunexplained terms, accessible version
StaleWas true, no longer applieswhen true, what changed, current state
ExtraneousUnnecessary/redundantvalue analysis shows no added info

Bibliography Formats

TypeFormat
Code tracefile:lines - finding
Testcommand - result
Web sourceTitle - URL - "excerpt"
Git historycommit/issue - finding
DocumentationDocs: source section - URL
BenchmarkBenchmark: method - results
Paper/RFCCitation - 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>

OptionMethod
A. Branch changesgit diff $(git merge-base HEAD main)...HEAD --name-only + unstaged
B. Uncommittedgit diff --name-only + git diff --cached --name-only
C. Full repoAll 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:

{
  "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:

# 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>

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

Reviews can't be read right now.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.