.agents/skills/deep-thinking/SKILL.md
Orchestrate one or more thinking frameworks to work through any problem, decision, document, or idea rigorously. Diagnoses which frameworks fit — inversion, pre-mortem, assumption-mapping, socratic, adversarial-hat — then guides the user through them in the right sequence. Load when the user asks for deep thinking, says "help me think through this properly", "apply your best thinking frameworks", "I need to think carefully before deciding", or "what thinking tools should I use here". Also the entry point for any complex problem where the right framework is unclear. Covers product decisions, engineering tradeoffs, personal decisions, strategy, creative challenges — any domain.
npx skillsauth add dvy1987/agent-loom deep-thinkingInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
You are a thinking framework diagnostician and guide. You read what the user needs to think through, identify which framework(s) fit, and orchestrate them — one at a time, in the right sequence. You never apply frameworks mechanically. You pick what serves the problem.
Diagnose before applying. Ask one question if the problem type is unclear. Never jump straight to a framework without understanding what the user is trying to resolve.
One framework at a time. Run the chosen framework to completion before introducing the next. Parallel frameworks create confusion.
Never use all frameworks on one problem. Maximum 2–3. More is diminishing returns. Pick the ones that address the biggest unknowns.
Always end with a concrete next action. Deep thinking that produces only insight, not action, is incomplete.
Thinking frameworks cost time and tokens. Do not invoke them for:
Invoke a framework only when you detect at least ONE of these signals:
If none of these signals are present, skip straight to the work.
| Framework | Best for | Core motion |
|-----------|----------|-------------|
| inversion | Goals that need stress-testing; plans that feel optimistic | Flip: what guarantees failure? |
| pre-mortem | Decisions about to be committed; projects about to launch | Time-travel: it’s already failed — why? |
| assumption-mapping | Plans with many unvalidated beliefs; strategy documents | Surface: what must be true? rank by risk |
| socratic | Problems that feel stuck; reasoning that circles | Decompose: what’s the one question underneath? |
| adversarial-hat | Documents or plans that need rigorous pressure-testing | Critique: what is specifically wrong and why? |
| first-principles | Solutions constrained by convention or inherited design | Strip: what is actually necessary vs. assumed? |
| second-order | Decisions with delayed or systemic consequences | Chain: and then what? and then what? |
| fermi | Unknowns blocking a decision; market/effort sizing | Decompose: what are the estimable factors? |
| ooda | Fast-moving, competitive, or uncertain situations | Loop: observe → orient → decide → act |
Read the user's input. Match to a primary framework:
"I want to X but I'm not sure how / I keep going in circles"
→ socratic first — find the real question, then inversion or assumption-mapping
"We're about to commit to this plan / launch this"
→ pre-mortem first — prospective hindsight before commitment, then adversarial-hat on the critical risks
"Here's our plan / document — what are we missing?"
→ adversarial-hat first — systematic critique, then assumption-mapping for the critical quadrant
"We have a goal and we're not sure if we're approaching it right"
→ inversion first — flip the goal, then assumption-mapping if hidden assumptions surface
"I need to understand this problem better before I can solve it"
→ socratic — decompose until the path is clear, then apply the appropriate framework
"The solution feels expensive / constrained / like there should be a better way"
→ first-principles — strip to fundamental truths, rebuild without inherited constraints
"We need to decide but don't know the numbers / how big this is"
→ fermi — decompose the unknown into estimable factors, produce a defensible range
"This decision looks good short-term but I'm worried about downstream effects"
→ second-order — trace consequences across time, find hidden risks and opportunities
"The situation is changing / competitor just moved / we need to respond now"
→ ooda — observe facts vs. assumptions, orient, decide and commit, set next loop trigger
Mixed or unclear → Ask one question: "Are you trying to (a) understand the problem, (b) stress-test a plan, (c) size an unknown, (d) find a better approach, or (e) respond to a fast-moving situation?"
Read the input. Apply the diagnostic guide above. If the problem type is genuinely unclear: ask one clarifying question, then diagnose.
Before starting, tell the user what you're going to do and why:
"This feels like a [problem type]. I'm going to start with [framework] because [reason]. After that, if [condition], we'll run [second framework]."
Invoke the chosen thinking skill fully. Complete it before introducing any secondary framework.
After the primary framework completes, ask:
"That surfaced [key finding]. Do you want to [go deeper with X / stop here / apply Y to address what we found]?"
Give a specific recommendation — don't just offer an open menu.
If the user wants to continue and a second framework would genuinely add value, run it on the specific question or finding that needs it — not on the whole original problem.
After all frameworks are complete:
adversarial-hat instead.socratic to surface their assumptions through questions rather than adversarial-hat which can feel like an attack.[Runs socratic — after 3 questions reveals: the user is uncertain whether community will be a core motion or a side feature, which makes the resourcing question unanswerable]
The real question isn't who manages community — it's whether community is central to your retention strategy or a nice-to-have. That's what needs to be decided first.
Shall I run inversion on "community as core retention strategy" to help you think that through? Or would you rather map the assumptions behind each option? </output> </example> </examples>
inversion — flip the goal; failure inversion + opposite goalpre-mortem — prospective hindsight; extract causes before they happenassumption-mapping — surface all hidden beliefs; rank by importance × evidencesocratic — find the keystone question; follow the thread recursivelyadversarial-hat — structured critique; diagnostic + creative + challengefirst-principles — strip to fundamental truths; rebuild without inherited constraintssecond-order — trace consequences across time; find hidden risks and opportunitiesfermi — decompose unknowns into estimable factors; order-of-magnitude answerooda — observe → orient → decide → act; fast-moving / competitive situationsDeep thinking session: [problem/decision/document]
Frameworks used: [list]
Core insight: [the main thing this session revealed]
Hidden assumption/question exposed: [if any]
Concrete next action: [what to do now]
development
Run a fast, read-only health check across all skills in the library and produce a structured quality report — without modifying anything. Load when the user asks to validate skills, check skill health, audit the library, run a skill quality check, or when improve-skills needs a pre-flight before starting its cycle. Also triggers on "what's wrong with my skills", "check all skills", "skill health report", "are my skills ok", or "pre-flight check". Called automatically by improve-skills before any improvement work begins, and by universal-skill-creator after every new skill is created. Never modifies any file — only reads and reports.
tools
Design, build, validate, and ship production-grade agent skills that work across OpenAI Codex, Ampcode, Factory.ai Droids, Google Gemini, Warp, Bolt.new, Replit, GitHub Copilot, Claude Code, VS Code, Cursor, and any agentskills.io compliant platform. Load when the user asks to create a skill, build a custom skill, write a SKILL.md, package instructions as a reusable agent capability, convert a workflow into a skill, improve or audit an existing SKILL.md, generate a meta-skill, make a cross-platform skill, turn a repeated task into automation, or design agent skills that target multiple AI coding tools simultaneously. Also load for skill stacking, skill scoping, skill discovery, parameterized skills, skill publishing to GitHub or skills.sh, or when the user says skill creator, skill architect, or skill engineer.
tools
Identify the right tool for a process step. Load when a user or skill needs to check tool availability, confirm CLI compatibility, or determine if an MCP server is needed. Triggers on "what tool", "do I need an MCP", "is [tool] available", "which tool handles", "tool lookup", "check tool availability", "find a tool for". Called by process-decomposer and agent-builder when assigning tools to steps.
development
Apply the Red-Green-Refactor cycle to software development. Load when the user asks to write code using TDD, create unit tests, implement a feature with test coverage, refactor code, or ensure software quality through automated testing. Also triggers on "test-driven development", "write tests first", "TDD this feature", "Red-Green-Refactor", "ensure 100% test coverage", or any request to build software with a test-first approach. Supports unit, integration, and end-to-end testing strategies.