socrates-skill: a Claude Code skill that refuses to answer you

The skill for people who keep asking Claude for the answer

Most Claude Code sessions end the same way: you paste a function, ask why it returns null, and get a paragraph of explanation. That is fine when you want the answer. It is useless when you are trying to build a mental model of a codebase you have to maintain next quarter, because reading someone else's explanation produces recognition, not understanding.

socrates-skill inverts the interaction. The README states the rule plainly: the agent never gives a direct answer, even if you ask for one. Instead it runs a questioning loop until you have described the thing yourself. The intended user is someone with a knowledge asset in front of them (source code, a Markdown or PDF document, API documentation, a configuration file, an architecture diagram) and enough time to be questioned about it. It is a study aid, not a debugging aid.

Five stages, one refusal: the mechanism behind the questioning

The README describes a five-step workflow. The agent first reads the target resource silently. It then asks an opening question to gauge your current understanding. From there it moves through progressively deeper questions, which the README labels clarifying, probing, connecting, counter and hypothetical. It adapts to your responses by simplifying, deepening or redirecting. The loop closes when it asks you to summarize your understanding.

Two design choices stand out. The first is that the read step is silent, so the agent is not narrating its way through your file before the first question. The second is adaptation: the question type is a function of your previous answer, not a fixed script. That is also where the skill is least transparent. The README names the five question categories but does not show the prompts that implement them, so the actual difficulty curve depends on SKILL.md, which is one of the three files at the repository root alongside LICENSE and README.md. Anyone evaluating this should read SKILL.md rather than the README.

Language handling is automatic. The README says the agent detects and responds in whatever language you write in, and the trigger table includes a Korean keyword (소크라테스) as an example.

Installing the skill and running a first Socratic session

The README gives a single quick-install command through the skills CLI:

npx skills add RoundTable02/socrates-skill

Two alternatives are listed for people who do not want to use npx. Claude Code has its own installer:

claude install-skill RoundTable02/socrates-skill

Or clone the repository directly into the Claude skills directory:

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

Note the path mismatch worth checking after install: the clone target is ~/.claude/skills/socrates, while the install commands reference the RoundTable02/socrates-skill repository. Do not assume the directory name the skill expects without looking at SKILL.md.

The skill activates on keywords rather than a slash command. The README lists Socrates, socratic and 소크라테스 as triggers. A first real use, copied from the README's examples:

Socratic: help me understand the authentication flow in this codebase

What you should see is not an explanation of the auth flow. You should see a question about what you already believe the auth flow does. Answer it and the next question follows. If you get a direct answer instead, the skill did not load, and the install path is the first thing to check.

Where the refusal rule becomes a problem

The core rule is also the main limitation. If you ask for the answer, you will not get it, and there is no documented override. The README does not describe a way to disable Socratic mode mid-session, so the practical escape hatch is to start a session without the trigger keywords and ask normally. That is a workaround, not a feature, and it is worth knowing before you install.

There are cases where this is simply the wrong tool. A production incident, a stack trace you need decoded, a library API you have never seen: all of these want a direct answer, and being questioned about your assumptions costs minutes you may not have. The skill also assumes you have something to be questioned about. If you are learning a topic from nothing, a Socratic loop over an empty mental model produces frustrated guessing rather than insight. It works best when you have partial understanding and need it tested.

One more constraint: the README says it works with any readable content, including PDF and DOCX. It does not describe how those formats are parsed or what happens when a file is too large for the context window. Treat the format list as a claim to verify on your own documents.

How socrates-skill differs from a Claude Code tutor prompt

The obvious alternative is not another repository. It is a system prompt you write yourself: paste a paragraph into Claude Code telling it to ask questions instead of answering, and you have most of the behaviour. The difference is packaging and persistence. A prompt lives in the session where you typed it. socrates-skill is an Agent Skills package installed into ~/.claude/skills, so it is available across projects and triggers on keywords rather than on you remembering to paste anything.

The second difference is the workflow. A hand-written prompt usually says ask questions. This skill specifies five stages and five question types, plus an adaptation step and a closing summarization step. Whether that structure produces better questions than a good one-line prompt is not something the README demonstrates, and it is the thing to judge by reading SKILL.md.

If what you actually want is explanation rather than interrogation, a plain Claude Code session or a documentation-focused skill is the better fit. This one is deliberately unhelpful in the conventional sense.

Maintenance, licence and what you are actually taking on

The repository is MIT licensed, so you can copy, modify and redistribute it, including in commercial settings, provided the licence text travels with it. That is a permissive arrangement and the practical implication is that forking the skill to change the question prompts is allowed. This is not legal advice; read the LICENSE file at the repository root for the actual terms.

The maintenance picture is thin. There are no releases, so installation is always from the repository's main branch, and there is no version to pin. The last push was on 2026-04-02, which is more than six months before today. Nothing in the repository indicates whether that reflects a finished, stable skill or an abandoned one. Practically, that means upgrades are pulls rather than version bumps, and any local edits you make to SKILL.md will conflict with them. If you customize the prompts, keep your changes in a fork rather than in the installed directory.

Editorial conclusion

Adopt socrates-skill if you want the agent to withhold answers and push you to articulate your own understanding of a codebase, document or paper, and if you can accept that it will not give you the answer even when you ask directly. Do not adopt it when you need a fix, a summary or an explanation on a deadline; a normal Claude Code session is the right tool there. Before installing, read SKILL.md to see the actual question sequence, because the README only names the five stages and does not show the prompts behind them.

Frequently asked questions

Official sources

1. bevibing/socrates-skill on GitHub
2. Issues
3. License: MIT
4. README