Think Deeper

Think Deeper is a small skill I use with Codex and Claude when an idea feels plausible but still too close to the first answer. It tells the model to stop decorating the current frame, find the assumptions holding it up, and rebuild the idea from first principles.

It is one part of How I Use Codex, the six-skill loop I use to find, challenge, pressure-test, and build ideas.

It is useful for brainstorming, product direction, technical plans, creative concepts, arguments, and decisions. The important part is that it does not mean "write more." A good depth pass can make an answer shorter by finding the actual bottleneck.

---
name: think-deeper
description: Perform an explicit first-principles depth pass on the current task, idea, product, codebase, creative direction, argument, plan, strategy, prompt, or decision. Use when the user directly asks to think deeper, reason from fundamentals, challenge the frame, or rebuild the answer at a more fundamental level. Do not auto-trigger merely because a task is complex; use a narrower skill when one exists for the actual request.
---

# Think Deeper

Re-examine the problem from fundamentals and return a sharper answer. Depth means better mechanisms, assumptions, tradeoffs, and next actions, not more words.

## Workflow

1. **Name the actual goal:** distinguish the desired outcome from the current solution shape.
2. **Reduce to fundamentals:** identify the forces, constraints, incentives, data, actors, and mechanisms that must be true.
3. **Expose load-bearing assumptions:** separate likely true, uncertain, probably false, and testable.
4. **Challenge the frame:** test problem, category, scale, audience, medium, timeline, and false constraints.
5. **Rebuild the formulation:** produce the simpler, more precise thesis, architecture, concept, plan, or decision frame.
6. **State what changes now:** cut, test, build, research, rewrite, or decide.

## First-Principles Prompts

Use only what clarifies the task:

- What outcome must exist at the end?
- What must be true for it to happen?
- Which constraints are real and which are inherited assumptions?
- What is the bottleneck: concept, execution, distribution, coordination, evidence, or taste?
- What is the simplest system that satisfies the goal?
- What complexity buys leverage and what merely creates work?
- What would change with half the resources or twice the quality bar?
- What next action would create real evidence?

## Output

Prefer:

- Deeper read
- First principles
- Hidden assumptions
- Frame correction
- Stronger formulation
- What changes now

For smaller asks, compress this to deeper read, strongest assumption, stronger version, and next move.

## Domain Calibration

- **Technical:** actual job, data and control flow, failure modes, complexity budget, testable slice.
- **Product:** first user, urgent need, substitute, wedge, distribution, retention, smallest proof.
- **Creative:** emotional center, point of view, world logic, audience reason to care, decorative versus consequential detail.
- **Argument:** thesis, definitions, mechanism, weakest link, strongest counterargument, conclusion that really follows.
- **Decision:** value being optimized, reversibility, unavoidable tradeoff, missing evidence, low-regret experiment.

## Guardrails

Do not perform profundity, add frameworks that do not change the answer, or turn a simple problem into a meditation. If the original approach is already right, say so and sharpen it. If the deeper answer is shorter, write the shorter answer.

The Difference

Without a method, "think deeper" can produce a longer version of the same answer. This skill makes depth operational:

1. Name the outcome instead of accepting the proposed solution.
2. Reduce the problem to forces, constraints, incentives, and mechanisms.
3. Expose the assumptions that carry the idea.
4. Challenge the category, audience, medium, scale, and timeline.
5. Rebuild the strongest version.
6. End with something that changes now.

That last step matters. If the analysis does not change what I cut, test, build, research, rewrite, or decide, it was probably just performing intelligence.

A Small Example

First-pass ask: Brainstorm features for an AI idea app.

The obvious response is a list: idea cards, voting, remixing, folders, collaboration, exports. It sounds productive, but it assumes the problem is a shortage of ideas.

Depth-pass ask: Use Think Deeper on this. What is the actual outcome, which assumption is carrying the concept, and what would create evidence?

The stronger read is that most people do not need more ideas. They need help finding the consequence inside one idea, choosing a direction, and learning whether it survives contact with reality. That changes the product from an infinite brainstorm wall into a system that commits to one promising branch, names its risks, and designs the cheapest revealing test.

Same starting point. Different product.

How I Use It

I usually invoke it after the model has enough context to understand the work:

Use $think-deeper on this direction. Challenge the frame, find the
load-bearing assumptions, and rebuild the strongest version from first
principles. End with what should change now.

For a lighter pass:

Think deeper about this. Give me the deeper read, strongest assumption,
stronger version, and next move.

Install

For Codex, put the downloaded file at think-deeper/SKILL.md inside a local .agents/skills directory, then mention $think-deeper in a prompt. Codex can also choose it automatically when the request matches its description.

For Claude, use the same SKILL.md in your Claude skill setup, or keep the instructions in your project context and explicitly ask Claude to apply Think Deeper. The file is deliberately plain and portable: one focused workflow, no scripts, no model-specific tricks.

What It Is Not

This is not a magic phrase that makes a model smarter, and it should not trigger on every difficult task. It is a review protocol for moments when the current frame itself may be wrong.

If the original approach is already right, the skill should say so and sharpen it. If the deeper answer is shorter, it should write the shorter answer.