Self-Discover
Instead of forcing every problem through one fixed reasoning pattern, let the model first discover a reasoning structure tailored to the task, by selecting and composing atomic reasoning modules, then solve each problem by following that structure.
*These are learning tools, not prompts. They teach you to write your own, think of them as training wheels that guide you while you learn, then fall away once you can ride on your own.
Let the Model Design Its Own Plan
Most reasoning techniques impose one shape on every problem. Chain-of-Thought says “think step by step” whether the task is arithmetic, spatial logic, or ethical judgment. But different problems call for different kinds of thinking, and a single fixed pattern leaves value on the table.
Self-Discover lets the model compose the reasoning approach itself. It draws on a set of atomic reasoning modules, generic thinking moves like “break the problem into subproblems,” “think step by step,” “consider it critically,” or “reason about physical relationships,” and assembles the relevant ones into an explicit, task-specific reasoning structure. That structure is discovered once per task, then reused to solve every instance of that task.
The payoff is both quality and efficiency. Because the structure is tailored to the task rather than generic, it substantially improves reasoning accuracy. And because the expensive discovery happens once at the task level, not per problem, Self-Discover reaches strong results at a fraction of the inference cost of methods that sample many reasoning paths for every single question.
The key move is separating two things that most methods blur together: figuring out how to reason about a task, and actually reasoning through a specific problem. Self-Discover does the first once, producing a reusable reasoning structure, then applies it cheaply to every instance. This is why it can outperform approaches that repeatedly sample reasoning paths, while using far less compute: the hard thinking about how to think is amortized across the whole task.
The Self-Discover Process
Discover a reasoning structure at the task level, then apply it per problem
Select Relevant Reasoning Modules
From a pool of atomic reasoning modules, generic thinking strategies such as decomposition, step-by-step reasoning, critical thinking, or reasoning about causes, the model selects the ones most useful for the task at hand. This is the first stage of discovering how to think about the problem.
For a spatial logic puzzle, the model selects modules like “break the problem into smaller parts,” “reason about spatial relationships,” and “check for consistency.”
Adapt Modules to the Task
The selected modules are generic, so the model rephrases each one to fit the specific task. A broad module like “break the problem into subproblems” becomes a concrete, task-relevant instruction. This adaptation makes the eventual structure directly actionable for the problem domain.
“Break the problem into subproblems” becomes “identify each object’s position and the constraints on where it can go.”
Implement the Reasoning Structure
The adapted modules are composed into an explicit, ordered reasoning structure, essentially a step-by-step plan, often written as a structured key-value outline. This structure captures how to reason about any instance of the task, and it is produced only once per task.
A structure like: 1) list objects and constraints, 2) place the most constrained object first, 3) propagate constraints, 4) verify no rule is violated, 5) state the arrangement.
Solve Each Instance by Following It
With the reasoning structure in hand, the model solves each specific problem by filling it in step by step. The same discovered structure is reused across every instance of the task, so the one-time cost of discovery pays off repeatedly, and the reasoning stays consistent and auditable.
For each new puzzle, the model walks the five-step structure, producing the arrangement plus a clear trail of how it was derived.
See the Difference
A task-specific structure versus one generic pattern for everything
One Fixed Pattern
Apply “think step by step” to every problem, whatever its nature, and sample many reasoning paths per question to boost accuracy.
The generic pattern may not suit the task’s real structure, and sampling many paths for every single question is expensive.
Self-Discover
Discover a reasoning structure tailored to the task once, by selecting, adapting, and composing atomic modules, then reuse it to solve every instance.
The structure matches how the task should actually be reasoned about, and the one-time discovery cost is amortized across all instances.
Practice Responsible AI
Always verify AI-generated content before use. AI systems can produce confident but incorrect responses. When using AI professionally, transparent disclosure is both best practice and increasingly a legal requirement.
Most US states are actively legislating AI transparency and accountability. Critical thinking remains your strongest tool against misinformation.
Self-Discover in Action
Discovering a fitted reasoning structure across different task types
A class of multi-step rate-and-work word problems where naive step-by-step reasoning often mixes up which quantity to combine.
Selected + adapted modules: identify all rates and their units; convert to a common basis; combine rates only when they act together; solve for the unknown; sanity-check the units.
Applied per problem: the model fills in each step for the specific numbers, so it never combines incompatible rates, the error a generic chain often makes. The structure, discovered once, guards every problem in the class.
Constraint puzzles (who owns which pet, lives in which house) where the order of applying clues determines whether the model gets stuck.
Selected + adapted modules: list entities and attributes; encode each clue as a constraint; apply the most restrictive constraints first; propagate consequences; backtrack on contradiction; report the unique solution.
Applied per problem: because the structure front-loads the tightest constraints, the model resolves puzzles that trip up a left-to-right reading of the clues.
Recurring business decisions (build vs buy, vendor selection) where the team wants consistent, comparable analyses each time.
Selected + adapted modules: state the decision and options; list the criteria that matter; weigh each option against the criteria; surface key risks and assumptions; recommend with a rationale.
Applied per decision: every analysis follows the same discovered structure, so results are consistent and comparable across decisions, a durable template rather than a one-off answer.
When to Use Self-Discover
Best when a whole class of problems shares a reasoning shape
Perfect For
When you will solve many instances of the same kind of problem, the one-time discovery cost is amortized and the fitted structure pays off every time.
Tasks whose natural approach is not plain step-by-step, spatial, constraint-based, or multi-criteria problems that a generic chain handles poorly.
When sampling many reasoning paths per question is too expensive, discovering one structure and reusing it delivers strong accuracy far more cheaply.
When you need every answer in a class produced the same way, a shared discovered structure enforces a consistent, comparable process.
Skip It When
For a single question you will not repeat, the overhead of discovering a reusable structure is not worth it; a direct chain is simpler.
Straightforward lookups or one-step problems gain nothing from a composed reasoning structure; the machinery is overkill.
If each request needs a genuinely different approach, there is no shared task structure to discover and reuse.
Use Cases
Where Self-Discover delivers the most value
Benchmark and Exam Reasoning
Discover a fitted structure for a category of exam or benchmark questions, then apply it across the whole set for consistent, higher-accuracy solutions.
Repeatable Analytical Workflows
Turn a recurring analysis into a discovered reasoning structure so every run follows the same rigorous, comparable steps.
Agent Task Planning
Give an agent a discovered structure for a class of tasks, so it plans consistently instead of improvising a new approach every run.
Structured Case Review
Compose a review structure for cases or applications so each is evaluated against the same criteria in the same order, improving fairness and auditability.
Cost-Efficient Reasoning Systems
Replace expensive per-question path sampling with a discover-once structure, cutting inference cost while keeping strong reasoning quality.
Teaching Reasoning Patterns
Expose the discovered structure to learners so they can see, and reuse, the explicit reasoning plan behind a class of problems.
Where Self-Discover Fits
From one fixed pattern to a self-composed reasoning structure
Self-Discover reframes the question from “how do I answer this problem?” to “how should this kind of problem be reasoned about?” By selecting, adapting, and composing atomic reasoning modules into an explicit structure, it produces a reusable plan that fits the task rather than a generic pattern applied everywhere. Discovering that structure once and reusing it is what lets Self-Discover beat approaches that sample many reasoning paths per question, at a small fraction of the compute. Pair it with Chain-of-Thought to walk each discovered step in detail.
Related Techniques
Explore complementary reasoning techniques
Let the Model Find the Structure
Try Self-Discover in the Prompt Builder, or explore how it connects to other reasoning frameworks.