Socratic

Socratic

Meta - questioning about questioning. Question yourself till you're left with only answers.

Socratic is a self-interrogation skill for agentic AI, packaged as a portable Claude and Codex skill or prompt.

It helps an LLM slow down, inspect the task, ask itself the right engineering questions, and only ask the user for the few decisions that actually require human authority.

Two halves work together:

• 697 questions across 15 engineering domains — what a task must resolve
• 60 decision cards in 10 source-backed packs — how experienced engineers resolve it, distilled from Kleppmann, Nygard, Evans, Ousterhout, Feathers, Khorikov, and others

Neither is loaded whole. The agent selects the slice the task actually signals, so a typical run costs about 3,000 tokens.

Not a form. Not a checklist. A lightweight reasoning loop.

The stopping rule: question until the answer is solid

Socratic is not a 697-question checklist and it is not an endless reasoning loop. It asks the smallest set of relevant questions needed to reach a solid, evidence-backed answer.

The agent stops expanding its review when the outcome and scope are clear, consequential assumptions are visible, material risks have a mitigation or verification path, no contradiction changes the plan, and the riskiest assumption can be tested proportionately. If the next question would not change the design, risk, cost, authority decision, or verification plan, it is no longer material.

This is the purpose of self-interrogation: let an agent challenge its own plan from several useful directions, satisfy the meaningful uncertainty, and then build. It should never keep thinking merely to consume tokens, nor stop only because a token budget is low.

How it actually works

The agent interviews itself, not you. Point it at a task, and it silently works through the relevant slice of the question bank — reading the codebase where it can, applying sensible engineering defaults where it can't, and only stopping to ask you about the handful of decisions that are genuinely yours to make (budget, vendor, legal risk, an irreversible call).

What you see is a short contract before any code is written:

Domains considered:      requirements, data, security, testing, AI/LLM
Self-answered:           Postgres over SQLite (existing driver, concurrent writers)
                         at-least-once delivery; duplicate work is safe here
                         no PII in the queue, so no encryption-at-rest work
Assumed (flag if wrong): single-region; retries capped at 5
Open questions for you:  1. Is a 30-second worst-case job latency acceptable?
Top risks:               retry storm on downstream outage — no circuit breaker yet
Plan:                    durable enqueue → worker drain → backoff on failure

One question instead of twelve. The other eleven were answered from your repo.

The loop behind it:

1. classify the task
2. detect the relevant domains
3. load the smallest useful question set
4. self-interrogate silently
5. surface assumptions, risks, and only necessary open questions
6. build
7. verify

If you'd rather be interviewed live, ask for it ("interview me," "ask me one at a time") and it switches to a one-yes/no-question-per-turn mode instead. That's opt-in, not the default.