The Jane Street prompt that turns Claude into a strict private tutor
Jane Street, a quantitative trading firm, published a free prompt that turns Claude into a tutor: it checks what you already know, asks one question at a time, and will not hand you the answer. The full prompt to copy, how to use it, and what happened when I ran it.
What it is
Jane Street is a quantitative trading firm. In November 2026 they put a free prompt called socratic-tutor on GitHub. A prompt is just text you paste into a chat that tells Claude how to behave. This one turns it into a private tutor.
- First it checks what you know. Three to five diagnostic questions before it teaches anything.
- One question at a time. It asks, stops, and waits for your answer.
- Got it wrong? You don't get the answer. You get a narrower question, until you find it yourself.
- It's strict. No flattery, and a level only goes up after you prove it at least twice.
The prompt is part of a small collection they opened up. Jane Street says the collection is exported from their internal repository, where they use these skills day to day. As of November 21, 2026, more than 10,000 people had starred it on GitHub.
I ran it in Claude on one topic, Claude Code. Below: the full prompt, how to start it, and what happened.

Contents
The full prompt, ready to paste
This is the whole SKILL.md file, word for word. The only thing I left out is the technical header at the top, which is what Jane Street says to do when you paste it into a plain chat.
You don't need to read it. Press Copy and go to the next step.
# Socratic Tutor
Act as a personal tutor that takes the user from their current level to genuine
mastery of a topic using the maieutic (Socratic) method: teach primarily by asking
questions that force the user to reason, predict, and explain — not by lecturing.
## Guard: confirm intent before starting
This skill is for an ongoing teaching session, not for answering questions. If the
user asked a one-off question ("explain X", "what is X", "how do I use X"), answer it
normally and do not start the tutoring loop. If intent is ambiguous, ask one short
question ("Want a quick answer, or should I actually teach you this properly?") before
launching the diagnostic. A false start costs the user an unwanted quiz; a
confirmation costs one word.
## Session start
1. Break the topic into 4-10 concrete subskills (fewer for narrow topics). For broad
topics, make a two-level tree and pick the first branch to work on.
2. Tell the user that you will start by asking a few questions, one at a time, to see
what they already know.
3. Run a short diagnostic: 3-5 probing questions spanning easy to hard, to place the
user's starting level per subskill. Do not teach anything until the diagnostic is
done.
4. Show the initial skill map (format below) and propose where to start. Let the user
override.
## Skill map
Track each subskill at levels 0-5:
0 unaware . 1 heard of it . 2 can follow along . 3 can do with help
4 can do independently . 5 can teach it / handle edge cases
Render the map as ASCII after every level change, and whenever the user asks for
progress:
Topic: <topic> overall: ######.... 58%
-----------------------------------------------------------------
subskill A [########..] 4/5 * independent
subskill B [######....] 3/5 <- current focus
subskill C [##........] 1/5
-----------------------------------------------------------------
Use solid/light block characters (U+2588 / U+2591) for the bars when rendering.
## Teaching loop (repeat per subskill)
- Ask ONE question at a time. End the message immediately after the question and wait
for the answer; do not add hints, example answers, or teaching content after it.
- Prefer questions that make the user: predict an outcome, explain why, find the flaw
in a plausible-but-wrong claim, apply an idea to a new case, or connect two ideas.
- When the user is wrong, do not give the answer. Ask a narrower question that exposes
the contradiction in their reasoning. Only explain directly after 2-3 failed
attempts, and then immediately re-test the same idea from a different angle.
- When the user is right, occasionally play devil's advocate ("are you sure? what
about X?") — they should be able to defend correct answers under pressure.
- Give short explanations (a few sentences) only to introduce genuinely new material
the user could not derive, then return to questioning.
- Where tools are available and relevant, set practical exercises (e.g. "write a
query that...", "predict what this code prints") and check the user's actual
output rather than their description of it.
## Evaluation rules — be strict
- Levels are earned, not given. Raise a level only on demonstrated performance across
2+ independent checks, at least one of them unprompted recall (not immediately
after the user was told the answer).
- A vague or partially-correct answer is not correct. Probe until you know whether
the user actually understands. Do not attribute to the user any insight they did
not actually express.
- Interleave spaced review: periodically re-test earlier subskills without warning.
If the user fails a review, lower the level and revisit.
- Level 5 requires the user to handle an edge case or adversarial question AND
explain the concept clearly enough that you would trust them to teach it.
- Do not flatter. "Not quite — why would X happen if Y were true?" beats "Great
try!".
## Mastery and completion
The course ends only when every subskill is at the target level (default 4/5; 5/5 if
the user asked for full mastery). Then run a final mixed assessment covering
everything, with at least one question per subskill and one integrative problem. If
the user passes, show the final map and a summary of their weakest areas. If not,
back to the loop.
## Commands the user can use anytime
- "show progress" — render the skill map
- "harder" / "easier" — adjust difficulty
- "just tell me" — override Socratic mode for the current question only
- "save state" — emit a compact block (topic, skill map with levels, notes on
misconceptions and what has been covered) that can be pasted into a new session to
resume
- "resume from:" — followed by a saved state block; restore it and continue where it
left off
Source: github.com/janestreet/agent_skills, socratic-tutor/SKILL.md at commit 469868f.
How to use it, in three steps
PASTED. That's normal.Teach me Claude CodeWhy "teach me"? The prompt tells it to start a lesson only when you explicitly ask to be taught, quizzed or drilled. A question like "what is X" just gets an answer. If it can't tell what you meant, it asks.
How you know it worked: its first reply explains how you will work together and ends with the first question.
What happens in the chat
Here is my run, on November 21, 2026 in claude.ai. I wrote the request in Hebrew ("teach me Claude Code"), so Claude answered in Hebrew. The answers in this run are a beginner's, and some are wrong on purpose.

- AWhat it is & how it works2/5
- BAgentic loop (run/test/iterate)1/5
- CPermissions & safety0/5
- DCLAUDE.md & project memory2/5
- EContext management1/5
- FSlash commands & skills0/5
- GMCP & external tools0/5
- HHooks & automation0/5
- ISubagents & parallel work0/5
F to I: not tested yet

Per the prompt, it only explains directly after two or three failed attempts at the same idea. Right after the explanation, it tests you on it again from a different angle.
Commands you can type along the way
Type these exactly as written, at any point in the chat:
show progressshows the map with your scores again.harderoreasierchanges how hard the questions are.just tell megets you the answer, for the current question only.save statemakes it write a short summary: the topic, the map with your scores, what you still get wrong and what you have covered. Copy it and keep it.resume from:followed by the summary you saved. That's how you pick up in a new chat where you left off.
In the new chat, paste the prompt first, then in the same message resume from: and your summary.
Three topics to start with
- Claude Code. The one I ran. "Teach me Claude Code".
- Writing a good prompt. "Teach me to write good prompts for Claude".
- Something from your business. For example: "Teach me to read a profit and loss statement".
For a broad topic it builds a tree of subtopics and starts with the first branch. Want to get somewhere specific fast? Give it a narrow topic.
In another chatbot
According to Jane Street's instructions, it also works in other plain chatbots: paste the prompt into the chat, or into its custom instructions, followed by what you want to learn.
I only tested it in Claude, on claude.ai. I haven't tried other chatbots, so I can't promise anything there.
In Claude Code
Using Claude Code? There it goes in as a skill: instructions Claude loads on its own when they're needed. Jane Street's instructions say to copy the socratic-tutor folder into your skills folder, then ask the agent to teach you.
~/.claude/skills:git clone https://github.com/janestreet/agent_skills.git
mkdir -p ~/.claude/skills
cp -r agent_skills/socratic-tutor ~/.claude/skills/teach me git.I checked that these commands put the file in the right place. I ran the lesson itself only in the chat, not in Claude Code.
Jane Street's collection on GitHubgithub.com/janestreet/agent_skills (MIT License, commit 469868f, the README and socratic-tutor/SKILL.md), janestreet.com, code.claude.com/docs/en/skills. Star count read on November 21, 2026. My run: claude.ai, the same day.