MCPInstall

socratic-questioning

Guide discovery through questioning techniques and pattern recognition for Clean Code, GoF design patterns, and architectural decisions. Use when coaching developers, facilitating design discussions, or helping teams discover solutions.

Installs
90
Last 24h
—
Trending rank
—
Security
Not audited

Install

Works with every agent the skills CLI supports.

npx skills add https://github.com/nickcrew/claude-cortex --skill socratic-questioning
  1. 01

    Install

    Run the command in your project. The CLI asks which agents to install for.

  2. 02

    Describe the task

    Ask your agent for something this skill covers. It loads socratic-questioning automatically when relevant.

  3. 03

    Review the result

    The agent follows the SKILL.md steps, scripts and references bundled with the skill.

SKILL.md

The instructions your agent reads when the skill is triggered.

Socratic Questioning

Guide developers toward discovery through strategic questioning rather than direct instruction. Covers Clean Code principles, GoF design patterns, and architectural trade-offs using progressive, level-adaptive questioning techniques.

When to Use This Skill

  • Coaching developers on Clean Code or design pattern concepts
  • Facilitating design discussions where the team needs to discover trade-offs
  • Helping developers identify code smells and refactoring opportunities
  • Teaching programming principles through guided discovery
  • Running code review sessions focused on learning, not just fixing

Quick Reference

ResourcePurposeLoad when
references/questioning-techniques.mdSocratic method for code, question types, scaffolding progressionStarting a discovery session
references/facilitation-patterns.mdClean Code discovery, GoF pattern recognition, trade-off explorationDiscussing specific patterns or principles

Workflow

Phase 1: Assess       → Determine learner level, goals, prior knowledge
Phase 2: Explore      → Lead discovery with layered questions
Phase 3: Consolidate  → Summarize insights, propose exercises, outline next steps

Phase 1: Assess

Before asking questions, understand the learner:

  1. Gauge level -- beginner (concrete observations), intermediate (pattern recognition), advanced (synthesis and application)
  2. Identify goals -- what does the learner want to understand or improve?
  3. Map prior knowledge -- what principles do they already apply?
  4. Choose strategy -- select questioning depth and scaffolding level

Phase 2: Explore

Lead discovery through layered questioning:

Core Progression

Observe  → "What do you notice about [specific aspect]?"
Analyze  → "Why might that be important?"
Abstract → "What principle could explain this?"
Apply    → "How would you apply this principle elsewhere?"

Principles

  • Ask, don't tell -- guide toward the insight, don't state it directly
  • Build incrementally -- each question builds on the previous answer
  • Validate discoveries -- confirm insights without judgment
  • Name after discovery -- only name a pattern/principle after the learner identifies the concept

Knowledge Revelation Timing

  • After discovery: "What you've discovered is called..."
  • Confirming: "Robert Martin describes this as..."
  • Contextualizing: "You'll see this principle at work when..."
  • Applying: "Try applying this to..."

Phase 3: Consolidate

Close the learning loop:

  1. Summarize -- have the learner articulate what they discovered
  2. Connect -- link the discovery to broader principles and patterns
  3. Practice -- propose an exercise that applies the new understanding
  4. Plan -- outline what to explore next based on gaps revealed

Session Types

SessionFocusFlow
Code ReviewApply Clean Code to existing codeObserve → Identify issues → Discover principles → Improve
Pattern DiscoveryRecognize GoF patterns in codeAnalyze behavior → Identify structure → Discover intent → Name pattern
Principle ApplicationApply learned principles to new scenariosPresent scenario → Recall principles → Apply → Validate

Understanding Checkpoints

Track learner progress through these milestones:

CheckpointEvidence
ObservationLearner identifies relevant code characteristics
Pattern recognitionLearner sees recurring structures or behaviors
Principle connectionLearner connects observations to programming principles
Application abilityLearner applies principles to new scenarios
Teaching abilityLearner can explain the principle to others

Anti-Patterns

  • Do not lecture -- if you're explaining more than asking, recalibrate
  • Do not reveal the answer before the learner has a chance to discover it
  • Do not ask leading questions that have only one acceptable answer
  • Do not skip levels -- ensure the learner has a solid foundation before advancing
  • Do not judge wrong answers -- redirect with a follow-up question instead

FAQ

What does the socratic-questioning skill do?

Guide discovery through questioning techniques and pattern recognition for Clean Code, GoF design patterns, and architectural decisions. Use when coaching developers, facilitating design discussions, or helping teams discover solutions.

How do I install socratic-questioning?

Run npx skills add https://github.com/nickcrew/claude-cortex --skill socratic-questioning in your project. The skills CLI detects the agents you use and copies the skill into the right folder. For Claude Code you can also place the skill folder at ~/.claude/skills/socratic-questioning/ (personal) or .claude/skills/socratic-questioning/ (project).

Which AI agents can use socratic-questioning?

Any agent that supports the open Agent Skills format (a folder with a SKILL.md file), including Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, Windsurf, Cline, OpenCode and more.

Is socratic-questioning safe to install?

No partner security audit is available yet. Skills can run commands and scripts, so read the SKILL.md and any bundled files before installing.

Who maintains socratic-questioning?

It is published by nickcrew in nickcrew/claude-cortex. It has 90 recorded installs.

More from nickcrew/claude-cortex

View all →

react-performance-optimization

nickcrew/claude-cortex

React performance optimization patterns using memoization, code splitting, and efficient rendering strategies. Use when optimizing slow React applications, reducing bundle size, or improving user experience with large datasets.

Frontend & Design1.9K installs

owasp-top-10

nickcrew/claude-cortex

OWASP Top 10 security vulnerabilities with detection and remediation patterns. Use when conducting security audits, implementing secure coding practices, or reviewing code for common security vulnerabilities.

Security758 installs

ui-design-aesthetics

nickcrew/claude-cortex

Generates high-quality, non-generic UI designs with a focus on performance, progressive disclosure, and distinctive aesthetics.

Frontend & Design358 installs

threat-modeling-techniques

nickcrew/claude-cortex

Threat modeling methodologies using STRIDE, attack trees, and risk assessment for proactive security analysis. Use when designing secure systems, conducting security reviews, or identifying potential attack vectors in applications.

Security357 installs

token-efficiency

nickcrew/claude-cortex

Compressed communication using symbols and abbreviations. Use when context is limited or brevity is needed.

228 installs

helm-chart-patterns

nickcrew/claude-cortex

Helm chart development patterns for packaging and deploying Kubernetes applications. Use when creating reusable Helm charts, managing multi-environment deployments, or building application catalogs for Kubernetes.

DevOps & Cloud179 installs

Popular code quality & workflow skills

View category →

grill-me

mattpocock/skills

A relentless interview to sharpen a plan or design.

Scan a codebase for deepening opportunities, present them as a visual HTML report, then grill through whichever one you pick.

handoff

mattpocock/skills

Compact the current conversation into a handoff document for another agent to pick up.

domain-modeling

mattpocock/skills

Build and sharpen a project's domain model. Use when discussing codebase terminology, writing or editing a GLOSSARY.md, or recording or editing an ADR.

codebase-design

mattpocock/skills

Shared vocabulary for designing deep modules. Use when the user wants to design or improve a module's interface, find deepening opportunities, decide where a seam goes, make code more testable or AI-navigable, or when another skill needs the deep-module vocabulary.

diagnosing-bugs

mattpocock/skills

Diagnosis loop for hard bugs and performance regressions. Use when the user says "diagnose"/"debug this", or reports something broken/throwing/failing/slow.