Thinking Control
Scannednpx machina-cli add skill silvesterdivas/context-engineer/thinking-control --openclawThinking Depth Control
Calibrate reasoning effort to the task at hand. Deep thinking is powerful but expensive — both in tokens and latency.
Thinking Levels
Minimal Thinking
When: Routine, mechanical tasks with clear instructions.
- Running a command the user specified
- Making a simple edit the user described exactly
- Reading a file the user pointed to
- Formatting or reorganizing existing content
Approach: Act immediately. Avoid deliberating on obvious actions.
Light Thinking
When: Standard development tasks with clear patterns.
- Writing a function with clear inputs/outputs
- Fixing a straightforward bug
- Adding a test for existing behavior
- Implementing a well-defined feature
Approach: Brief consideration of approach, then execute. One pass is usually sufficient.
Moderate Thinking
When: Tasks requiring analysis or multi-step planning.
- Refactoring code for better structure
- Debugging an issue with multiple possible causes
- Implementing a feature that touches several files
- Writing code that must handle edge cases
Approach: Consider 2-3 approaches before choosing. Read relevant code first. Plan execution steps.
Deep Thinking
When: Complex tasks requiring careful reasoning.
- Architecture decisions with long-term implications
- Security-sensitive code (auth, crypto, input validation)
- Performance-critical algorithms
- Resolving conflicting requirements
- Understanding unfamiliar or complex codebases
Approach: Thoroughly explore the problem space. Consider trade-offs. Read all relevant code. Plan in detail before writing. Review the output.
Anti-Patterns
Over-Thinking
- Writing a paragraph of analysis before making a one-line fix
- Considering edge cases that can't happen given the constraints
- Planning three approaches for a task with one obvious solution
- Adding extensive error handling to internal utilities
Under-Thinking
- Jumping into a multi-file refactor without reading the existing code
- Making architecture decisions without understanding the current system
- Writing security-sensitive code without considering attack vectors
- Implementing a feature without checking if it already exists
Context Budget Impact
Thinking consumes context window space:
- Minimal: ~50 tokens of reasoning overhead
- Light: ~200 tokens
- Moderate: ~500-1000 tokens
- Deep: ~2000-5000 tokens
In YELLOW/ORANGE budget zones, bias toward lighter thinking. In RED zone, use minimal thinking — focus on saving state and wrapping up.
Source
git clone https://github.com/silvesterdivas/context-engineer/blob/main/skills/thinking-control/SKILL.mdView on GitHub Overview
Thinking Control calibrates reasoning effort to the task at hand, balancing latency and accuracy. It defines four levels (Minimal, Light, Moderate, Deep) and provides guardrails for when to think deeply vs act quickly, including guidance on talking about thinking depth and avoiding over- or under-thinking.
How This Skill Works
When a task is presented, select a thinking level based on complexity: Minimal for routine actions, Light for standard development tasks, Moderate for multi-step planning, and Deep for architecturally significant work. The skill prompts a structured approach: read relevant code first, consider 2-3 approaches, plan execution steps, and review results before delivering.
When to Use It
- Calibrating reasoning effort for a task to match requirements
- When asked directly about 'thinking depth', 'over-thinking', or 'under-thinking'
- When balancing latency against accuracy in a task
- During debugging with multiple potential root causes
- While designing architecture or security-sensitive features
Quick Start
- Step 1: Assess task complexity and potential impact
- Step 2: Pick a thinking level (Minimal–Deep) based on task
- Step 3: Execute with planned steps and re-evaluate if needed
Best Practices
- Align the thinking level with task complexity and impact
- Read the relevant code or docs before deciding
- Consider 2-3 potential approaches before choosing
- Be mindful of context budget: favor lighter thinking in Yellow/Orange zones
- Avoid anti-patterns like over-thinking or under-thinking
Example Use Cases
- Choosing Minimal Thinking for a file read or simple edit
- Using Light Thinking for implementing a well-defined function
- Employing Moderate Thinking for multi-file refactors or edge cases
- Applying Deep Thinking to architecture decisions or security-sensitive work
- Responding to questions about thinking depth with calibrated, explainable reasoning
