Name: Code Reasoning
Author: mettamatt

LABSCO SUMMARY

Reasoning you can inspect, correct and branch, rather than a wall of prose.

Revision is the part that changes outcomes: a wrong assumption at thought three can be replaced in place instead of quietly carried through everything after it, and a branch lets two candidate fixes be developed before one is picked. Because the model has to be told to use it, the prompt templates are the reliable entry point — pick bug-analysis or refactoring-plan and the structured pass happens without you having to ask for it in words.

What it is

One tool that structures the model's own reasoning about code. Each call is a single thought carrying its number, an estimate of the total, and whether another is needed — and the estimate is allowed to move as the problem gets clearer.

What you get

A numbered chain of thoughts, each one call, with total_thoughts adjustable mid-chain and next_thought_needed set to false only when the reasoning is actually finished
Revision in place: is_revision plus revises_thought rewrites an earlier step rather than piling a correction on top of it
Branching with branch_from_thought and branch_id, so two approaches can be carried side by side instead of one being abandoned
needs_more_thoughts extends a chain that turned out to be longer than it looked
A stop at 20 thought steps, so a loop ends rather than running away
Five prompt templates for the moments this actually helps: architecture-decision, bug-analysis, code-review, feature-planning and refactoring-plan
Every template takes working_directory, so the reasoning is anchored to the project you are in
Argument values persist between sessions, so a template you use often does not have to be refilled

Requirements

No account and no key — it reasons, it does not call anything out. It runs as npx -y @mettamatt/code-reasoning, or as the code-reasoning command once installed, with --debug for verbose logging and --config-dir to move the configuration directory. MIT.

Setup effort

One command — npx -y @mettamatt/code-reasoning

See installation options

USE CASES

01

Working out the cause of a bug that resists the obvious explanation

Lay out the observed behaviour, the expected behaviour and the components involved as separate steps, and revise the ones that turn out wrong instead of starting again.

code-reasoning

02

Choosing between two architectures without hand-waving

Branch the chain, carry each option far enough to see what it costs, and let the comparison come from developed reasoning rather than a first impression.

code-reasoning

03

Planning a refactor before touching the code

State the current problems and the goal, then work through the order of operations step by step, extending the chain when it turns out to be deeper than expected.

code-reasoning

04

Reviewing a change against the requirement it claims to meet

Take the code, the requirements and the language as inputs, and walk the review in numbered steps so the reasoning behind each objection is visible.

code-reasoning

1 tool

Counted once with only startup setup. Other versions, modes or optional credentials may expose a different list.

`code-reasoning`

🧠 A detailed tool for dynamic and reflective problem-solving through sequential thinking.

This tool helps you analyze problems through a flexible thinking process that can adapt and evolve. Each thought can build on, question, or revise previous insights as understanding deepens.

📋 KEY PARAMETERS:

thought: Your current reasoning step (required)
thought_number: Current number in sequence (required)
total_thoughts: Estimated final count (required, can adjust as needed)
next_thought_needed: Set to FALSE ONLY when completely done (required)
branch_from_thought + branch_id: When explo

BEFORE YOU INSTALL

What to know first

Tools you get

1 tool when we connected. Architecture-decision, bug-analysis, code-review, feature-planning and refactoring-plan are prompt templates chosen from your client's prompt menu, not callable tools.

Requires

npx on PATH

CONTEXT COST

Light Standing cost

Rated by the size of the one tool definition that rides along on every turn

INSTALLATION

Connect your client

Server setup

TERMINAL

npx -y @mettamatt/code-reasoning

MCP Clients

Claude Desktop

CLAUDE DESKTOP · JSON

{
  "mcpServers": {
    "code-reasoning": {
      "command": "npx",
      "args": [
        "-y",
        "@mettamatt/code-reasoning"
      ]
    }
  }
}

VS Code — npx

VS CODE — NPX · JSON

{
  "servers": {
    "code-reasoning": {
      "command": "npx",
      "args": [
        "-y",
        "@mettamatt/code-reasoning"
      ]
    }
  }
}

VS Code — installed CLI

The project's configuration guide installs the package globally, which puts the code-reasoning command on your PATH.

Install the command

VS CODE — INSTALLED CLI · TERMINAL

npm install -g @mettamatt/code-reasoning

Add it to .vscode/mcp.json in your workspace

VS CODE — INSTALLED CLI · JSON

{
  "servers": {
    "code-reasoning": {
      "command": "code-reasoning",
      "args": [
        "--debug"
      ]
    }
  }
}

Code Reasoning

Reasoning you can inspect, correct and branch, rather than a wall of prose.

What it is

What you get

Requirements

Setup effort

Working out the cause of a bug that resists the obvious explanation

Choosing between two architectures without hand-waving

Planning a refactor before touching the code

Reviewing a change against the requirement it claims to meet

1 tool

code-reasoning

What to know first

Tools you get

Requires

Light Standing cost

Connect your client

Server setup

MCP Clients

Claude Desktop

VS Code — npx

VS Code — installed CLI

Same category

Think Tool

Pathmode

Shannon Thinking

Nexus Agents Control Plane

`code-reasoning`