atomise_skill

Overview

This skill implements Atom of Thoughts (AoT) reasoning to decompose genuinely complex problems into minimal, verifiable atoms with confidence tracking and backtracking. It is designed for hard reasoning tasks—security analysis, architecture trade-offs, deep debugging, and multi-step proofs—where linear chains of thought accumulate errors. The goal is a compact, verifiable answer with an explicit confidence score and a traceable chain of atoms.

How this skill works

The skill breaks a problem into atomic subquestions (1–2 sentences each), solves leaf nodes first, verifies each hypothesis with tests or counterexamples, and then contracts the verified state into a short summary. Confidence is tracked per atom and propagated: a child atom cannot exceed its least-confident parent. If verification yields low confidence, the system backtracks and explores alternative decompositions until a confidence threshold is reached or all paths are exhausted.

When to use it

• Security threat modeling or adversarial analysis where assumptions must be tested
• Complex architecture decisions requiring tradeoffs and constraints reasoning
• Multi-step debugging where root causes are unclear and require independent checks
• Formal or informal proofs that benefit from independent verification of premises
• High-stakes decisions that need traceable confidence and structured backtracking

Best practices

• State premises explicitly as atoms (given facts = 1.0, assumptions = 0.6)
• Keep atoms minimal: 1–2 sentences each to avoid hidden assumptions
• Always attach a verification step to hypotheses (counterexample, tests, domain checks)
• Use --light for quick overviews, --deep for exhaustive exploration
• Contract aggressively: summarize verified state in two sentences before continuing

Example use cases

• Analyze whether an authentication flow is vulnerable to session fixation (--security)
• Decide whether to adopt event sourcing for a domain with complex consistency needs (--deep --design)
• Find the root cause of a flakey function that returns null on the second call (--code)
• Validate a multi-step mathematical claim with boundary and counterexample checks (--math)
• Compare cache technologies when performance, cost, and failure modes must be weighed (--light)