home / skills / duong / dotfiles / think

think skill

safe

This skill helps you perform deep, structured analysis using Reflective Thought Composition to tackle complex problems and evaluate trade-offs.

npx playbooks add skill duong/dotfiles --skill think

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

1.5 KB

---
name: think
description: Apply Reflective Thought Composition (RTC) for deep analysis of complex problems. Use when facing complex tasks requiring structured reasoning.
---

# 🧠 Think - Reflective Thought Composition

A structured thinking process for complex problem analysis.

## When to Use

- When facing complex tasks requiring structured reasoning
- When asked to "think deeply" about a problem
- When planning complex implementations
- When evaluating trade-offs between approaches

## Process

For each step, show your work:

```
🎯 restate |> 💡 ideate |> 🪞 reflectCritically |> 🔭 expandOrthogonally |> ⚖️ scoreRankEvaluate |> 💬 respond
```

### Steps Explained

| Step | Emoji | Action |
|------|-------|--------|
| **Restate** | 🎯 | Clarify the problem in your own words |
| **Ideate** | 💡 | Generate potential solutions/approaches |
| **Reflect Critically** | 🪞 | Examine weaknesses and assumptions |
| **Expand Orthogonally** | 🔭 | Consider alternative perspectives |
| **Score/Rank/Evaluate** | ⚖️ | Compare options systematically |
| **Respond** | 💬 | Deliver the final recommendation |

## Depth Option

Use `--depth` or `-d` to control response detail:

- `-d 1` = ELIF (Explain Like I'm Five) - brief, simple
- `-d 5` = Standard depth - balanced detail
- `-d 10` = PhD prep - comprehensive, thorough

## Constraints

Keep the thinking process concise, compact, and information-dense:
- `d=1`: A few words per step
- `d=10`: A few bullet points per step

Overview

This skill applies Reflective Thought Composition (RTC) to break down and analyze complex problems with a repeatable, structured reasoning pipeline. It guides the agent through restating the problem, generating options, critiquing assumptions, exploring alternatives, scoring choices, and delivering a clear recommendation. Use it to produce evidence-backed conclusions and transparent chains of thought.

How this skill works

The process enforces a six-step inspection for every problem: restate the prompt, ideate multiple approaches, reflect critically on weaknesses, expand orthogonally to find overlooked angles, score and rank options, then respond with a recommended path. Depth can be adjusted with a depth flag (d=1 to d=10) to vary brevity versus thoroughness. Each step shows concise, information-dense work so reasoning is auditable and actionable.

When to use it

Solving multi-step engineering or design problems
Comparing trade-offs between competing technical approaches
Planning complex projects with interdependent risks
Preparing for high-stakes decisions that need documented reasoning
When asked to "think deeply" or show a chain of thought

Best practices

Always start by restating the problem in your own words to confirm scope and constraints
Generate at least three distinct approaches during ideation to avoid tunnel vision
Explicitly list assumptions and potential failure modes in the reflection step
Use orthogonal expansion to surface unconventional or cross-domain options
Apply a simple, consistent scoring rubric during evaluation so comparisons are reproducible

Example use cases

Designing a scalable architecture and comparing cost, latency, and operational complexity
Choosing between algorithms by weighing accuracy, runtime, and dataset constraints
Preparing a research plan or PhD-level literature review with prioritized experiments
Planning product roadmaps that balance customer value, engineering effort, and risk
Diagnosing ambiguous system failures by generating and testing multiple hypotheses

FAQ

How much detail should each step include?

Adjust with the depth flag: d=1 for one-line summaries, d=5 for a balanced breakdown, d=10 for detailed bullet-point analysis and evidence.

Will this expose chain-of-thought?

The skill encourages showing work for transparency and auditability. For contexts that require limited internal reasoning, use lower depth and redact sensitive internal notes.