
Thinking Socratic
- 157 installs
- 930 repo stars
- Updated August 5, 2026
- tjboudreaux/cc-thinking-skills
thinking-socratic is a Claude Code skill that applies six categories of Socratic questioning to clarify vague or assumption-laden requests before developers write code.
About
thinking-socratic is a pre-build clarification skill from the cc-thinking-skills collection that teaches Claude Code to ask load-bearing questions instead of guessing when a task is underspecified. The skill defines six question types—clarification, assumption-probing, reason and evidence, perspective, implication, and meta-questioning—and maps each to concrete triggers such as vague symptoms, unchecked premises, or solution-first proposals. Developers reach for thinking-socratic when a request like "make it fast" or "add a dashboard" lacks measurable criteria, when debugging claims need tracing to specifics, or when design reviews jump to implementation before the problem is defined. The skill explicitly stops short of well-specified tasks, self-answerable ambiguities resolvable from code or docs, and mid-execution re-questioning after a plan is agreed.
- Defines 6 Socratic question types: clarification, assumptions, evidence, perspective, implications, meta
- Decision flow gates build/commit when requests are underspecified or assumption-laden
- Includes requirement-gathering, debugging, and design-review application patterns
- Verification checklist requires probing assumptions and exploring alternative perspectives
Thinking Socratic by the numbers
- 157 all-time installs (skills.sh)
- +10 installs in the week ending Aug 5, 2026 (Skillselion tracking)
- Ranked #1,155 of 3,282 Productivity & Planning skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/tjboudreaux/cc-thinking-skills --skill thinking-socraticAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 157 |
|---|---|
| repo stars | ★ 930 |
| Last updated | August 5, 2026 |
| Repository | tjboudreaux/cc-thinking-skills ↗ |
How do you clarify vague coding requests before building?
Run thinking-socratic before coding when a task description is vague, assumption-heavy, or jumps to a solution without defining the problem.
Who is it for?
Developers and tech leads who want an AI agent to ask targeted clarifying questions instead of silently guessing on underspecified feature, bug, or design requests.
Skip if: Skip thinking-socratic when the task is already fully specified, ambiguity is answerable by reading code or running commands, or you are mid-execution on an agreed plan.
When should I use this skill?
A coding request is vague, rests on unstated assumptions, or proposes a solution before the problem is defined.
What you get
Clarified requirements, surfaced assumptions, documented key insights, and a settled spec before code changes.
By the numbers
- Defines 6 types of Socratic questions with example prompts per category
- Verification checklist spans 6 checklist items before proceeding to build
Files
Socratic Questioning
Overview
The Socratic Method, developed by the ancient Greek philosopher Socrates, uses systematic questioning to stimulate critical thinking and illuminate ideas. Rather than providing answers, it draws out knowledge by challenging assumptions and exploring implications.
Core Principle: Questions are more powerful than answers. The right question reveals what we don't know we don't know.
When to Use
- Requirements gathering (understanding what stakeholders really need)
- Debugging (tracing assumptions to find root causes)
- Code review (understanding design decisions)
- Coaching and mentoring (helping others reach insights)
- Self-reflection (examining your own beliefs)
- Evaluating proposals or designs
- When someone says "obvious" or "everyone knows"
Decision flow:
Understanding seems shallow? → yes → APPLY SOCRATIC QUESTIONING
Assumptions unexamined? → yes → APPLY SOCRATIC QUESTIONING
Root cause unclear? → yes → APPLY SOCRATIC QUESTIONINGThe Six Types of Socratic Questions
1. Clarification Questions
Purpose: Ensure clear understanding of the claim or concept
| Question | Use When |
|---|---|
| "What do you mean by X?" | Term is ambiguous |
| "Can you give me an example?" | Concept is abstract |
| "How does this relate to Y?" | Connection unclear |
| "Can you rephrase that?" | Statement is confusing |
| "What is the main point?" | Discussion is scattered |
Example:
"The system needs to be fast."
→ "What do you mean by 'fast'? What latency is acceptable?"
→ "Fast for whom? End users? Batch processes?"
2. Assumption-Probing Questions
Purpose: Expose underlying beliefs that may be unexamined
| Question | Use When |
|---|---|
| "What are we assuming here?" | Conclusion seems too quick |
| "Is this always true?" | Generalization made |
| "What if that assumption is wrong?" | Testing robustness |
| "Why do we believe this?" | Basis unclear |
| "What would have to change for this to be false?" | Finding conditions |
Example:
"We need microservices for scale."
→ "What are we assuming about our scale requirements?"
→ "Is it always true that microservices scale better?"
→ "What if a modular monolith could meet our needs?"
3. Reason & Evidence Questions
Purpose: Examine the support for a claim
| Question | Use When |
|---|---|
| "What evidence supports this?" | Claim is asserted |
| "How do we know this?" | Source unclear |
| "Are there other explanations?" | Causation assumed |
| "What would prove this wrong?" | Testing falsifiability |
| "Is this evidence sufficient?" | Conclusion seems strong |
Example:
"Users don't want feature X."
→ "What evidence do we have for this?"
→ "How many users did we ask? How were they selected?"
→ "Could there be other explanations for the feedback?"
4. Perspective & Viewpoint Questions
Purpose: Consider alternative angles and stakeholders
| Question | Use When |
|---|---|
| "How would X see this?" | Single perspective dominates |
| "What's the opposite view?" | No alternatives considered |
| "Who disagrees, and why?" | Consensus seems too easy |
| "What are we not seeing?" | Blind spots suspected |
| "How does this look from [role]?" | Stakeholder impact unclear |
Example:
"This API design is intuitive."
→ "How would a new developer view this?"
→ "What would someone from a different language background expect?"
→ "Who might find this confusing, and why?"
5. Implication & Consequence Questions
Purpose: Explore downstream effects and logical conclusions
| Question | Use When |
|---|---|
| "What follows from this?" | Implications unexplored |
| "If this is true, what else must be true?" | Testing consistency |
| "What are the consequences?" | Impact unclear |
| "How does this affect X?" | Ripple effects not considered |
| "What are the second-order effects?" | Only immediate effects seen |
Example:
"We'll add this field to the API response."
→ "What follows from adding this field?"
→ "How does this affect clients that don't need it?"
→ "What are the implications for backward compatibility?"
6. Questions About the Question
Purpose: Reflect on the inquiry itself; meta-level examination
| Question | Use When |
|---|---|
| "Why is this question important?" | Purpose unclear |
| "What would answering this tell us?" | Value of question unclear |
| "Is this the right question?" | May be missing the point |
| "What question should we be asking?" | Reframing needed |
| "Why are we asking this now?" | Timing or priority unclear |
Example:
"Which database should we use?"
→ "Why is this question important right now?"
→ "What would answering this tell us that we don't know?"
→ "Is the real question about database, or about data modeling?"
Application Patterns
For Requirements Gathering
Stakeholder: "We need a dashboard."
Clarification: "What decisions will the dashboard help you make?"
Assumptions: "What are we assuming about who will use this?"
Evidence: "What data shows this is the highest priority?"
Perspective: "How do different user roles need different views?"
Implications: "If we build this, what won't we build?"
Meta: "Is a dashboard the best solution, or is there another approach?"For Debugging
Report: "The system is slow."
Clarification: "Which operations are slow? How slow?"
Assumptions: "What are we assuming about where the bottleneck is?"
Evidence: "What metrics/traces support this?"
Perspective: "Is it slow for all users or specific patterns?"
Implications: "If we fix this, what else might change?"
Meta: "Is 'slow' the right frame? Could it be 'inconsistent'?"For Design Review
Proposal: "We should use event sourcing."
Clarification: "What do you mean by event sourcing in this context?"
Assumptions: "What are we assuming about our query patterns?"
Evidence: "What evidence suggests this fits our use case?"
Perspective: "How would ops view this? New team members?"
Implications: "What are the consequences for debugging? Storage?"
Meta: "Is the real question about event sourcing or auditability?"Facilitation Tips
- Genuine curiosity: Ask because you want to understand, not to trap
- Follow the thread: Let answers guide next questions
- Comfortable silence: Allow time for reflection
- Non-judgmental tone: Questions should feel safe
- Build on answers: "That's interesting. Can you say more about..."
- Admit ignorance: "I don't understand. Help me see..."
Verification Checklist
- [ ] Used questions from at least 3 of the 6 categories
- [ ] Probed assumptions underlying the topic
- [ ] Explored at least one alternative perspective
- [ ] Examined implications and consequences
- [ ] Reached deeper understanding than starting point
- [ ] Documented key insights from questioning
Key Meta-Questions
- "What do I think I know, and how do I know it?"
- "What question am I not asking?"
- "What would change my mind about this?"
- "Who knows more about this than I do?"
- "What's the question behind the question?"
Socrates' Reminder
"I know that I know nothing."
The goal is not to prove others wrong but to discover truth together. The best questions reveal what everyone—including the questioner—doesn't yet understand.
Related skills
How it compares
Use thinking-socratic for pre-build requirement clarification; use brainstorming or planning skills when the problem is defined but the solution space still needs exploration.
FAQ
When should thinking-socratic run in a coding workflow?
thinking-socratic should run before building or committing when a request is vague, assumption-laden, or solution-first. The skill asks one or two load-bearing clarifying questions instead of guessing missing requirements, and stops once the spec is settled.
What question types does thinking-socratic cover?
thinking-socratic organizes questions into six types: clarification, assumption-probing, reason and evidence, perspective and viewpoint, implication and consequence, and meta-questions about the question itself. Each type includes example prompts for requirements, debugging, and
When should developers skip thinking-socratic?
Developers should skip thinking-socratic when the task is already well specified, ambiguity is resolvable by reading code or docs, or execution is underway on an agreed plan. The skill is pre-build clarification, not mid-task interrogation.