reasoning

reasoning-skills

A Claude Code plugin marketplace with one plugin, reasoning, shipping three skills: atom-of-thought, which decomposes complex problems before answering; confess, which audits Claude's own work afterward; and postmortem, which turns a finished session into a root-cause analysis and proposed fixes.

Installation

Inside a Claude Code session:

1. Add the marketplace

/plugin marketplace add benjaminjackson/reasoning-skills

2. Install the plugin

/plugin install reasoning@reasoning-skills

3. Confirm it installed

/plugin list

atom-of-thought

Helps Claude catch the sub-parts and hidden dependencies that a one-shot answer misses, by decomposing a multi-part problem into sub-questions, solving them in dependency order, and recombining them into one answer, checked at the end against a direct, one-shot attempt. See What to expect below for the concrete shape this takes.

Each step needs only the current state, not the full history, so you never have to hold the whole problem in your head at once.

The skill is based on "Atom of Thoughts for Markov LLM Test-Time Scaling" (Teng et al., NeurIPS 2025), adapted here from a test-time-scaling technique into a prompting skill Claude runs during a conversation.

Usage

• Explicitly, as a slash command:

  /reasoning:atom-of-thought <your problem>
  

• Automatically, when Claude judges a prompt warrants it: phrases like "atom of thought," "AoT," "break this down systematically," "decompose this problem," or "atomic decomposition" will trigger it, as will any tangled analytical, planning, or reasoning task.

It's built for problems with structure to decompose: multiple sub-questions, some of which depend on others. For a single-part question it's the wrong tool: you'll get the overhead of decomposition with nothing to decompose.

What to expect

Output is longer and more structured than a normal reply. You'll see six sections, roughly in this shape:

## Step 1: Direct Assessment
[a quick baseline answer]

## Step 2: Atomic Decomposition
Q1: ... — DEPENDENCIES: none
Q2: ... — DEPENDENCIES: none
Q3: ... — DEPENDENCIES: [Q1, Q2]
Completeness check: ...

## Step 3: Parallel Resolution
Q1 → ...
Q2 → ...

## Step 4: Dependency Resolution
Q3 (needs Q1, Q2): ...

## Step 5: Contraction & Integration
Contracted Problem: ...
Final Answer: ...

## Step 6: Ensemble Validation
[direct vs. decomposed answer, and which one wins]

Expect a trade: more tokens and more time per answer, for fewer missed sub-parts and dependencies on complex problems. On easy ones, that trade isn't worth it, which is why the skill triggers only on complex, multi-part problems.

Paper

Fei Teng, Quan Shi, Zhaoyang Yu, Jiayi Zhang, Yuyu Luo, Chenglin Wu, Zhijiang Guo. "Atom of Thoughts for Markov LLM Test-Time Scaling." NeurIPS 2025. arXiv:2502.12018 · official code

The paper's core move: existing test-time scaling methods burn extra compute re-processing the whole history at every step. The authors instead treat reasoning as a Markov process, where each step depends only on the current state, not the full history, and scale the approach with tree search and reflective refinement. Doing so surfaces an atomic structure: reasoning decomposes cleanly into self-contained, low-complexity units called Atom of Thoughts (AoT). In their experiments, AoT consistently beats baselines as compute budget grows, and composes with reasoning and non-reasoning LLMs.

This skill is a prompting-level adaptation of that idea, not a port of the paper's code. The original is a multi-agent, tool-driven pipeline; it's the same decompose → resolve → contract shape, run as instructions for Claude in a single conversation.

confess

A self-audit of work Claude just finished (not a re-check of whether the work is correct, but a report on how confident Claude is in it), so shortcuts and unverified assumptions surface before they cause problems. When triggered, Claude reports:

1. A confidence score (1-10) per component, with reasons.
2. Every shortcut or "good enough" call it made, why, and the risk.
3. Every assumption it made without verifying, and how to verify it.
4. Issues it noticed but didn't handle.
5. What would raise its confidence, as a concrete checklist.
6. The weakest part of the work, named plainly.

Once you run it, the work's quality is already locked in, so there's nothing to gain by hedging: a thorough confession is the whole point.

Usage

• Manually, as a slash command, right after Claude finishes a task:

  /reasoning:confess
  

• Automatically, on phrases like "confess," "be honest about this," "what are you unsure about," "what did you cut corners on," "what's the weakest part," or "audit your own work."

What to expect