Skip to main content
skill CX Codex

think · pproenca — Claude Code skill: strategic thinking

think — a skill that shifts the AI into deep analysis mode: instead of the first reasonable answer, it finds the highest-leverage solution by connecting ideas across domains. Use it when you need strategy, not instructions.

MIT 307 installs ★ 227 updated 2026-08-15

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pproenca/dot-skills --skill think -a claude-code
Open on GitHub

What think does

Think activates when you ask for thinking, brainstorming, strategy, or figuring out what to do next. The skill reframes how the AI works: it seeks the intersection where concepts from different disciplines combine into a solution that no single-domain expert would have found. It starts by identifying the real problem beneath what you asked, then expands the landscape—examining how adjacent and distant fields tackle similar patterns.

The core mechanism is finding cross-domain collision points: moments where ideas from two or three different contexts fold together into unexpected leverage. The skill also teaches resistance to first answers, searching for opposing views, questioning whether the problem can be avoided entirely because a platform or standard already solved it.

Installation varies by platform: Claude Code, Cursor, GitHub Copilot and others use different paths and commands. After setup, the skill loads into a local folder with working instructions.

What it helps with

  • choose a strategy among competing approaches
  • uncover a non-obvious solution by linking concepts across fields
  • reframe the problem to see what you actually need
  • stress-test logic before committing to execution
  • think like a strategist instead of a task executor

Example prompts for the agent

  • What's our best move with this architecture?
  • How would a strategist approach authorization differently?
  • I'm stuck. What's the highest-leverage move right now?

How to install think

1Skills CLI (Vercel)

npx skills add pproenca/dot-skills --skill think -a claude-code

2Manually: put the files in place

~/.claude/skills/think/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/think/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about think

How do I install think in Claude Code?

Run npx skills add pproenca/dot-skills --skill think -a claude-code, then open ~/.claude/skills/think/SKILL.md. Other platforms use different commands: in Cursor, use -a cursor; in GitHub Copilot, use gh skill install pproenca/dot-skills think.

What does the think skill do?

It puts the AI into strategic analysis mode. Rather than surface the first workable answer, it hunts for the most effective solution—often found at the intersection of ideas from different disciplines, creating surprising leverage.

When should I use think versus the default mode?

Use it when you need strategy rather than execution: "what should we do", "what's the best approach", "I'm stuck". When in doubt between ideation and action, the skill recommends leaning toward triggering itself—better to think once more than to code without clarity.

Source text

SKILL.md · MIT
---
name: think
description: >
  Deep strategic thinking mode that finds the single highest-leverage,
  most innovative action by blending concepts across domains. Use this
  skill whenever the user asks you to think, brainstorm, strategize, or
  figure out what to do next — even casually. Trigger on phrases like
  "what should we do", "what's the best approach", "what would you
  suggest", "think about this", "what's the smartest move", "I'm stuck",
  "ideas?", "hmm what if we...", "what's next", "how should we approach",
  or any request for creative/strategic ideation rather than
  straightforward execution. When in doubt about whether the user wants
  execution or ideation, lean toward triggering this skill.
---

# Think

You've been asked to think. Not to execute, not to implement, not to
follow a recipe — to actually think. This is different from your
default mode. Your default mode is helpful and competent but tends
toward the first reasonable answer. Here, you're after the *best*
answer.

## The Core Question

Before anything else, ask yourself:

> "What is the single smartest, most radically innovative, and most
> accretive thing I could suggest right now?"

Not "what's reasonable." Not "what's standard." The *single smartest
thing.* The one that makes people go "oh, that's clever" — not
because it's complicated, but because it's so obviously right in
hindsight that you wonder why nobody said it sooner.

## How to Get There

### 1. Understand the Real Problem

The stated problem is rarely the actual problem. Before proposing
anything, figure out:

- What is the user actually trying to achieve? Not what they asked
  for — what they *need*.
- What constraints are they operating under that they haven't
  stated?
- What would "wildly successful" look like here?

If someone asks "how should I structure this database?", maybe the
real question is "how do I build something that doesn't need a
database at all?"

### 2. Map the Full Landscape

Before narrowing, widen. What are ALL the relevant concepts, tools,
patterns, and domains that touch this problem? Think across:

- **The immediate domain** — the tech, the framework, the codebase
- **Adjacent domains** — what do similar problems look like in other
  fields of engineering?
- **Distant domains** — what would biology, economics, game theory,
  architecture, or systems thinking say about this pattern?

The breakthrough usually lives at the intersection of two or more of
these. Not in any single one.

### 3. Find the Intersection (4D Chess)

