Think Deeper

Think Deeper is a skill for Codex and Claude: a short Markdown file of instructions the model follows. I reach for it when an idea sounds plausible but is still close to the first answer. It tells the model to stop adding detail to that version, find the assumptions it rests on, and rebuild the idea from first principles.

I use it on brainstorms, product and technical plans, creative concepts, arguments, and decisions. It is one of the six skills I work through to find, question, pressure-test, and build ideas. How I Use Codex describes all six.

---
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.

What it tells the model to do

If you just ask a model to think deeper, you often get a longer version of the same answer. A good pass can make the answer shorter, because it finds the actual bottleneck. The skill breaks the request into six steps:

1. Separate the outcome that's wanted from the solution already proposed.
2. Break the problem down to what drives it: the constraints, the incentives, and how it actually works.
3. Find the assumptions the idea depends on.
4. Question the basic choices: category, audience, medium, scale, and timeline.
5. Rebuild the strongest version.
6. End with what should change now.

If the analysis doesn't change what I cut, test, build, research, rewrite, or decide, it was probably just the model sounding smart.

An example

First prompt: Brainstorm features for an AI idea app.

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

Second prompt: Use Think Deeper on this. What is the actual outcome, which assumption is carrying the concept, and what would create evidence?

The better answer is that most people don't need more ideas. They need help working out where one idea leads, choosing a direction, and finding out whether it holds up. So the app should stop being an endless wall of brainstorms and become a tool that picks one promising branch, names its risks, and designs the cheapest test that would give real evidence.

How I use it

It shouldn't trigger on every hard task, and it won't make a model smarter. It's for when I suspect the problem itself is framed wrong. If the original approach is already right, the skill tells the model to say so and sharpen it.

I usually bring it in once 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 quicker 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. I kept the file plain so it works with both. It has one set of steps, no scripts, and nothing written for a specific model.