cerredz Step-Back Reasoning Trace
Goal
Use Step-Back Reasoning to answer the user's question through a two-phase abstraction-and-reasoning process, building a reasoning trace that records both the principle scaffolding and the reasoning it enables. The trace should first step back from the specific question to identify the general problem class, the underlying principles that govern solutions in that class, the applicable conceptual frameworks, and the key abstractions that strip away irrelevant detail while preserving structural features. It should then reason forward from those abstractions, applying a reasoning structure that is oriented by principles rather than driven by surface features. The goal is to create a public scratchpad that a reviewer can audit without exposing hidden private chain-of-thought. Center the scratchpad on the abstraction phase outputs, subquestions, principle-guided reasoning steps, assumptions, evidence, contrasts, tests, intermediate conclusions, and implications, because those artifacts make step-back reasoning useful rather than decorative. Preserve the user's domain, constraints, definitions, and evidence standards so the trace stays tied to the actual task. Keep uncertainty visible by naming weak assumptions, missing evidence, rival interpretations, and confidence changes as they arise. Write the result to root memory/{question_name}.md so the reasoning trace becomes a durable project artifact.
Intent
We run this trace because detail-first reasoning—the default mode in which models and humans alike plunge into the specifics of a problem—is structurally vulnerable to a class of errors that abstraction prevents. When a reasoner engages immediately with the surface features of a question—the specific numbers, the named entities, the concrete scenario—it risks fixating on irrelevant details, committing to a wrong reasoning direction early, and failing to recognize that the problem is an instance of a general class with known solution patterns. Step-back reasoning addresses this by inserting an abstraction phase before any detailed reasoning begins: the problem is first classified into its general type, the governing principles are identified, and the applicable frameworks are selected, creating a principled scaffold that the subsequent detailed reasoning is anchored to. The trace records both phases—the abstraction scaffolding and the forward reasoning it enables—so a reviewer can verify that the principles were correctly identified and faithfully applied.
This trace is designed to prevent reasoning errors that arise from detail fixation rather than from knowledge gaps. A reasoner who doesn't step back might correctly compute a retention curve but miss that the curve's shape violates a known behavioral principle, because the principle wasn't surfaced before the computation began. A reasoner who does step back would identify the principle first (e.g., Ebbinghaus forgetting curve constraints), then check the computed curve against it. The trace makes this two-phase structure explicit: the Abstraction Scaffolding section shows what principles were identified, and the Scratchpad section shows how each reasoning step is grounded in those principles. A reviewer can independently assess whether the right abstractions were chosen and whether the forward reasoning genuinely follows from them rather than from detail-level intuition.
Instructions
Derive {question_name} from the user's actual question by lowercasing it, replacing non-alphanumeric runs with hyphens, trimming extra hyphens, and using reasoning-trace if no safe name remains. Create the root memory directory when needed, then write or replace memory/{question_name}.md with this trace. Start the file with the question, selected strategy, scale note, source constraints, and the abstraction scaffolding. Build the scratchpad by repeatedly applying the step-back reasoning move: ascend to general principles, identify governing frameworks, then descend back to the specific question with reasoning grounded in the abstractions. Use a medium-depth trace by default, usually around 100 numbered lines, unless the user asks for a different depth. Prefer concise public reasoning artifacts over hidden deliberation, and make every numbered item contribute a question, observation, test, comparison, inference, or synthesis. End the file with a synthesis and final answer that follow from the trace, including any important uncertainty that remains.
Background Information About The Reasoning Strategy
Step-Back Reasoning operationalizes the abstraction-and-reasoning framework from Zheng et al in their 2024 ICLR paper "Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models." The strategy addresses a common reasoning failure mode: when presented with detailed, specific problems, reasoners often become entangled in surface details, pursuing dead-end reasoning chains, misapplying domain knowledge, or failing to recognize that the problem is an instance of a general class with known solution patterns. The remedy is a two-phase structure that separates concept-space exploration from detail-space execution.
In the first phase ΓÇö the step back ΓÇö the reasoner abstracts away from the specific question to identify: (1) the general class of the problem (What known problem type is this an instance of?), (2) the underlying scientific or logical principles at play (What laws, theorems, or regularities govern all instances of this class?), (3) the applicable conceptual frameworks (What established models provide the vocabulary and structure for reasoning about this class?), and (4) the key abstractions that capture the essential structure while discarding irrelevant detail. In the second phase ΓÇö reason forward ΓÇö the reasoner applies those identified principles, frameworks, and abstractions to the specific quantities, constraints, and context in the question. This structure prevents the reasoner from fixating on irrelevant surface features, prematurely committing to a wrong reasoning direction, or failing to check for degenerate cases, boundary conditions, and hidden assumptions.
The empirical foundation includes testing on PaLM-2L, GPT-4, and Llama2-70B across domains spanning physics, chemistry, temporal reasoning, and multi-hop reasoning. PaLM-2L achieved improvements of +7% on MMLU Physics, +11% on MMLU Chemistry, +27% on TimeQA, and +7% on MuSiQue. The core insight is that going wider in concept-space before going deeper in reasoning-space reduces the chance of reasoning errors caused by detail fixation. The two-phase structure also produces more auditable reasoning ΓÇö a reviewer can inspect both the principle scaffolding and how it was applied, rather than having to infer the principles from a detail-level trace.
Algorithm for the Output Document
Restate the user's question, constraints, and evidence standard, then derive the subquestions or working items that step-back reasoning needs to inspect.
Step Back ΓÇö Abstraction Phase: Identify the general class of the problem, the underlying principles that govern solutions in that class, the applicable conceptual frameworks, and the key abstractions that capture essential structure. Write these as explicit, specific outputs ΓÇö not vague restatements.
Reason Forward ΓÇö Application Phase: Apply the identified principles and frameworks to the specific problem. For each subquestion or reasoning step, explicitly ground the reasoning in the abstractions from the first phase. Check for boundary conditions, degenerate cases, and hidden assumptions revealed by the abstraction layer.
For each subquestion, case, option, hypothesis, or criterion the reasoning generates, write numbered public reasoning items that answer it before advancing. Each item should be traceable to at least one abstraction from the first phase.
Record assumptions, missing evidence, disconfirming signals, and confidence changes where they affect the analysis.
Synthesize the completed trace into the final answer, showing how the conclusion follows from principle-guided reasoning rather than from detail-first intuition.
Validate the abstraction scaffolding retrospectively. Check whether each identified principle was actually applied in the forward reasoning phase—an abstraction that was identified but never used is decoration, not scaffolding. Check whether any important principle was missed during the step-back phase and had to be introduced ad-hoc during forward reasoning—if so, flag the gap in the trace and note that the abstraction phase was incomplete. Check whether the forward reasoning inadvertently reverted to detail-first intuition at any point, producing reasoning steps that cannot be traced to any identified principle.
Produce a principle coverage assessment: for each major conclusion in the final answer, identify which abstraction(s) from the step-back phase directly supported it. If any conclusion has no principle grounding—it emerged from detail-level reasoning without reference to the abstraction layer—flag it as potentially vulnerable to the errors that step-back reasoning is designed to prevent. The assessment should make explicit what a reviewer would otherwise have to infer: whether the abstraction scaffolding actually carried weight in the reasoning or was a pro-forma exercise that the forward phase ignored.
Implementation Details
The Step-Back Prompting framework was introduced by Zheng et al. (2024) at ICLR 2024 in "Take a Step Back: Evoking Reasoning via Abstraction in Large Language Models." The core contribution is a two-phase prompting technique that separates concept-space exploration from detail-space execution. In the first phase, the model is prompted to step back and answer a more abstract question—for example, given a specific physics problem about thermal expansion of a copper rod, the step-back question might be "What are the general principles governing thermal expansion in solids?" The model answers this abstraction question, and the answer becomes context for the second phase, where the model reasons forward from the abstracted principles to the specific problem. By front-loading principle identification, the technique prevents the model from becoming entangled in the specific quantities, units, and scenario details before it has established the governing framework.
The empirical evaluation spanned PaLM-2L, GPT-4, and Llama2-70B across domains chosen to stress-test the abstraction-first hypothesis: MMLU Physics and Chemistry (requiring principle identification in scientific domains), TimeQA (requiring temporal reasoning where surface-level chronology can mislead), and MuSiQue (requiring multi-hop reasoning where detail fixation on any single hop can derail the entire chain). PaLM-2L achieved improvements of +7% on MMLU Physics, +11% on MMLU Chemistry, +27% on TimeQA, and +7% on MuSiQue relative to standard chain-of-thought prompting without the step-back abstraction phase. The magnitude of the TimeQA gain (+27%) is particularly notable because temporal reasoning is a domain where surface details (specific dates, event sequences, temporal connectives) are especially likely to cause fixation: the model latches onto a particular date or event ordering and reasons forward from that detail, while the step-back approach first establishes the general temporal relations (what kinds of events precede what other kinds of events) before engaging with specific dates. The MuSiQue gain (+7%) demonstrates that the technique scales to compositional reasoning: each hop in a multi-hop chain benefits from having the governing principle established before the hop is executed, reducing the chance that an early hop's error cascades through subsequent hops.
The mechanism of improvement was analyzed through ablation studies. When Zheng et al. removed the abstraction phase and prompted the model to reason directly about the specific problem, errors clustered in two categories: principle misapplication (the model used a related but incorrect principle because it didn't explicitly identify the correct one first) and detail fixation (the model pursued a reasoning chain triggered by a specific detail rather than by the problem's abstract structure). When the abstraction phase was present, principle misapplication errors dropped by approximately 60%—evidence that the step-back phase's primary benefit is forcing the model to identify the governing principle before it can commit to a reasoning direction. Detail fixation errors dropped by approximately 40%, suggesting that even when the abstraction phase doesn't perfectly identify the right principle, the act of abstracting broadens the model's attention beyond the most salient surface detail. These error-rate reductions map directly to the trace design: the Abstraction Scaffolding section captures what principles were identified, and the Scratchpad section's principle grounding annotations let a reviewer verify that each reasoning step actually used those principles.
For the Vidbyte strategy execution pipeline, the two-phase structure maps cleanly onto strategy problems that benefit from principle-first reasoning. Problems in Retention Optimization (where underlying behavioral principles like Ebbinghaus forgetting curves, habit formation dynamics, and attention decay govern the specific metrics), Monetization Strategy (where economic principles like price elasticity, willingness-to-pay distributions, and bundling effects govern the specific pricing questions), and Brand Narrative (where narrative theory principles like the hero's journey structure, emotional arc theory, and narrative transportation govern the specific creative decisions) are particularly strong candidates for step-back reasoning. The trace records both the abstraction identification and the principle-to-application mapping, producing an auditable reasoning artifact where the reviewer can independently assess whether the right principles were chosen and correctly applied.
Output Information
Write the scratchpad as Markdown in root memory/{question_name}.md before responding to the user. Include this scale note near the top of the file: "Scale: default - aim for around 100 numbered lines, or roughly 2,000 to 3,500 tokens, while adapting to the real complexity of the question." Use numbered scratchpad items for scanability, but treat the number target as approximate and subordinate to usefulness. Keep the scratchpad public, inspectable, and concise enough per line that the structure remains easy to review. After writing the file, respond with the path, a summary of the abstraction scaffolding, the scale note, and the final answer summary.
Specify Files And Length And Structure Of Output
Write the artifact to memory/{question_name}.md at the repository root, using the literal memory directory name. Structure the file with the sections Question, Strategy, Scale, Abstraction Scaffolding, Scratchpad, Synthesis, and Final Answer. The Abstraction Scaffolding section should contain the outputs of the step-back phase: General Class, Underlying Principles, Conceptual Frameworks, and Key Abstractions ΓÇö each with specific, problem-grounded content. The Strategy section should list the slash command. The Scratchpad section should target around 100 numbered lines or roughly 2,000 to 3,500 tokens of public scratchpad detail, adjusted reasonably for very small or unusually broad questions. Use subsections inside Scratchpad when the trace becomes long enough that phases, branches, hypotheses, cases, or criteria would improve readability. Reasoning items in the Scratchpad should explicitly reference abstractions from the Abstraction Scaffolding section where applicable. If the user supplies a domain format, evidence source, or output constraint, preserve it inside this structure while keeping the default scale approximate.
Things Not to Do
- Do not skip the abstraction phase and call it step-back reasoning. Producing a detailed answer with a few general observations sprinkled in is not the same as performing a genuine two-phase process where principles are identified first and reasoning is built from them. The Abstraction Scaffolding section must contain specific, named principles and frameworks, not vague restatements like "the problem involves physics principles."
- Do not identify abstractions that are too generic to be useful. Stating that "this is a problem about optimization" or "this involves trade-offs" is an abstraction so broad that it provides no constraint on the forward reasoning. The identified principles must be specific enough to rule out wrong answers—if every conceivable answer to the problem is compatible with the identified abstractions, the abstractions have failed to do their job.
- Do not allow the forward reasoning to drift away from the identified principles. If the Scratchpad section produces reasoning that cannot be traced to any abstraction from the first phase, the trace has degenerated into detail-first reasoning wearing abstraction clothing. The principle grounding annotations on each reasoning step are what prevent this drift.
- Do not present a step-back that merely restates the question in more abstract language without actually identifying a governing principle. "We need to find the retention rate after 30 days" restated as "We need to understand user persistence over time" is not an abstraction—it is the same question with fancier words. A genuine abstraction identifies a principle like "user retention follows a power-law decay governed by initial engagement strength and habit formation rate."
- Do not omit the principle coverage assessment (step 8 of the algorithm). The trace must explicitly report whether each major conclusion was supported by an identified principle, because this is what distinguishes principle-guided reasoning from detail-first reasoning with a decorative abstraction section. A conclusion without principle grounding is not necessarily wrong, but it is unguarded against the errors step-back reasoning exists to prevent.
- Do not treat the step-back as a one-time event that only happens at the beginning. If the forward reasoning encounters a sub-problem that introduces a new domain or a new class of challenge, a secondary step-back may be warranted to identify the principles governing that sub-domain. The trace should flag these secondary step-back moments explicitly.
- Do not confuse abstraction with generalization. The abstraction phase identifies the underlying principles that govern the problem class, not a more general version of the specific question. The question "How many users will retain after 30 days?" does not step back to "How do products retain users?"—that is generalization, not abstraction. The correct step-back identifies principles like retention decay functions, cohort analysis methodology, and the distinction between early-stage and late-stage retention dynamics.
- Do not allow the forward reasoning to treat the identified principles as infallible. Principles can be incorrectly identified, misapplied to the domain, or have boundary conditions that the specific problem violates. The forward reasoning must test the principles against the problem's specifics, and if a tension emerges between principle and evidence, the trace must flag it rather than resolve it in favor of the principle by default.