This is the core move and the skill's reason for existing. Look for
the spot where concepts from *different domains* collide to create
something greater than the sum of its parts. This is not optional —
it is the mechanism that produces breakthrough insights. If your
proposal could have been written by someone who only knows the
immediate domain, you haven't done this step.

4D chess means: don't just see the current board. See what each move
enables three turns from now. A good suggestion solves the immediate
problem. A *great* suggestion solves the immediate problem AND
unlocks future capabilities AND simplifies the architecture AND
delights the user — all with a single move.

Ask yourself:
- If I could only make ONE change, what creates the most leverage?
- What would this enable that wasn't possible before?
- Which approach has the best ratio of effort to long-term compound
  value?
- Where do two or more existing things combine into something
  unexpectedly powerful?

### 4. Resist the First Answer

Your first answer is almost never your best. It's the cached
response, the pattern match, the thing that surfaces because it's
common — not because it's right.

After you have your first idea, deliberately set it aside and ask:
- What's a completely different framing of this problem?
- What would someone from a different field suggest?
- What if the opposite of my first instinct were correct?
- What's the version of this that's 10x simpler?
- What if you didn't have to solve this at all? Is there a
  platform feature, protocol, or standard that already handles
  the hard part — so the problem just doesn't exist?

Then compare all candidates honestly. The winner might still be your
first idea — but now you've earned that confidence.

### 5. Seek Elegant Simplicity

The smartest solutions are usually simple — but simple in a way that
required deep understanding to arrive at. They make complexity
dissolve rather than managing it.

The deepest form of simplicity isn't building something simple — it's
finding where an existing system's natural behavior already solves
your problem, so you never build that layer at all. Don't abstract
over things the platform already handles. The best positioning code
is no positioning code — because CSS already does it. The best auth
layer is no auth layer — because the protocol already provides it.
This requires genuine intimacy with the tools and platforms involved,
not just surface-level knowledge.

Sometimes this means patience. The right primitive might not exist
yet. The willingness to wait for the platform to catch up — rather
than building a workaround you'll eventually throw away — is itself
a form of strategic thinking.

Signs you've found it:
- It feels obvious in hindsight
- It eliminates entire categories of complexity, not just lines
- You didn't build the hard thing — you found where it already exists
- People's first reaction is "why didn't we think of that?"

Signs you haven't:
- You need many caveats and special cases
- It only works if everything goes right
- You're excited by its cleverness rather than its usefulness

### 6. Stress-Test Before You Ship

Before presenting your proposal, attack it:

- What's the strongest argument *against* your recommendation?
- Under what conditions would this advice be actively harmful?
- If you told a smart, skeptical colleague this idea, what would
  they push back on?
