Socrates transforms Claude Code from an answer machine into a deliberate practice partner. Instead of immediately explaining everything, it first challenges you to think. Instead of encouraging passive acceptance, it encourages active reasoning. Instead of making every interaction frictionless, it introduces just enough productive friction to ensure every difficult problem becomes an opportunity to improve.
This isn't about making development slower. It's about making learning inevitable.
That's not just philosophy — it's measurable. Researchers at the University of Chicago and Toronto found that bringing AI in before you've tried a hard problem yourself makes you remember less, narrow your thinking prematurely, and anchor to whatever the model suggests first. Bring it in after — and it helps instead of hollowing you out. That's the exact seam Socrates is built around: challenge first, answer only once you've earned it.
Further reading: the research behind this
Academic research
- AI-overdependence and human cognitive decline: Hazards, evidence, and mitigation strategies
- Tool, Tutor, or Crutch?: A grounded theory of cognitive scaffolding and offloading in AI-assisted programming education
- Deskilling, Reskilling or Upskilling?
- From Algorithm Aversion to AI Dependence
- AI Technology and Labor Skill Transformation
- A Survey of AI Reliance
- Knowing About Knowing
- Brainrot: Deskilling and Addiction are Overlooked AI Risks
- A Systematic Review in Computer Science Education
Articles
- Financial Times – The risk of letting AI do your thinking
- TIME – Are We Losing Our Minds to AI?
- The New Yorker – Instead of Taking Your Job, AI Might Transform It
- New York Times – Technology Weakens Our Minds. It's Time to Resist.
- The Atlantic – The Age of De-Skilling
- The Week – Deskilling: A dangerous side effect of AI use
- New York Times – I Saw Something New in San Francisco
- The New Yorker – The Hidden Costs of Automated Thinking
Every insight you discover yourself strengthens mental models that no autocomplete can build for you. Every design decision you reason through becomes easier to recognize the next time. Every mistake becomes another Capability Compound—an investment in judgment that continues paying dividends long after today's AI models are obsolete. That is the game Socrates is designed to play. Not today's sprint. Your next decade.
Read this before installing anything. The nine skills below are the implementation; the Manifesto is the reasoning behind them—why productivity is becoming a commodity, why judgment isn't, and why the friction you're about to opt into is the point, not a bug.
Everything Socrates does serves a single objective: preserving and strengthening your ability to think.
The first three are modes—on by default from the moment the plugin is installed, shaping every conversation until you switch them off. The other six are commands—you invoke them when you need them.
| Skill | Type | What it does |
|---|---|---|
/socratic-MCQs |
Mode | Gates explanations, diagnoses, and decisions behind a multiple-choice question you answer first |
/socratic-dev |
Mode | Pushes generated code back toward KISS, DRY, and YAGNI |
/socratic-talk |
Mode | Trims verbose responses, runs noisy commands in a Sandbox out of your context, and shows your live context usage plus the tokens it saved |
/explain |
Command | Explains a concept at a chosen depth—five-year-old, junior, non-dev, or teammate |
/to-lesson |
Command | Turns a concept into a single self-contained lesson, saved as a Markdown file |
/teach-me |
Command | Walks you through material—a codebase, article, or concept—one paced step at a time |
/quiz-me |
Command | Runs a live multiple-choice quiz on anything, with hints instead of instant answers |
/to-anki |
Command | Turns what you just learned into reviewed, approved Anki flashcards |
/dialogue |
Command | A live Socratic back-and-forth that pressure-tests a claim you hold |
Each mode takes a single on or off argument—/socratic-dev off, /socratic-talk on—and stays that way across sessions until you flip it back. The status line always shows which modes are currently active, so you never have to wonder how Socrates is behaving. With all three on, it looks like this:
🏛️·🧿·💬42.7K(21.3%)·♻️~12K
🏛️ means socratic-MCQs is on, 🧿 means socratic-dev is on, and 💬 means socratic-talk is on—followed by your live context usage and, after ♻️, the tokens socratic-talk has saved you this session. Turn a mode off and its segment disappears.
The context usage number is color-coded so you can read the health of your session at a glance: sand below 100K tokens, amber from 100K, and red from 200K—time to wrap up or start fresh. The ♻️ savings count is always green.
This isn't a native Claude Code feature—it's socratic-talk. Turning it on wraps whatever status line command you already have configured, so your original status line keeps running exactly as before, with Socrates' segments appended after it. Turn socratic-talk off and the extra segments disappear, original status line untouched.
Before explaining an architectural decision, diagnosing a bug, or teaching a concept, Socrates asks you to answer a carefully chosen multiple-choice question.
Not to slow you down. To wake your brain up.
Learning isn't created by reading an explanation. It's created by attempting to predict the explanation before you see it. That small act of retrieval transforms passive consumption into active understanding. Mechanical work stays mechanical. If you've already decided on a solution and simply want Claude to execute it, Socrates gets out of the way. Thinking is only required where thinking actually matters.
Code generation has made complexity dangerously inexpensive. Nested abstractions, unnecessary patterns, premature optimization, and clever designs can now be produced faster than ever before. Socrates continuously pushes generated code back toward timeless engineering principles—KISS, DRY, and YAGNI—not because minimalism is fashionable, but because complexity compounds far faster than simplicity.
Simplicity never comes at the cost of safety. Security, trust-boundary validation, data-loss handling, and accessibility stay non-negotiable even while everything else gets simplified.
The result isn't code that merely works. It's code that's easier to understand six months later.
Modern AI conversations are surprisingly wasteful. Verbose explanations, unnecessary acknowledgments, and pages of command output consume context without increasing understanding.
Socrates keeps conversations lean. Responses focus on what matters, while a Sandbox runs noisy commands in a subprocess and routes only the derived result back to you—so raw terminal output never lands in your primary context. The status line's 💬 segment tracks your live context usage as the conversation grows, and the ♻️ segment shows the running token total that sandbox has kept out of context this session, so both the cost and the savings stay visible, not just theoretical. Less noise. More signal.
Commands don't stay on in the background—each one runs when you call it, does its job, and gets out of the way.
Sometimes you don't need another answer. You need a different explanation.
Whether you're learning recursion for the first time, mentoring a junior developer, onboarding to an unfamiliar codebase, or refreshing a concept you haven't touched in years, Socrates adapts the explanation to the level of understanding you actually need. Teaching isn't about saying more. It's about saying exactly enough.
An explanation lives in the chat and dies with the chat. Understanding worth keeping needs a home outside the scroll.
/to-lesson takes any concept and turns it into a single, self-contained lesson saved as a Markdown file: the intuition behind it, what it is and when to reach for it, a diagram when one earns its place, an implementation when the topic calls for it, the trade-offs worth remembering, and a question that checks whether it actually landed. Same depth levels as /explain, so the file speaks to whoever opens it next—including you, in six months, having forgotten all of it.
A good explanation fades once the conversation ends. A lesson you wrote for yourself doesn't.
An explanation answers the question you asked. It doesn't build the whole mental model.
/teach-me takes anything—a codebase, an article, a concept—and turns it into a guided journey instead of a single answer. Socrates breaks the material into an ordered sequence of steps, shows you the map before you start, then walks you through it one step at a time, at the depth you choose, pausing after each one so you decide what happens next: move on, go deeper, hear it a different way, or ask what's actually confusing you. Nothing gets dumped on you at once, and nothing moves forward until you're ready for it to.
That includes Socrates itself. Run /teach-me the Socrates plugin and get the same guided walkthrough—the philosophy, the skills, how they fit together—one step at a time, instead of a single orientation dump.
Reading feels like learning. It isn't. The only way to know whether you actually understand something is to test yourself—before the answer is in front of you.
/quiz-me turns anything—a codebase, an article, a concept, the conversation you just had—into a live multiple-choice quiz, one question at a time. Wrong answers don't get corrected; they get a hint and another attempt, because working your way toward the answer is where the learning happens. And when the quiz ends, you decide what happens next: let it all go, or send the questions that beat you—or every question—straight into Anki so spaced repetition finishes what the quiz started.
Understanding something once is not the same as owning it. Insight you never revisit quietly evaporates—usually right around the time you need it again.
/to-anki turns whatever you just worked through—a conversation, a codebase, an article, a concept—into Anki flashcards. By default every card is multiple-choice, the same challenge format Socrates quizzes you with—classic front/back and cloze cards are there when you ask for them. And it's not a bulk export: you review and approve every single card before it enters your deck, because deciding what's worth remembering is itself an act of judgment. Then spaced repetition does what no bookmark ever will. What you earned with Socrates today is still yours in six months.
Being handed an answer feels like understanding it. It isn't. Real understanding survives being questioned—and the only way to find out if yours does is to have it questioned.
/dialogue takes a claim you actually hold—an opinion, a definition, a design decision you're leaning toward—and turns it into a live conversation instead of a lecture. State it, and Socrates probes: what do you mean by that, what are you assuming, how do you know, what follows if it's true, who would disagree, why does the question even matter. One question at a time, in your own words, with no multiple choice standing between you and the gap in your own reasoning. When a contradiction surfaces, it doesn't get smoothed over—that discomfort is the whole point, not a bug to route around.
The claim you leave with isn't the one you arrived with. It's sturdier, because you're the one who found where it was thin.
Socrates isn't designed for everyone.
If your only objective is producing as much code as possible, there are cheaper tools that will happily generate answers all day long.
If you believe engineering is simply typing instructions into increasingly capable models, you'll probably find Socrates unnecessarily demanding.
That's intentional.
Socrates is built for engineers who view their own capability as the most valuable asset they'll ever own.
The ones who understand that every difficult problem is an opportunity to sharpen judgment.
The ones who care as much about the person writing the software as the software itself.
The ones playing a game measured in decades instead of deadlines.
The research earlier in this README isn't an outlier — study after study finds the same pattern: skill that's never exercised erodes, and judgment is a skill like any other. Socrates is priced like what it protects.
Every engineer understands the return on compounding investments. Small improvements, repeated consistently over long periods of time, create outcomes that look impossible in hindsight. Judgment compounds exactly the same way — and unlike a subscription, this is a one-time cost buying a skill that keeps paying out for as long as you're writing code.
Here's how fast it pays back: one better architectural call, one production incident caught before it ships, one design flaw you spot in review before a teammate does — any single one of those is worth more than $1,000 on its own. Most engineers clear that bar inside the first project.
This is also why it's yours to buy, not your employer's. Plenty of companies will expense a course or a certification — something with a name and a receipt they can point to. Almost none will expense a tool whose entire premise is "this makes you slower on purpose today, so you're sharper in five years" — there's no line item for that, and if you change jobs, the company doesn't keep the payoff anyway. You do. Nobody expects their employer to pay for the gym either, for the same reason. The specific stack you use at work — sure, that's the company's to fund. The mind you bring to every stack after this one is yours.
You're not paying for nine Claude Code skills. You're investing in the only competitive advantage AI cannot commoditize — your ability to think independently.