deep-thinking_skill

Overview

This skill is a comprehensive deep-reasoning framework that guides systematic, thorough thinking for complex tasks. It activates automatically for multi-step problems, ambiguous requirements, architectural decisions, debugging sessions, and any situation that benefits from careful analysis. The skill helps produce grounded, evidence-backed recommendations and maps trade-offs clearly. It is designed to scale depth of analysis to the problem's stakes and available information.

How this skill works

When applied, the skill reframes the problem, distinguishes knowns from unknowns, and decomposes the task into focused components. It generates multiple hypotheses or solution paths, evaluates trade-offs, and iterates through verification and error-correction steps. The framework emphasizes natural discovery flow — following leads, challenging assumptions, and tying digressions back to the core goal. Final output synthesizes findings into actionable recommendations, including edge cases and likely follow-ups.

When to use it

• Designing system or architecture with multiple valid approaches and trade-offs
• Debugging complex issues that span modules, systems, or unclear failure modes
• Handling ambiguous requirements where clarifying questions are needed
• Making decisions with high stakes (data integrity, security, production impact)
• Tasks that explicitly ask to think carefully, deeply, or explore alternatives

Best practices

• Start by restating the problem and listing what is known vs unknown
• Keep at least two to three working hypotheses open before committing
• Scale analysis depth to complexity and stakes—avoid over-engineering trivial tasks
• Actively seek counterexamples and verify conclusions against evidence
• Document trade-offs, edge cases, and recommended follow-up actions

Example use cases

• Choosing between database sharding strategies for scaling a production service
• Investigating intermittent failures that reproduce under unclear conditions
• Designing a migration plan with rollback strategy and risk assessment
• Evaluating trade-offs between latency, consistency, and cost for a distributed system
• Turning vague product requirements into a prioritized, testable implementation plan