Thought Based Reasoning
Pick and apply Chain-of-Thought and related prompting patterns when simple prompts fail on multi-step logic, math, or planning tasks.
Overview
thought-based-reasoning is a journey-wide agent skill that guides Chain-of-Thought and related prompting techniques—usable whenever a solo builder needs explicit step-by-step LLM reasoning before committing to an answer.
Install
npx skills add https://github.com/neolabhq/context-engineering-kit --skill thought-based-reasoningWhat is this skill?
- Covers Zero-shot CoT, Few-shot CoT, Self-Consistency, Tree of Thoughts, Least-to-Most, ReAct, PAL, and Reflexion
- Quick-reference table maps each technique to use case, complexity, and reported accuracy gains
- Decision matrices and templates for choosing a reasoning pattern per task type
- Targets commonsense, arithmetic, symbolic manipulation, and multi-step problems where flat prompts fail
- Research-backed patterns for making implicit LLM reasoning explicit before the final answer
- 8 named reasoning techniques in the quick-reference table
- Reported accuracy gains from roughly +10% to +80% depending on technique and task
Adoption & trust: 590 installs on skills.sh; 1.1k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
Simple one-shot prompts fail on complex reasoning, and you lack a structured way to choose CoT, Self-Consistency, Tree of Thoughts, or ReAct for the task at hand.
Who is it for?
Builders tuning agent prompts for math, planning, debugging hypotheses, or research synthesis when accuracy matters more than latency.
Skip if: Trivial lookups or fixed-format extractions where extra reasoning tokens add cost without benefit.
When should I use this skill?
Tackling complex reasoning, multi-step arithmetic, commonsense logic, symbolic tasks, or any problem where simple prompting fails.
What do I get? / Deliverables
You apply a research-backed reasoning pattern with templates and decision matrices so the model produces auditable intermediate steps and higher accuracy on multi-step problems.
- Selected reasoning technique
- Prompt template applied to the task
- Explicit intermediate reasoning steps before final answer
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Compare three niche positioning options with Zero-shot CoT before you commit to a build theme.
Decompose a MVP feature list with Least-to-Most prompting to surface hidden subproblems.
Wire ReAct-style prompts when the agent must call tools and reason over external facts.
Run Self-Consistency over a risky auth change to see if multiple reasoning paths agree.
Interpret funnel anomalies with explicit CoT so you can audit assumptions in the narrative.
How it compares
Use as a prompting methodology reference instead of unstructured “think step by step” copy-paste without technique selection.
Common Questions / FAQ
Who is thought-based-reasoning for?
Solo builders and indie hackers designing LLM workflows who need dependable multi-step reasoning across product, agent, and research tasks.
When should I use thought-based-reasoning?
Use it during Idea competitor analysis, Validate scope tradeoffs, Build agent-tooling prompts, Ship review of complex logic, or Operate when diagnosing incidents—whenever flat prompting gives inconsistent or wrong conclusions.
Is thought-based-reasoning safe to install?
Check the Security Audits panel on this Prism page for the skill source; the content is instructional prompting guidance with no required secret access.
SKILL.md
READMESKILL.md - Thought Based Reasoning
# Thought-Based Reasoning Techniques for LLMs ## Overview Chain-of-Thought (CoT) prompting and its variants encourage LLMs to generate intermediate reasoning steps before arriving at a final answer, significantly improving performance on complex reasoning tasks. These techniques transform how models approach problems by making implicit reasoning explicit. ## Quick Reference | Technique | When to Use | Complexity | Accuracy Gain | |-----------|-------------|------------|---------------| | Zero-shot CoT | Quick reasoning, no examples available | Low | +20-60% | | Few-shot CoT | Have good examples, consistent format needed | Medium | +30-70% | | Self-Consistency | High-stakes decisions, need confidence | Medium | +10-20% over CoT | | Tree of Thoughts | Complex problems requiring exploration | High | +50-70% on hard tasks | | Least-to-Most | Multi-step problems with subproblems | Medium | +30-80% | | ReAct | Tasks requiring external information | Medium | +15-35% | | PAL | Mathematical/computational problems | Medium | +10-15% | | Reflexion | Iterative improvement, learning from errors | High | +10-20% | --- ## Core Techniques ### 1. Chain-of-Thought (CoT) Prompting **Paper**: "Chain of Thought Prompting Elicits Reasoning in Large Language Models" (Wei et al., 2022) **Citations**: 14,255+ #### When to Use - Multi-step arithmetic or math word problems - Commonsense reasoning requiring logical deduction - Symbolic reasoning tasks - When you have good exemplars showing reasoning #### How It Works Provide few-shot examples that include intermediate reasoning steps, not just question-answer pairs. The model learns to generate similar step-by-step reasoning. #### Prompt Template ``` Q: Roger has 5 tennis balls. He buys 2 more cans of tennis balls. Each can has 3 tennis balls. How many tennis balls does he have now? A: Roger started with 5 balls. 2 cans of 3 tennis balls each is 6 tennis balls. 5 + 6 = 11. The answer is 11. Q: The cafeteria had 23 apples. If they used 20 to make lunch and bought 6 more, how many apples do they have? A: The cafeteria had 23 apples originally. They used 20 to make lunch. So they had 23 - 20 = 3. They bought 6 more apples, so they have 3 + 6 = 9. The answer is 9. Q: [YOUR QUESTION HERE] A: ``` #### Strengths - Significant accuracy improvements on reasoning tasks - Interpretable intermediate steps - Works well with large models (>100B parameters) #### Limitations - Requires crafting good exemplars - Less effective on smaller models - Can still make calculation errors --- ### 2. Zero-shot Chain-of-Thought **Paper**: "Large Language Models are Zero-Shot Reasoners" (Kojima et al., 2022) **Citations**: 5,985+ #### When to Use - No exemplars available - Quick reasoning needed - General-purpose reasoning across task types - Prototyping before creating few-shot examples #### How It Works Simply append "Let's think step by step" (or similar phrase) to the prompt. This triggers the model to generate reasoning steps without any examples. #### Prompt Template ``` Q: A juggler can juggle 16 balls. Half of the balls are golf balls, and half of the golf balls are blue. How many blue golf balls are there? Let's think step by step. ``` **Alternative trigger phrases**: - "Let's work this out step by step to be sure we have the right answer." - "Let's break this down." - "Let's approach this systematically." - "First, let me understand the problem..." #### Two-Stage Approach (More Robust) **Stage 1 - Reasoning Extraction**: ``` Q: [QUE