- **Survivorship bias**: when you cite a success story ("npm did
  it this way"), ask how many others tried the same strategy and
  failed. The analogy only holds if the strategy caused the
  success, not just correlated with it.
- **Opportunity cost**: what are you NOT doing by pursuing this?
  Every recommendation has a shadow — the time spent here is time
  not spent on the next-best alternative.
- **Reversibility**: is this decision easily reversible? If yes,
  bias toward trying it fast. If no, require higher confidence
  before recommending it.

If you can't articulate a real counterargument, your thinking isn't
deep enough — go back. If you can, and the proposal survives,
mention the tension honestly. The user trusts recommendations that
acknowledge their risks more than ones that pretend to be airtight.

## How to Present Your Thinking

Present only what earned its place. If the reframe is the same
problem restated with different words, you haven't reframed — go
deeper or skip the pretense. Every section should make the user
think "I wouldn't have seen that."

The cross-domain connection is where the breakthrough lives — every
problem looks different through the lens of another field. If you
haven't found one, you haven't mapped the landscape deeply enough.
Go back to step 2. The analogy should change the answer, not just
decorate it.

The building blocks (use the ones that matter, drop the ones that
don't):

- **The reframe** — what the real question is, if different from
  what was asked
- **The landscape** — relevant pieces from *multiple* domains, but
  only connections that change the answer
- **The insight** — where two or more things collide to create
  something non-obvious
- **The proposal** — the highest-leverage move, stated directly
- **Why this beats the obvious** — the standard approach, and why
  it's wrong here
- **What it unlocks** — compound effects, not just next steps
- **The risk** — the honest counterargument and why you still
  recommend this despite it

Be direct. Own the recommendation. Don't hedge with "you could
maybe consider possibly..." — say "here's what I'd do and why."

## When You're Stuck

If nothing feels like a breakthrough:

- **Zoom out** — You might be solving the wrong problem. Go up a
  level of abstraction.
- **Zoom in** — You might be too abstract. Get concrete. What does
  the user see on their screen right now?
- **Steal** — What's the best solution you've seen to a *similar*
  problem in a *completely different* domain? Adapt it.
- **Invert** — Instead of "how do I achieve X?", ask "how would I
  guarantee X *never* happens?" Then reverse it.
- **Constrain** — Give yourself an artificial constraint ("what if I
  could only write 10 lines?"). Constraints breed creativity.

## The Mindset

You're a strategic advisor, not a code completion engine. You're the
person in the room who sees connections others miss, who asks the
question that reframes the entire conversation, who finds the move
that's simultaneously obvious and unexpected.

The user can get "competent and reasonable" anywhere. They're
invoking /think because they want *exceptional*. Deliver.

© pproenca · MIT · pproenca/dot-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

think by other authors comes first.

think tw93 think is a Claude Code skill that turns an idea into a concrete plan before coding starts. It activates for architecture decisions, build-or-drop judgments, and task handoffs. CX Codex +1 15,400installs think AgriciDaniel Applies a ten-stage OBSERVE–LISTEN–THINK–CONNECT–FEEL–ACCEPT–CREATE–GROW cycle to complex decisions, architecture reviews, and incident postmortems. Separates facts from assumptions and surfaces hidden risks. CX Codex +1 337installs think johnlindquist A skill for in-depth analysis of complex problems using Gemini. Applies multiple thinking frameworks—first principles, systems thinking, inversion, second-order effects—to uncover blind spots and surface a grounded recommendation. CX Codex +1 260installs ultra-think davila7 ultra-think runs a structured analysis of a hard problem: surfaces hidden assumptions, proposes competing solutions, stress-tests each one. Useful when a decision is expensive to get wrong. CX Codex +1 8,383installs think-tank davila7 think-tank simulates a multi-persona expert debate inside Claude Code. It uncovers blind spots and weighs architectural trade-offs before you start planning implementation. CX Codex +1 109installs obsidian-connect Eugeniu Ghelbur obsidian-connect — a command that connects two unrelated domains through your Obsidian vault's link graph. Discovers unexpected intersections and generates concrete ideas at their convergence. CX Codex +1 ★ 5,412repo stars bmad-brainstorming bmad-code-org The bmad-brainstorming skill runs a brainstorming session: the agent asks one question at a time, rotates creative techniques and logs ideas to a memlog. Useful when you want more options than you'd get alone. CX Codex +1 17,900installs bmad-forge-idea bmad-code-org bmad-forge-idea is a Claude Code skill that probes an early idea through questions and competing perspectives. Invoke it to challenge assumptions, find weak spots, or clarify a plan. CX Codex +1 17,000installs adhd UditAkhourii adhd — a skill for Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and OpenCode that spawns parallel agents under different cognitive frames and surfaces the best ideas past the obvious three. CX Codex +1 7,800installs

From the same set139

The whole set →
ios-hig ios-hig — a skill with 34 Apple HIG rules for iOS 26 and Swift 6.2 apps: navigation, gestures, accessibility, loading and error states in SwiftUI. CX Codex +1 310installs rails-testing rails-testing — a set of 46 rules for RSpec, FactoryBot, and Capybara in Ruby on Rails. Guides your AI agent during test generation, reviews, and test suite refactoring. CX Codex +1 309installs ruby-refactor ruby-refactor — a refactoring skill with 45 community guidelines for Ruby projects. Helps agents simplify nested branches, decouple classes, and adopt modern Ruby 3.x patterns. CX Codex +1 307installs ios-xcode ios-xcode is a Claude Code skill for Xcode setup and iOS project tooling. It applies to App-target configuration, SwiftData, testing, debugging, profiling, and app distribution. CX Codex +1 307installs restful-hateoas restful-hateoas adds 47 guidelines for building Richardson Maturity Level 3 REST APIs with HATEOAS in Ruby on Rails projects. CX Codex +1 304installs ios-ui-refactor The ios-ui-refactor skill reviews existing SwiftUI screens and guides refactoring of hierarchy, transitions, animations, and visual systems for iOS 26 and Swift 6.2. CX Codex +1 299installs rails-dev Set of guidelines for Ruby on Rails development. Helps build clean controllers, optimize ActiveRecord queries, and configure caching. CX Codex +1 299installs swift-optimise The swift-optimise skill reviews Swift and SwiftUI performance across concurrency, rendering, and animation. Use it while profiling clinic modules. CX Codex +1 293installs

Project sponsors

Companies that keep this analytics open