About

Imported from borghei/claude-skills (engineering/extended-thinking-architect/SKILL.md). Install upstream with npx skills add borghei/claude-skills --skill extended-thinking-architect. Copyright stays with the author (MIT + Commons Clause).

Extended Thinking Architect

Name: extended-thinking-architect
Author: borghei

Category: Engineering Domain: AI Engineering

Overview

The Extended Thinking Architect skill helps you decide when an LLM task should spend a reasoning/thinking budget, how much (no-thinking / low / medium / high), and when the better move is a cheaper model with a sharper prompt instead. It turns task signals — error cost, ambiguity, step count, latency budget — into a deterministic recommendation with a rough cost multiplier, and allocates effort across the phases of an agent loop so you front-load reasoning where it pays and avoid runaway budgets.

Clarify First

Before recommending an effort level, confirm these inputs. If any is unknown or vague, ASK — do not assume:

Task type & verifiability — what the model is actually doing (extraction, classification, planning, code-debug, math…) and whether the output is checkable (sets --task-type and --verifiable)
Cost of a wrong answer — how expensive a bad output is, plus the latency budget the task must fit (sets --error-cost and --latency-budget)
Shape of the work — how many reasoning/tool steps are expected and how ambiguous the request is (sets --steps and --ambiguity)

Stop rule: ask only the 2-3 that most change the output. If the user says "just draft it," proceed and list your assumptions at the top of the artifact.

Quick Start

# Recommend a reasoning effort level for a single task
python scripts/reasoning_budget_advisor.py --task-type code-debug \
  --error-cost high --steps 4 --ambiguity low --latency-budget interactive

# A cheap, high-volume classification task — expect "cheaper model + better prompt"
python scripts/reasoning_budget_advisor.py --task-type classification \
  --error-cost low --latency-budget realtime --json

# Allocate reasoning effort across the phases of an agent loop
python scripts/reasoning_loop_allocator.py --difficulty high --steps 8 \
  --max-budget-multiplier 30

# Tight-latency loop — see effort capped per phase
python scripts/reasoning_loop_allocator.py --difficulty medium --steps 5 --realtime --json

Tools Overview

Tool	Purpose	Key Flags
`reasoning_budget_advisor.py`	Recommend an effort level (none/low/medium/high) or "prompt-first / cheaper-model" for one task, with rationale + cost multiplier	`--task-type`, `--error-cost`, `--steps`, `--ambiguity`, `--latency-budget`, `--verifiable`, `--json`
`reasoning_loop_allocator.py`	Allocate reasoning effort across agent-loop phases (plan/act/observe/recover/finalize) under a total budget cap	`--difficulty`, `--steps`, `--max-budget-multiplier`, `--realtime`, `--json`

Workflows

Choosing Effort for a New Task

Identify the task type and whether the output is verifiable (ground truth or a checker exists).
Run reasoning_budget_advisor.py with the error cost, step count, ambiguity, and latency budget.
If the result is prompt-first, fix the prompt/spec (clarify, add examples) before spending any reasoning, then re-run.
If the result is cheaper-model, route to a smaller/faster model and invest the savings in a better prompt.
Otherwise adopt the recommended effort, note the cost multiplier, and set a per-call budget cap.

Budgeting Reasoning Across an Agent Loop

Estimate overall task difficulty and the expected number of steps.
Run reasoning_loop_allocator.py to get per-phase effort (front-loaded at plan/recover, thin at act/observe).
Apply the total budget cap as a hard stop so a stuck loop cannot run away.
Instrument per-phase token spend; if observe/act phases consume high reasoning, that is an overthinking signal — clamp them.

Reference Documentation

When to Use Extended Thinking - Decision matrix of task classes where reasoning pays off vs. is wasted, interaction with tool use and agent loops, budget guards, overthinking failure modes, and eval signals.
Reasoning Budget Patterns - Allocation patterns, escalation ladders, caps and circuit breakers, and the cost/quality/latency tradeoff model.

Common Patterns

When Reasoning Pays Off

Multi-step deduction with a verifiable answer (math, constraint solving, debugging from a stack trace)
Planning and decomposition before a long agent run — front-load thinking once, not on every tool call
High error-cost decisions where a wrong answer is expensive to detect or undo

When Reasoning Is Wasted

Extraction, classification, and formatting — deterministic mappings, not deduction; a cheaper model usually wins
Underspecified requests — extra thinking confidently elaborates on the wrong goal; fix the prompt first
Realtime/latency-tight paths where thinking tokens blow the budget more than they improve quality

Guarding the Budget

Set a per-call effort cap and a loop-level total cap (e.g. a multiple of one no-thinking call)
Escalate effort only on failure (retry at higher effort), never start high "to be safe"
Treat reasoning spent on trivial sub-steps as a regression — alert on per-phase token spend

Use it

Copy one of these into your project. Installing also returns the manifest and these snippets.

yaml

targets:
  - https://api.opensmartroute.ai/api/v1/registry/borghei-claude-skills-extended-thinking-architect/manifest   # or paste the manifest below

Manifest

An Open Capability Manifest: the router reads it to know what this does, what it costs and when to pick it.

borghei-claude-skills-extended-thinking-architect.ocm.jsonjson

{
  "ocm": "1",
  "id": "borghei-claude-skills-extended-thinking-architect",
  "kind": "skill",
  "name": "extended-thinking-architect",
  "description": "This skill should be used when the user asks to \"decide reasoning effort\", \"set a thinking budget\", \"when to use extended thinking\", \"tune reasoning vs cost\", or \"should this task use a reasoning model\".",
  "publisher": "borghei",
  "version": "1.0.0",
  "capabilities": {
    "domains": [
      "finance"
    ],
    "tags": [
      "skill-md",
      "extended-thinking",
      "reasoning-effort",
      "llm",
      "cost-optimization",
      "agents",
      "skills-sh"
    ],
    "languages": [
      "en"
    ]
  },
  "quality_prior": 0.6,
  "examples": [
    "This skill should be used when the user asks to \"decide reasoning effort\", \"set a thinking budget\", \"when to use extended thinking\", \"tune reasoning vs cost\", or \"should this task use a reasoning model\"."
  ],
  "primary": false,
  "metadata": {
    "source": {
      "provider": "skills.sh",
      "repository": "https://github.com/borghei/claude-skills",
      "path": "engineering/extended-thinking-architect/SKILL.md",
      "ref": "HEAD",
      "url": "https://github.com/borghei/claude-skills/blob/HEAD/engineering/extended-thinking-architect/SKILL.md",
      "key": "borghei/claude-skills/engineering/extended-thinking-architect/SKILL.md"
    },
    "license": "MIT + Commons Clause"
  },
  "instructions": "# Extended Thinking Architect\n\n> **Category:** Engineering\n> **Domain:** AI Engineering\n\n## Overview\n\nThe **Extended Thinking Architect** skill helps you decide *when* an LLM task should spend a reasoning/thinking budget, *how much* (no-thinking / low / medium / high), and when the better move is a cheaper model with a sharper prompt instead. It turns task signals — error cost, ambiguity, step count, latency budget — into a deterministic recommendation with a rough cost multiplier, and allocates effort across the phases of an agent loop so you front-load reasoning where it pays and avoid runaw",
  "cost": {
    "context_tokens": 1302
  }
}

Fetch it by URL: GET /api/v1/registry/borghei-claude-skills-extended-thinking-architect/manifest?version=1.0.0

Reviews

Star ratings from people who tried it. One review per account; edit yours any time.

No reviews yet. Install it, try it, and be the first to rate it.