atomise
/atomise
Rozkłada złożone problemy na atomowe jednostki rozumowania z kontrolą pewności i cofaniem, metodą Atom of Thoughts, do naprawdę złożonych zagadnień.
- Autor
- 0xDarkMatter ↗
- Repozytorium
- claude-mods ↗
- Licencja
- MIT
- Ostatnia zmiana repozytorium
- 15.10.2026
Ocena i bezpieczeństwo
- Pliki w paczce
- 4
- Skrypty
- 0
- Komentarze HTML
- 0
- Adresy URL w SKILL.md
- 0
Brak sygnałów. Repozytorium zmienione 15.10.2026, bez odwołań do wycofanych modeli i API.
MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.
Co robi i kiedy
Rozkłada złożone problemy na atomowe jednostki rozumowania z kontrolą pewności i cofaniem, metodą Atom of Thoughts, do naprawdę złożonych zagadnień.
Oryginalny opis (EN)
Atom of Thoughts (AoT) reasoning - decompose complex problems into atomic units with confidence tracking and backtracking. For genuinely complex reasoning, not everyday questions. Triggers on: atomise, complex reasoning, decompose problem, structured thinking, verify hypothesis.
Jak działa
- The Core Loop
- Atoms
- Confidence (Honest Caveat)
- Modes
- Output
- Execution Guide
- Examples
- Anti-Patterns
- Remember
Podgląd SKILL.md
---
name: atomise
description: "Atom of Thoughts (AoT) reasoning - decompose complex problems into atomic units with confidence tracking and backtracking. For genuinely complex reasoning, not everyday questions. Triggers on: atomise, complex reasoning, decompose problem, structured thinking, verify hypothesis."
license: MIT
compatibility: "Pure reasoning framework, no external dependencies."
allowed-tools: "Read"
metadata:
author: claude-mods
---
# Atomise - Atom of Thoughts Reasoning
Decompose complex problems into minimal, verifiable "atoms" of thought. Unlike chain-of-thought (linear, error-accumulating), AoT treats each step as independently verifiable and backtracks when confidence drops.
**Use for:** Security analysis, architectural decisions, complex debugging, multi-step proofs.
**Don't use for:** Simple questions, trivial calculations, information lookup.
```
/atomise "<problem>" [--light | --deep] [--math | --code | --security | --design]
```
---
## The Core Loop
```
1. DECOMPOSE -> Break into atomic subquestions (1-2 sentences each)
2. SOLVE -> Answer leaf nodes first, propagate up
3. VERIFY -> Test each hypothesis (counterexample, consistency, domain check)
4. CONTRACT -> Summarize verified state in 2 sentences (drop history)
5. EVALUATE -> Confident enough? Done. Too uncertain? Backtrack and try another path.
```
Repeat until confident or all paths exhausted.
---
## Atoms
Each atom is a minimal unit:
```
{id, type, content, depends_on[], confidence, verified}
```
| Type | Purpose | Starting Confidence |
|------|---------|---------------------|
| **premise** | Given facts | 1.0 |
| **reasoning** | Logical inference | Inherited from parents |
| **hypothesis** | Claim to test | Max 0.7 until verified |
| **verification** | Test result | Based on test outcome |
| **conclusion** | Final answer | Propagated from chain |
**Confidence propagates:** A child can't be more confident than its least-confident parent.
---
## Confidence (Honest Caveat)
These numbers are *heuristic*, not calibrated probabilities. They're useful for tracking relative certainty, not for actual risk assessment.
| Threshold | Meaning |
|-----------|---------|
| **> 0.85** | Confident enough to conclude |
| **0.6 - 0.85** | Needs more verification |
| **< 0.6** | Decompose further or backtrack |
| **< 0.5** | Backtrack - this path isn't working |
**Verification adjusts confidence:**
- Confirmed -> maintain or slight boost
- Partial -> reduce ~15%
- Refuted -> major reduction, likely backtrack
---
## Modes
**Depth:**
- `--light` - Fast: max 3 levels, 0.70 confidence threshold
- *(default)* - Standard: max 5 levels, 0.85 threshold
- `--deep` - Exhaustive: max 7 levels, 0.90 threshold
**Domain** (adjusts verification style):
- `--math` - Arithmetic checks, proof validation, boundary tests
- `--code` - Type checking, invariant verification, test generation
- `--security` - Threat modeling, attack surface, adversarial thinking
- `--design` - Tradeoff analysis, constraint satisfaction, feasibility
---
## Output
```
ANSWER: {result}
CONFIDENCE: {0.0-1.0} - {why}
KEY CHAIN: P1 -> R1 -> H1 -> V1 -> C1
ATOMS:
| id | type | content | conf | verified |
|----|------|---------|------|----------|
| P1 | premise | Given: ... | 1.0 | Y |
| R1 | reasoning | Therefore: ... | 0.95 | Y |
| ... | ... | ... | ... | ... |
RISKS: {what could change this}
```
Add `--verbose` for full trace, `--quiet` for just the answer.
---
## Execution Guide
### Phase 0: Setup
1. **Restate** the problem in one sentence
2. **Extract premises** as atoms (given facts = 1.0, assumptions = 0.6)
3. **Sketch approaches:** Direct solve? Decompose? Reframe? Pick best.
### Phase 1+: Iterate
1. **Atomicity gate:** Can you answer from verified atoms? Yes -> solve. No -> decompose.
2. **Decompose:** Build dependency tree of atomic subquestions
3. **Solve + Verify:** Leaves first, propagate up. Every hypothesis needs verification.
4. **Contract:** Summarize in <=2 sentences. Drop everything else.
5. **Evaluate:**
- Confident? -> Terminate
- Uncertain but viable? -> Continue
- Low confidence? -> Backtrack, try alternative
### Backtracking
When a path yields confidence < 0.5 after verification:
1. Prune that branch
2. Restore to last contracted state
3. Try alternative from initial sketch
---
## Examples
```bash
# Complex debugging
/atomise "Why does this function return null on the second call?" --code
# Security review
/atomise "Is this authentication flow vulnerable to session fixation?" --security
# Architecture decision
/atomise "Should we use event sourcing for this domain?" --deep --design
# Quick decision (light mode)
/atomise "Redis vs Memcached for this cache layer?" --light
```
---
## Anti-Patterns
```
BAD: /atomise "What's 2+2?" -> Just answer it
BAD: /atomise "Rewrite this function" -> That's implementation, not reasoning
BAD: Forcing conclusion despite low confidence -> Let it backtrack
GOOD: /atomise for genuine uncertainty requiring structured decomposition
```
---
## Remember
1. **Atomic = minimal.** 1-2 sentences per atom.
2. **Verify everything.** Hypotheses need tests.
3. **Contract aggressively.** Keep only what's needed for next step.
4. **Backtrack freely.** Low confidence means try another path.
5. **Confidence is heuristic.** Useful for structure, not actual probabilities.
Pliki w paczce (4)
- SKILL.md 5 KB
- assets/.gitkeep 1 KB
- references/.gitkeep 1 KB
- scripts/.gitkeep 1 KB
Wersje
W bazie nie ma innych skilli o nazwie atomise.
Identyczna treść występuje jeszcze w 1 innych folderach na GitHubie. Tu pokazujemy jedną, najlepiej ocenioną kopię.
Migawka bazy z 13.11.2026 · wersja paczki 44ef7009d50b (skrót SHA-256 całej paczki)
Pobrania w ostatnich 30 dniach: 0 · ranking
Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.
Podobne skille
- 100sequential-thinking
Dzieli złożone problemy na łańcuch rozumowania krok po kroku, by ułatwić planowanie i analizę. - 95prompt-tree-of-thoughts
Przeszukuje częściowe rozwiązania w strukturze drzewa, z oceną stanów, cofaniem się i limitami kosztów. - 100reasoning-router
Klasyfikuje trudne problemy i kieruje je do właściwego z jedenastu serwerów myślenia MCP, a przy spadku pewności przekierowuje zadanie. - 95thought-based-reasoning
Opisuje techniki rozumowania krok po kroku, takie jak Chain-of-Thought, Self-Consistency, Tree of Thoughts, ReAct i Reflexion, z szablonami i macierzami decyzji dla złożonych zadań. - 100tree-of-thoughts
Prowadzi ustrukturyzowane rozumowanie przez rozgałęzianie, ocenę, przycinanie i rozwijanie drzewa rozwiązań albo jeden uporządkowany łańcuch, przy architekturze, planowaniu refaktoryzacji i debugowaniu. - 90ck:sequential-thinking
Prowadzi krok po kroku analizę złożonych problemów z możliwością korekty, weryfikując hipotezy i dzieląc problem na części.