When should you use it?
- You need to really understand a subject, such as SQL indexes, bond math or a new framework, rather than skim an explanation
- You notice that chat answers feel clear in the moment but are gone a day later
- A new hire or career changer wants a structured way to learn on their own time
Not for: Quick factual questions; the skill is built to stay out of the way for those; Topics where mistakes are dangerous and a qualified human teacher or supervisor is required; Anyone who wants a summary to read, since every step expects you to answer
What do you need, and what do you get?
You need
- A chat assistant or agent that can load a SKILL.md file, or a chat where you can paste a system prompt
- The topic you want to learn and, if you like, a target level
- Thirty minutes or more per session, plus the saved progress block between sessions
You get
- A short placement quiz and a starting progress map
- A text progress bar for each subskill that updates as levels change
- Surprise review questions on earlier material
- A final exam with a summary of your weakest areas
- A compact save block you can paste into a new chat to pick up later
How does it work, step by step?
- Install or paste the skillCopy the socratic-tutor folder into your agent's skills folder, or paste the text below into a custom instruction or the first message of a new chat.
- Ask to be taughtStart with a clear request such as 'teach me how database indexes work'. A plain question gets a plain answer instead of a course.
- Answer the placement questions honestlySkip nothing. The tutor uses these to decide where you start and which parts you can skip.
- Work through the loopReply to one question at a time. Say 'harder', 'easier' or 'just tell me' when you need to change pace.
- Save and resumeBefore you close the chat, ask it to save state, and paste that block into the next session to continue where you stopped.
The prompt
The original prompt by Jane Street Group (janestreet/agent_skills), word for word, with a link to where it was published. Below it is our adapted version with fill-in blanks, if you want it. Works in Claude, Claude Code, ChatGPT and others. Values in lime are placeholders.
Original prompt by Jane Street Group (janestreet/agent_skills)
---
name: "socratic-tutor"
description: "Structured Socratic tutoring when the user explicitly asks to be taught, quizzed, or drilled to mastery on a topic: diagnostic placement, a skill map with levels 0-5, spaced review, and a final assessment. Trigger phrases: 'teach me', 'tutor me', 'quiz me', 'drill me', 'help me master'. Not for one-off 'explain X' or 'what is X' questions."
---
# 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
Exactly as published by Jane Street Group (janestreet/agent_skills) in socratic-tutor skill (janestreet/agent_skills).
Our adapted version (optional)
Fill in the blanks (optional; the copied prompt uses your values)
Be my tutor for {topic}. My goal is {goal} and I can study {minutes} minutes at a time. First split the topic into a handful of parts and quiz me briefly to find my level in each, from 0 (never heard of it) to 5 (could teach it). Show the levels as a small text chart. Then teach mostly through questions, asking one per message and waiting for my reply. If I am wrong, ask an easier question that shows me the mistake instead of giving the answer. Only raise a level after I succeed twice, once without a recent hint. Re-test older parts now and then without warning. When I say 'save', give me a short block I can paste into a new chat to continue.
What can go wrong?
- The tutor is only as accurate as the model behind it. On technical or regulated subjects, check key facts against a trusted reference.
- Long sessions can push early material out of the chat's memory. Save state often and start fresh chats.
- Overriding with 'just tell me' too often turns it back into an ordinary chatbot and loses the benefit.
- Self-reported answers can be gamed. Where the topic allows it, ask for exercises the agent can actually run and check.
Our take
Most AI study help fails in the same way: the model explains beautifully, you nod along, and nothing stays. This skill fixes that by changing the assistant's job from explaining to examining. It is short, plain and opinionated, which is why we think it works. The rules about levels are the best part. A level only goes up after repeated success, at least once from memory, and surprise reviews can push it back down. That is how good human tutors behave, and it is rare to see it written down this clearly for a model. The guard at the top also matters, because a tutor that launches a quiz every time you ask a quick question would be uninstalled within a day. Two cautions. The model can still be wrong about the subject itself, so pair it with a trusted reference on anything technical, legal or medical. And it rewards patience, so it suits planned study sessions rather than a busy afternoon. In our dry run on spreadsheet lookup formulas, it placed the learner, asked one question per turn and refused to raise a level after one lucky answer.
Where the time goes back: Instead of rereading explanations that never stick, you spend study time answering targeted questions on exactly the parts you have not yet mastered, and you can stop and resume without starting over.
FAQ
Who made it and can I use it at work?
Does it work in a plain chatbot?
How does it decide I have mastered something?
Source and credit
The original prompt on this page is by Jane Street Group (janestreet/agent_skills), shown word for word with a link to where it was published. The summary, notes and adapted version are ours.
- Original
- socratic-tutor skill (janestreet/agent_skills)
- Creator
- janestreet
- Published on
- GitHub (janestreet/agent_skills)
- Original date
- Nov 3, 2026
- License
- MIT
- Originally for
- Custom agent
- AI dry run
- Nov 11, 2026: passed. Dry-run tested by our AI test agent on sample input. Guard held, one question per turn for 14 turns, no level raised on a single lucky answer, save and resume worked.
AI dry run on sample data; not run with live connected accounts. The playbooks.bot test agent filled the prompt with synthetic inputs, produced the output and checked it against the page's stated outputs and guardrails. - Verified
- Nov 11, 2026: source link resolves to the original, the credited creator published it, our excerpt or prompt matches it, and the license allows our use.
The original is licensed under the MIT License (Copyright (c) 2026 Jane Street Group, LLC). The original prompt above is reproduced under that license with its copyright notice; our adapted prompt and summary are our own wording.
Are you the creator? Claim or correct this page.