/thinking-config Command

Metadata

name: thinking-config
version: 1.0.0
category: orchestration
status: active
priority: P0
derived_from: Claude Operating Preferences v6.0

Description

Configure extended thinking parameters for Claude Opus 4.5. Select thinking tiers, enable interleaved thinking, and estimate costs for tasks.

Usage

# Show current thinking configuration
/thinking-config

# Set thinking tier for session
/thinking-config --tier DEEP

# Enable interleaved thinking
/thinking-config --interleaved

# Estimate cost for a task
/thinking-config --estimate "Debug authentication race condition"

# Generate API configuration
/thinking-config --api-config --tier EXTENDED --interleaved

# Show all available tiers
/thinking-config --tiers

Arguments

Argument	Type	Default	Description
--tier	enum	STANDARD	Thinking tier (NONE, QUICK, STANDARD, DEEP, EXTENDED, MAXIMUM)
--interleaved	flag	false	Enable interleaved thinking between tool calls
--estimate	string	-	Estimate optimal tier for given task description
--api-config	flag	false	Output API configuration JSON
--tiers	flag	false	Show all available thinking tiers
--cost	flag	false	Show cost estimates for each tier

Thinking Tiers

Tier	Budget	Cost	Best For
NONE	0	$0	Simple extraction, formatting
QUICK	1K	$0.005	Basic reasoning, classification
STANDARD	4K	$0.02	Normal tasks, code generation
DEEP	16K	$0.08	Complex debugging, analysis
EXTENDED	32K	$0.16	Research, architecture design
MAXIMUM	64K	$0.32	30+ hour autonomous tasks

Output Examples

Show Current Config

$ /thinking-config

Current Thinking Configuration
------------------------------
Tier:        STANDARD (4096 tokens)
Interleaved: Disabled
Est. Cost:   $0.02 per call

Recommendation: For complex tasks, consider DEEP tier.

Estimate for Task

$ /thinking-config --estimate "Debug authentication race condition"

Task Analysis
-------------
Complexity:     0.72 (high)
Reasoning:      4 steps estimated
Tool Usage:     Multiple tools expected

Recommendation
--------------
Tier:           DEEP (16K tokens)
Interleaved:    Enabled (multi-tool task)
Est. Cost:      $0.08
Accuracy Boost: +15% vs no thinking

API Configuration

$ /thinking-config --api-config --tier DEEP --interleaved

{
  "model": "claude-opus-4-5-20251101",
  "max_tokens": 32000,
  "thinking": {
    "type": "enabled",
    "budget_tokens": 16000
  },
  "betas": [
    "interleaved-thinking-2025-05-14"
  ]
}

System Prompt

When this command is invoked, execute the following:

1. Parse arguments to determine requested action
2. If --tier specified: Update session thinking configuration
3. If --estimate specified: Analyze task and recommend tier
4. If --api-config specified: Generate and output JSON configuration
5. If no args: Display current configuration status

Use the thinking-budget-manager agent for complex estimation tasks.

Implementation

#!/usr/bin/env python3
"""thinking-config command implementation"""

import argparse
import json
from enum import Enum

class ThinkingTier(Enum):
    NONE = 0
    QUICK = 1024
    STANDARD = 4096
    DEEP = 16000
    EXTENDED = 32000
    MAXIMUM = 64000

TIER_COSTS = {
    "NONE": 0,
    "QUICK": 0.005,
    "STANDARD": 0.02,
    "DEEP": 0.08,
    "EXTENDED": 0.16,
    "MAXIMUM": 0.32
}

def get_api_config(tier: str, interleaved: bool) -> dict:
    tier_enum = ThinkingTier[tier.upper()]
    config = {
        "model": "claude-opus-4-5-20251101",
        "max_tokens": min(tier_enum.value * 2, 32000),
    }

    if tier_enum != ThinkingTier.NONE:
        config["thinking"] = {
            "type": "enabled",
            "budget_tokens": tier_enum.value
        }

    if interleaved:
        config["betas"] = ["interleaved-thinking-2025-05-14"]

    return config

def main():
    parser = argparse.ArgumentParser(description="Configure extended thinking")
    parser.add_argument("--tier", choices=[t.name for t in ThinkingTier])
    parser.add_argument("--interleaved", action="store_true")
    parser.add_argument("--estimate", type=str)
    parser.add_argument("--api-config", action="store_true")
    parser.add_argument("--tiers", action="store_true")
    parser.add_argument("--cost", action="store_true")

    args = parser.parse_args()

    if args.tiers or args.cost:
        print("\nThinking Tiers")
        print("-" * 50)
        for tier in ThinkingTier:
            cost = TIER_COSTS[tier.name]
            print(f"{tier.name:10} | {tier.value:6} tokens | ${cost:.3f}")
        return

    if args.api_config:
        tier = args.tier or "STANDARD"
        config = get_api_config(tier, args.interleaved)
        print(json.dumps(config, indent=2))
        return

    # Default: show current config
    tier = args.tier or "STANDARD"
    print(f"\nCurrent Thinking Configuration")
    print("-" * 30)
    print(f"Tier:        {tier} ({ThinkingTier[tier].value} tokens)")
    print(f"Interleaved: {'Enabled' if args.interleaved else 'Disabled'}")
    print(f"Est. Cost:   ${TIER_COSTS[tier]:.3f} per call")

if __name__ == "__main__":
    main()

Related Components

• agents/thinking-budget-manager.md - Agent for budget decisions
• skills/extended-thinking-patterns/ - Core patterns
• scripts/thinking-budget-calculator.py - Batch calculations

---

Action Policy

<default_behavior> This command configures settings without side effects. Provides:

• Current configuration display
• Tier recommendations
• API configuration JSON
• Cost estimates

Affects session thinking behavior when --tier specified. </default_behavior>

After execution, verify: - Configuration displayed correctly - Tier set if requested - API config valid JSON - Cost estimates accurate

Success Output

When thinking config completes:

✅ COMMAND COMPLETE: /thinking-config
Tier: <TIER> (XXXX tokens)
Interleaved: enabled|disabled
Est. Cost: $X.XX per call

Completion Checklist

Before marking complete:

• Arguments parsed
• Configuration updated
• Output displayed
• API config valid (if requested)

Failure Indicators

This command has FAILED if:

• ❌ Invalid tier specified
• ❌ API config malformed
• ❌ Cost calculation error
• ❌ No output displayed

When NOT to Use

Do NOT use when:

• Quick task (thinking adds cost)
• Simple formatting requests
• Using Sonnet/Haiku (no extended thinking)

Anti-Patterns (Avoid)

Anti-Pattern	Problem	Solution
MAXIMUM for simple	Wasted cost	Match tier to complexity
NONE for complex	Poor results	Use at least STANDARD
Skip estimation	Suboptimal tier	Use --estimate first

Principles

This command embodies:

• #9 Based on Facts - Task complexity analysis
• #4 Keep It Simple - Match tier to need

Full Standard: CODITECT-STANDARD-AUTOMATION.md