Skip to main content
skill CX Codex

think · agricidaniel — Claude Code skill: structured decision analysis

A skill that 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.

MIT 337 installs ★ 16,676 updated 2026-10-22

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

What think does

Think guides you through ten stages of deliberate attention, scaling depth to uncertainty and stakes. At each step you ground observations in evidence, name biases that might distort judgment, recover unstated constraints, map alternatives and tradeoffs, trace system boundaries, and consider user experience. You build a frame that distinguishes what was directly verified, what is inferred from evidence, what remains unknown, and what is preference.

The skill is read-only: it examines state and proposes, but does not mutate files, commit, or publish. When the CREATE stage yields an action, you authorize and compose it with the appropriate mutation skill afterward.

Use think for architecture decisions, postmortems, migration planning, challenging your own assumptions, and any choice where error has high cost or low reversibility.

What it helps with

  • evaluate trade-offs between event-driven and request-response architecture
  • conduct a postmortem and identify root causes
  • assess risks before migrating to a new tech stack
  • stress-test an assumption by constructing the strongest counterargument
  • plan a refactor while accounting for upstream and downstream effects

Example prompts for the agent

  • Think through the architecture decision between event-driven and request-response for this service
  • Think: why did we choose PostgreSQL over MongoDB for this microservice
  • Analyze why latency spikes in production after we switched to the new cache

How to install think

1Skills CLI (Vercel)

npx skills add AgriciDaniel/claude-obsidian --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 AgriciDaniel/claude-obsidian --skill think -a claude-code, then open ~/.claude/skills/think/SKILL.md.

What does think do?

It runs a ten-stage cycle—OBSERVE, LISTEN, THINK, CONNECT, FEEL, ACCEPT, CREATE, GROW—over a decision or problem. It separates observed facts from inferred conclusions and unknowns, surfaces hidden biases, maps system effects, and delivers a grounded recommendation with risks stated plainly.

Can think edit files or make commits?

No. Think is read-only: it inspects state and produces reasoning. If its recommendation calls for a change, you run a mutating skill afterward with explicit authorization.

Source text

SKILL.md · MIT
---
name: think
description: Apply the Fable-derived 10-stage OBSERVE, OBSERVE, LISTEN, THINK, CONNECT, CONNECT, FEEL, ACCEPT, CREATE, GROW loop to consequential or ambiguous reasoning and decisions. Use for think this through, deep think, architecture review, postmortem, tradeoff analysis, or challenges to assumptions. This is a reasoning review, not a deterministic vault health check or repair workflow.
---

# Think

Use the ten stages as a loop of attention, not a ceremonial transcript. Scale
the depth to novelty, stakes, uncertainty, and irreversibility. Keep the final
reasoning summary concise and evidence-bearing.

This skill is read-only. It may inspect available evidence, but it does not
edit files, execute a vault mutation, commit Git, or publish anything. If the
CREATE stage recommends a change, compose with the appropriate mutation skill
after the user authorizes that operation.

## Establish an evidence frame

Before the loop, separate:

- **Observed:** directly supported by an input, source, test, or measurement.
- **Inferred:** a conclusion drawn from observations; state the bridge.
- **Unknown:** missing evidence that could change the decision.
- **Preference:** a user or designer choice, not a factual claim.

Attach citations or concrete locators when sources exist. Never fabricate a
quotation, locator, test result, consensus, or confidence level.

## The ten stages

### 1. OBSERVE: external

Read the actual inputs, current state, constraints, failures, and prior work.
Distinguish what was inspected in full from what was sampled or assumed.

### 2. OBSERVE: internal

Name the biases most likely to distort this decision: anchoring, ownership,
novelty, familiarity, urgency, sunk cost, confirmation, or a desired verdict.
Recalibrate confidence to the evidence available.

### 3. LISTEN

Recover the user's intent, success condition, constraints, and unstated stakes.
Attend to error messages, dissent, edge cases, and affected voices. Ask only
questions whose answers could materially change the outcome.

### 4. THINK

Reduce the problem to invariants, alternatives, tradeoffs, and failure modes.
Prefer the smallest reversible test that could disprove the leading hypothesis.
Treat failure behavior as part of the specification.

### 5. CONNECT: lateral

Look for the same structure in adjacent components or another domain. Use an
analogy only when its mapped similarities and limits are explicit.

### 6. CONNECT: system

Trace upstream inputs, downstream consumers, ownership, state boundaries,
interfaces, and recovery paths. Check whether a locally sound decision creates
an integration failure elsewhere.

### 7. FEEL

Consider the user's cognitive load, emotional state, accessibility, trust, and
error-recovery experience. Treat intuition as a signal to investigate, never as
a substitute for evidence.

### 8. ACCEPT

State constraints, uncertainty, contradictory evidence, and unfavorable
findings plainly. Do not inflate a score, soften a material risk to please the
user, or mistake agreement for correctness. Present the strongest reasonable
counterargument to the preferred conclusion.

### 9. CREATE

Produce the smallest useful artifact: a recommendation, decision record,
experiment, draft, review, or handoff. Mark assumptions and unresolved risks.
Do not mutate state under this skill.

### 10. GROW

Define what feedback or measurement should update the decision, when to revisit
it, and what lesson is reusable. Saving the lesson is a separate explicit
operation composed with `save`.

## Verification discipline

Before calling the work complete:

1. Test the highest-risk claim or clearly state why it remains untested.
2. Seek disconfirming evidence, not only supporting examples.
3. Match verification effort to blast radius and reversibility.
4. Report actual commands, sources, artifacts, or observations used.
5. Separate a passing check from broader correctness it does not establish.
6. Give confidence as a calibrated qualitative judgment with reasons, not as a
   decorative percentage.

## Output shape

Adapt the headings to the task, but preserve these outcomes:

```markdown
## Decision
<recommendation or artifact>

## Evidence
<observed facts and important inferences>

## Counterargument and risks
<strongest alternative, contradictions, unknowns>

## Verification
<checks performed and checks still needed>

## Growth loop
<feedback signal, revisit condition, reusable lesson>
```

For a trivial, reversible lookup or typo, skip the formal loop. For a
consequential decision, loop back whenever a later stage exposes a missing
observation or misunderstood requirement.

© AgriciDaniel · MIT · AgriciDaniel/claude-obsidian

Similar skills

All skills for Code review and refactoring →

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 pproenca 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. CX Codex +1 307installs 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 architecture-review Donchitos architecture-review — a skill for Claude Code, Codex, Cursor and other agents that maps every GDD requirement to an architectural decision record. Runs before the project moves from Technical Setup into Pre-Production. CX Codex +1 653installs deliberation chrono-meta deliberation — a Claude Code skill that runs design decisions through three layers: an innovator proposes, a devil's advocate challenges, a mediator synthesizes. CX Codex +1 ★ 33repo stars aws-well-architected-review aws aws-well-architected-review runs an AWS Well-Architected Framework review: reads your code and IaC, checks it against live AWS docs, and returns a prioritized report. CX Codex +1 2,400installs commands-team-collaboration BuildWithClaude Community commands-team-collaboration adds slash commands for team workflows: code reviews, sprint planning, decision analysis, task triage, and standup reports directly in Claude Code and Cursor. ★ 3,785repo stars clean-room backnotprop clean-room is a Claude Code skill that asks a fresh agent to assess a decision from a neutral brief, without the current conversation. Run it for an independent verdict. CX Codex +1 344installs

From the same set15

The whole set →

Project sponsors

Companies that keep this analytics open