@ckelsoe/prompt-architect 3.0.2 → 3.1.1

package/skills/prompt-architect/references/frameworks/rcot.md

@@ -1,203 +1,203 @@
-# RCoT (Reverse Chain-of-Thought)
-
-## Overview
-
-Reverse Chain-of-Thought (RCoT) is a verification framework that catches reasoning errors by working backwards. After generating an initial answer using standard reasoning, the model is instructed to reconstruct what the original question must have been — given only its answer. The reconstructed question is then compared condition-by-condition against the actual question to identify overlooked conditions, misinterpreted constraints, and logical gaps. Discrepancies found in this cross-check feed back into a corrected response.
-
-**Research basis:** Documented on LearnPrompting.org and Mirascope; grounded in academic backward reasoning literature (RCoT paper; FOBAR: forward-backward reasoning). Related work: "Reversal of Thought" (ACL 2025, arXiv 2410.12323); "Reverse Thinking Makes LLMs Stronger Reasoners" (NAACL 2025).
-
-## Why RCoT Works
-
-Forward reasoning errors typically come from:
-- Overlooking a condition in the question
-- Misinterpreting a constraint
-- Assuming something that wasn't stated
-
-When the model reconstructs "what question would produce my answer?", it must articulate what conditions its reasoning implicitly assumed. Comparing these implicit assumptions against the actual question reveals the gaps.
-
-**Limitation:** RCoT catches overlooking and misinterpretation errors well, but is less effective at catching hallucinated facts (fabricated information that is internally consistent) or pure arithmetic errors.
-
-## Components
-
-### Initial Generation
-**Purpose:** Standard reasoning pass — generate an initial answer using Chain-of-Thought or direct reasoning. This is the answer to verify.
-
-### Question Reconstruction
-**Purpose:** Given only the answer (not the original question), reconstruct what the question must have been. The model must articulate the implicit conditions its reasoning assumed.
-
-**Trigger:** *"Looking only at the answer below, reconstruct the question that would produce this answer. List every condition, constraint, and piece of information the question must have contained."*
-
-### Condition Cross-Check
-**Purpose:** Compare the reconstructed question's conditions against the actual question's conditions. List any conditions that: appear in the actual question but not the reconstruction (overlooked), appear in the reconstruction but not the actual question (assumed/hallucinated), or are present in both but interpreted differently.
-
-### Correction
-**Purpose:** Feed the identified discrepancies back to the model to generate a corrected answer that addresses what was missed.
-
-## Template Structure
-
-```
-STEP 1 — INITIAL ANSWER:
-Answer the following question using step-by-step reasoning.
-Show your work.
-
-QUESTION: [Your question]
-
-STEP 2 — QUESTION RECONSTRUCTION:
-Looking only at the answer above (ignore the original question),
-reconstruct the question that would produce this answer.
-List every condition, constraint, and piece of information
-the question must have contained.
-
-RECONSTRUCTED QUESTION: [AI generates this]
-
-STEP 3 — CROSS-CHECK:
-Now compare the reconstructed question to the original question.
-Identify:
-- Conditions in the ORIGINAL question but MISSING from your reconstruction
-  (these are conditions you overlooked in your reasoning)
-- Conditions in your RECONSTRUCTION but NOT in the original question
-  (these are assumptions you made that weren't stated)
-- Conditions present in both but interpreted differently
-
-STEP 4 — CORRECTION:
-If discrepancies were found, generate a corrected answer that addresses
-every condition in the original question. If no discrepancies, confirm
-the original answer is correct.
-```
-
-## Complete Examples
-
-### Example 1: Multi-Condition Logic Problem
-
-```
-STEP 1 — INITIAL ANSWER:
-A company has 3 departments: Engineering, Marketing, and Sales.
-Engineering has 2x as many employees as Marketing.
-Sales has 5 fewer employees than Engineering.
-Marketing has 10 employees.
-How many total employees does the company have?
-
-Show your reasoning step by step.
-
-STEP 2 — QUESTION RECONSTRUCTION:
-Given only this answer: "45 employees total"
-What conditions must the question have contained?
-List every constraint implied by this answer.
-
-STEP 3 — CROSS-CHECK:
-Compare your reconstructed conditions to the actual question.
-What did you overlook? What did you assume that wasn't stated?
-
-STEP 4 — CORRECTION:
-If your cross-check found discrepancies, recalculate with all
-conditions properly applied.
-```
-
-### Example 2: Complex Requirement Analysis
-
-```
-STEP 1:
-Given these requirements: [paste requirements]
-Which of the following implementation approaches satisfies all of them?
-[List options]
-
-[AI generates initial recommendation]
-
-STEP 2 — RECONSTRUCTION:
-Looking only at the recommendation above, reconstruct the requirements
-that must have been in the original question.
-
-STEP 3 — CROSS-CHECK:
-Compare your reconstructed requirements to the actual requirements above.
-Which requirements did you not account for in your recommendation?
-
-STEP 4 — CORRECTION:
-Update the recommendation to satisfy the overlooked requirements.
-```
-
-### Example 3: Multi-Step Technical Analysis
-
-```
-STEP 1:
-[Complex technical question with multiple constraints]
-Analyze and recommend an approach.
-
-[AI generates initial analysis]
-
-STEP 2 — RECONSTRUCTION:
-From the analysis above only, list every constraint and requirement
-the original question must have specified.
-
-STEP 3 — CROSS-CHECK:
-Compare against the actual question. What was overlooked?
-What was assumed without basis?
-
-STEP 4 — CORRECTION:
-Revise the analysis to address everything found in Step 3.
-```
-
-## Abbreviated Version (Single Prompt)
-
-For simpler use cases, collapse all steps into one compound prompt:
-
-```
-Answer the following question step by step: [QUESTION]
-
-Then, working only from your answer (not re-reading the question),
-reconstruct what the question must have contained.
-
-Compare your reconstruction to the actual question. Identify any
-conditions you overlooked or misinterpreted.
-
-If discrepancies exist, provide a corrected answer.
-```
-
-## Best Use Cases
-
-1. **Multi-Condition Logic Problems**
-   - Questions with several constraints that must all be satisfied
-   - Eligibility determination, scheduling, constraint satisfaction
-
-2. **Complex Technical Requirements**
-   - Architecture decisions with multiple requirements
-   - Code that must satisfy several constraints simultaneously
-
-3. **Legal/Financial/Medical Analysis**
-   - Multi-clause documents where missing one condition is costly
-   - Any domain where overlooked conditions cause errors
-
-4. **Verification Layer in Pipelines**
-   - Add RCoT as a verification step after any complex reasoning
-   - Especially useful before high-stakes decisions
-
-## Selection Criteria
-
-**Choose RCoT when:**
-- ✅ The question has multiple conditions/constraints that could be overlooked
-- ✅ You want to verify that reasoning addressed everything
-- ✅ Previous answers to similar questions have missed conditions
-- ✅ Domain is high-stakes and overlooked conditions are costly
-
-**Avoid when:**
-- ❌ Simple question with one condition → overhead not worth it
-- ❌ Verification needs involve factual accuracy → CRITIC (tool-grounded) is better
-- ❌ Arithmetic verification → PS+ or explicit calculation check is faster
-- ❌ Creative or generative task → no "conditions to miss"
-
-## RCoT vs. Other Reasoning Frameworks
-
-| | RCoT | Chain of Thought | Plan-and-Solve | Step-Back |
-|---|---|---|---|---|
-| Direction | Forward then backward (verification) | Forward only | Forward with planning | Abstract then forward |
-| Best for | Catching overlooked conditions | Linear reasoning | Numerical calculation | Principle-grounded reasoning |
-| Adds | Verification pass | None | Planning + variable extraction | Abstraction step |
-| Failure mode | Doesn't catch hallucinations | Errors compound | Still needs correct variables | Step-back too vague |
-
-## Quick Reference
-
-| Step | Purpose |
-|------|---------|
-| Initial Answer | Generate reasoning (forward) |
-| Reconstruction | "What question produced this?" (backward) |
-| Cross-Check | Compare conditions: original vs. reconstructed |
-| Correction | Fix what was overlooked or misinterpreted |
+# RCoT (Reverse Chain-of-Thought)
+
+## Overview
+
+Reverse Chain-of-Thought (RCoT) is a verification framework that catches reasoning errors by working backwards. After generating an initial answer using standard reasoning, the model is instructed to reconstruct what the original question must have been — given only its answer. The reconstructed question is then compared condition-by-condition against the actual question to identify overlooked conditions, misinterpreted constraints, and logical gaps. Discrepancies found in this cross-check feed back into a corrected response.
+
+**Research basis:** Documented on LearnPrompting.org and Mirascope; grounded in academic backward reasoning literature (RCoT paper; FOBAR: forward-backward reasoning). Related work: "Reversal of Thought" (ACL 2025, arXiv 2410.12323); "Reverse Thinking Makes LLMs Stronger Reasoners" (NAACL 2025).
+
+## Why RCoT Works
+
+Forward reasoning errors typically come from:
+- Overlooking a condition in the question
+- Misinterpreting a constraint
+- Assuming something that wasn't stated
+
+When the model reconstructs "what question would produce my answer?", it must articulate what conditions its reasoning implicitly assumed. Comparing these implicit assumptions against the actual question reveals the gaps.
+
+**Limitation:** RCoT catches overlooking and misinterpretation errors well, but is less effective at catching hallucinated facts (fabricated information that is internally consistent) or pure arithmetic errors.
+
+## Components
+
+### Initial Generation
+**Purpose:** Standard reasoning pass — generate an initial answer using Chain-of-Thought or direct reasoning. This is the answer to verify.
+
+### Question Reconstruction
+**Purpose:** Given only the answer (not the original question), reconstruct what the question must have been. The model must articulate the implicit conditions its reasoning assumed.
+
+**Trigger:** *"Looking only at the answer below, reconstruct the question that would produce this answer. List every condition, constraint, and piece of information the question must have contained."*
+
+### Condition Cross-Check
+**Purpose:** Compare the reconstructed question's conditions against the actual question's conditions. List any conditions that: appear in the actual question but not the reconstruction (overlooked), appear in the reconstruction but not the actual question (assumed/hallucinated), or are present in both but interpreted differently.
+
+### Correction
+**Purpose:** Feed the identified discrepancies back to the model to generate a corrected answer that addresses what was missed.
+
+## Template Structure
+
+```
+STEP 1 — INITIAL ANSWER:
+Answer the following question using step-by-step reasoning.
+Show your work.
+
+QUESTION: [Your question]
+
+STEP 2 — QUESTION RECONSTRUCTION:
+Looking only at the answer above (ignore the original question),
+reconstruct the question that would produce this answer.
+List every condition, constraint, and piece of information
+the question must have contained.
+
+RECONSTRUCTED QUESTION: [AI generates this]
+
+STEP 3 — CROSS-CHECK:
+Now compare the reconstructed question to the original question.
+Identify:
+- Conditions in the ORIGINAL question but MISSING from your reconstruction
+  (these are conditions you overlooked in your reasoning)
+- Conditions in your RECONSTRUCTION but NOT in the original question
+  (these are assumptions you made that weren't stated)
+- Conditions present in both but interpreted differently
+
+STEP 4 — CORRECTION:
+If discrepancies were found, generate a corrected answer that addresses
+every condition in the original question. If no discrepancies, confirm
+the original answer is correct.
+```
+
+## Complete Examples
+
+### Example 1: Multi-Condition Logic Problem
+
+```
+STEP 1 — INITIAL ANSWER:
+A company has 3 departments: Engineering, Marketing, and Sales.
+Engineering has 2x as many employees as Marketing.
+Sales has 5 fewer employees than Engineering.
+Marketing has 10 employees.
+How many total employees does the company have?
+
+Show your reasoning step by step.
+
+STEP 2 — QUESTION RECONSTRUCTION:
+Given only this answer: "45 employees total"
+What conditions must the question have contained?
+List every constraint implied by this answer.
+
+STEP 3 — CROSS-CHECK:
+Compare your reconstructed conditions to the actual question.
+What did you overlook? What did you assume that wasn't stated?
+
+STEP 4 — CORRECTION:
+If your cross-check found discrepancies, recalculate with all
+conditions properly applied.
+```
+
+### Example 2: Complex Requirement Analysis
+
+```
+STEP 1:
+Given these requirements: [paste requirements]
+Which of the following implementation approaches satisfies all of them?
+[List options]
+
+[AI generates initial recommendation]
+
+STEP 2 — RECONSTRUCTION:
+Looking only at the recommendation above, reconstruct the requirements
+that must have been in the original question.
+
+STEP 3 — CROSS-CHECK:
+Compare your reconstructed requirements to the actual requirements above.
+Which requirements did you not account for in your recommendation?
+
+STEP 4 — CORRECTION:
+Update the recommendation to satisfy the overlooked requirements.
+```
+
+### Example 3: Multi-Step Technical Analysis
+
+```
+STEP 1:
+[Complex technical question with multiple constraints]
+Analyze and recommend an approach.
+
+[AI generates initial analysis]
+
+STEP 2 — RECONSTRUCTION:
+From the analysis above only, list every constraint and requirement
+the original question must have specified.
+
+STEP 3 — CROSS-CHECK:
+Compare against the actual question. What was overlooked?
+What was assumed without basis?
+
+STEP 4 — CORRECTION:
+Revise the analysis to address everything found in Step 3.
+```
+
+## Abbreviated Version (Single Prompt)
+
+For simpler use cases, collapse all steps into one compound prompt:
+
+```
+Answer the following question step by step: [QUESTION]
+
+Then, working only from your answer (not re-reading the question),
+reconstruct what the question must have contained.
+
+Compare your reconstruction to the actual question. Identify any
+conditions you overlooked or misinterpreted.
+
+If discrepancies exist, provide a corrected answer.
+```
+
+## Best Use Cases
+
+1. **Multi-Condition Logic Problems**
+   - Questions with several constraints that must all be satisfied
+   - Eligibility determination, scheduling, constraint satisfaction
+
+2. **Complex Technical Requirements**
+   - Architecture decisions with multiple requirements
+   - Code that must satisfy several constraints simultaneously
+
+3. **Legal/Financial/Medical Analysis**
+   - Multi-clause documents where missing one condition is costly
+   - Any domain where overlooked conditions cause errors
+
+4. **Verification Layer in Pipelines**
+   - Add RCoT as a verification step after any complex reasoning
+   - Especially useful before high-stakes decisions
+
+## Selection Criteria
+
+**Choose RCoT when:**
+- ✅ The question has multiple conditions/constraints that could be overlooked
+- ✅ You want to verify that reasoning addressed everything
+- ✅ Previous answers to similar questions have missed conditions
+- ✅ Domain is high-stakes and overlooked conditions are costly
+
+**Avoid when:**
+- ❌ Simple question with one condition → overhead not worth it
+- ❌ Verification needs involve factual accuracy → CRITIC (tool-grounded) is better
+- ❌ Arithmetic verification → PS+ or explicit calculation check is faster
+- ❌ Creative or generative task → no "conditions to miss"
+
+## RCoT vs. Other Reasoning Frameworks
+
+| | RCoT | Chain of Thought | Plan-and-Solve | Step-Back |
+|---|---|---|---|---|
+| Direction | Forward then backward (verification) | Forward only | Forward with planning | Abstract then forward |
+| Best for | Catching overlooked conditions | Linear reasoning | Numerical calculation | Principle-grounded reasoning |
+| Adds | Verification pass | None | Planning + variable extraction | Abstraction step |
+| Failure mode | Doesn't catch hallucinations | Errors compound | Still needs correct variables | Step-back too vague |
+
+## Quick Reference
+
+| Step | Purpose |
+|------|---------|
+| Initial Answer | Generate reasoning (forward) |
+| Reconstruction | "What question produced this?" (backward) |
+| Cross-Check | Compare conditions: original vs. reconstructed |
+| Correction | Fix what was overlooked or misinterpreted |