← Back to library

Learn any topic with a strict Socratic tutor skill

Jane Street published a small skills repository in November 2026 with one skill so far, a tutor that teaches by asking questions. It runs a placement quiz, draws a progress map, refuses to give answers until you have tried several times and grades strictly. The full skill is below under its MIT license.

  • OutcomeLoad Jane Street's open-source tutoring skill into Claude, ChatGPT or a coding agent so that when you ask to be taught something, it first tests what you already know, keeps a 0 to 5 level for each part of the topic, quizzes you one question at a time without handing over answers, re-tests older material by surprise, and only ends the course after a final mixed exam.
  • SetupMinutes
  • LevelStarter
  • Creditjanestreet
View original
Works with
ClaudeClaude CodeChatGPTGeminiCustom agent

Published Nov 11, 2026Updated Nov 11, 2026AI dry run on sample input: passed Nov 11, 2026Source verified Nov 11, 2026

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?

  1. 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.
  2. 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.
  3. Answer the placement questions honestlySkip nothing. The tutor uses these to decide where you start and which parts you can skip.
  4. Work through the loopReply to one question at a time. Say 'harder', 'easier' or 'just tell me' when you need to change pace.
  5. 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)

Word for wordby 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)

Adapted prompt3 variables
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?
Jane Street Group released it under the MIT License in its agent_skills repository on GitHub. MIT allows commercial use as long as the copyright notice travels with copies.
Does it work in a plain chatbot?
Yes. The repository's own instructions say you can paste the skill body into a chat or a custom prompt and then name the topic you want to learn.
How does it decide I have mastered something?
It raises a level only after you get it right on at least two separate checks, one of them from memory, and the default finish line is level 4 on every subskill.

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.

More in Career & Learning

All 37 Career & Learning playbooks →

Related playbooks

Career & LearningPrompt✓ AI dry run

Compare your project plan with its fastest possible timeline

Have an AI interview you task by task about a project you keep postponing, estimate how long each task would take with no waiting at all, set that beside your real schedule, name the three largest gaps and whether each comes from waiting, approvals, hesitation or genuine effort, and give you a one-page plan to close the largest gap this week.

Credit: AI Guides (@free_ai_guides)

Minutes
Career & LearningPrompt✓ AI dry run

Rehearse a negotiation against a counterpart who pushes back

Practice asking for a raise, a better rate or a refund against an AI that argues from the other side's real interests, then get a debrief on where you gave ground.

Credit: u/Ok_Negotiation_2587 on r/ChatGPTPromptGenius

Minutes
Career & LearningWorkflow✓ AI dry run

Write a literature review that can only cite your sources

Use a source-grounded notebook tool so every citation in your review points to a paper you uploaded, in author-year format.

Credit: u/Federal_Weekend_4278 on r/WritingWithAI

Under an hour
Career & LearningSkill✓ AI dry run

Run a literature review by chasing citations

Start from a few seed papers and have an agent expand the set through backward and forward citations, screen candidates, and refine the review in rounds.

Credit: u/ZS-Portfolio on r/AIToolBench

Under an hour