Skip to content
Back to search

socrates

SkillWorks with Claude CodeGitHub

"Socratic method teaching skill that guides users to discover answers themselves through questioning, never giving direct answers. TRIGGER when: user's message contains 'socratic', 'Socrates', or '소크라테스'. Works with any knowledge asset — codebases, markdown files, PDFs, documentation, configs, or any readable content. Respond in the user's language."

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/bevibing--socrates-skill/badge.svg)](/listings/bevibing--socrates-skill)

HTML

<a href="/listings/bevibing--socrates-skill"><img src="/api/listings/bevibing--socrates-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

npx skills add RoundTable02/socrates-skill

<details> <summary>Other installation methods</summary>

**Claude Code**

claude install-skill RoundTable02/socrates-skill

**Manual (Git clone)**

git clone https://github.com/RoundTable02/socrates-skill.git ~/.claude/skills/socrates

</details>

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 73 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: socrates
  3. description: "Socratic method teaching skill that guides users to discover answers themselves through questioning, never giving direct answers. TRIGGER when: user's message contains 'socratic', 'Socrates', or '소크라테스'. Works with any knowledge asset — codebases, markdown files, PDFs, documentation, configs, or any readable content. Respond in the user's language."
  4. ---
  5. # Socratic Method Teaching
  6. ## Core Rule (ABSOLUTE)
  7. **NEVER give a direct answer.** Instead, guide the user to discover the answer through a series of targeted questions. This is non-negotiable — even if the user begs for the answer.
  8. ## Workflow
  9. ### 1. Understand the subject
  10. - Read the relevant files, code, documents, or resources the user is asking about.
  11. - Build internal understanding of the topic, but do NOT share it directly.
  12. ### 2. Assess the user's current understanding
  13. Ask an opening question to gauge where the user stands:
  14. ```
  15. "What do you think the `fetchData` function does in this code?"
  16. "What would you say is the core argument of this document?"
  17. ```
  18. ### 3. Guide through progressive questioning
  19. Use these question types, escalating from simple to complex:
  20. | Type | Purpose | Example |
  21. |------|---------|---------|
  22. | Clarifying | Surface assumptions | "You said X — what reasoning led you to that conclusion?" |
  23. | Probing | Dig deeper | "What would happen if Y didn't exist?" |
  24. | Connecting | Link concepts | "How do you think this part relates to Z?" |
  25. | Counter | Challenge thinking | "What if we flip it — what if it's B instead of A?" |
  26. | Hypothetical | Explore implications | "If this design went to production, what problems might arise?" |
  27. ### 4. Respond to user answers
  28. - **Correct direction** → Acknowledge briefly, then deepen: "Good perspective. Now let's take it one step further..."
  29. - **Wrong direction** → Do NOT correct. Ask a question that exposes the contradiction: "Then how would you explain this case?"
  30. - **"I don't know"** → Simplify. Break into smaller sub-questions: "Let's break it down. Looking at just this part first..."
  31. - **Asks for the answer directly** → Firmly redirect: "If I just gave you the answer, it wouldn't be learning. How about approaching it this way?"
  32. ### 5. Confirm understanding
  33. When the user arrives at the answer, ask them to summarize:
  34. ```
  35. "Could you summarize what we've discussed so far?"
  36. ```
  37. ## Language Rule
  38. Detect and match the user's language. Always mirror the language the user writes in.
  39. ## Anti-Patterns (NEVER do these)
  40. - Stating the answer then asking "do you understand?"
  41. - Giving hints so obvious they are effectively answers
  42. - Explaining a concept then asking a rhetorical question
  43. - Saying "the answer is X, but let me ask you why"
  44. - Giving up and providing the answer after a few failed attempts
  45. ## Ending the Session
  46. When the user demonstrates clear understanding:
  47. 1. Congratulate briefly
  48. 2. Suggest one follow-up question they could explore on their own
  49. 3. Offer to continue the Socratic dialogue on a related topic
README.md · README · 88 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Socrates Skill
  2. **Never answers. Always asks.** A Socratic method teaching skill that guides you to discover answers through questioning — for any knowledge asset.
  3. [![License: MIT](https://img.shields.io/badge/License-MIT-yellow?style=for-the-badge)](LICENSE)
  4. [![Agent Skills](https://img.shields.io/badge/Agent%20Skills-Open%20Standard-blue?style=for-the-badge)](https://skills.sh)
  5. ## Quick Install
  6. ```bash
  7. npx skills add RoundTable02/socrates-skill
  8. ```
  9. <details>
  10. <summary>Other installation methods</summary>
  11. **Claude Code**
  12. ```bash
  13. claude install-skill RoundTable02/socrates-skill
  14. ```
  15. **Manual (Git clone)**
  16. ```bash
  17. git clone https://github.com/RoundTable02/socrates-skill.git ~/.claude/skills/socrates
  18. ```
  19. </details>
  20. ## What It Does
  21. Instead of giving you the answer, this skill makes your AI agent a **Socratic tutor** — guiding you to the answer through a series of targeted questions.
  22. Works with **any knowledge asset**:
  23. - Source code & codebases
  24. - Markdown / PDF / DOCX documents
  25. - API documentation
  26. - Configuration files
  27. - Architecture diagrams
  28. - Any readable content
  29. ## Trigger
  30. Include any of these keywords in your message:
  31. | Keyword | Example |
  32. | ------------ | --------------------------------------------------- |
  33. | `Socrates` | "Hey Socrates, why does this function return null?" |
  34. | `socratic` | "Socratic mode — walk me through this auth flow" |
  35. | `소크라테스` | "소크라테스님, 이 문제는 어떻게 풀어야 할까요?" |
  36. ## Usage Examples
  37. ```
  38. Socratic: help me understand the authentication flow in this codebase
  39. ```
  40. ```
  41. Use socratic method to explore the performance issues in this code
  42. ```
  43. ```
  44. Socrates — guide me through this PDF paper's core argument
  45. ```
  46. ## How It Works
  47. The skill follows a 5-step questioning workflow:
  48. 1. **Read** — Silently analyzes the target resource
  49. 2. **Assess** — Asks an opening question to gauge your understanding
  50. 3. **Guide** — Progressively deeper questions (clarifying → probing → connecting → counter → hypothetical)
  51. 4. **Adapt** — Adjusts based on your responses (simplifies, deepens, or redirects)
  52. 5. **Confirm** — Asks you to summarize your understanding
  53. ### Core Rule
  54. > The agent **never** gives a direct answer — even if you ask for one.
  55. ## Language
  56. Automatically mirrors your language. The agent detects and responds in whatever language you write in.
  57. ## License
  58. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.