Maieutic Prompting: 4 Recipes That Ship (2026)

Quick Answer

Maieutic prompting makes a model argue that an answer is true, argue that it is false, then keep only the explanations that survive both directions and resolve what is left. It comes from a 2022 EMNLP paper by Jung et al., and it is scoped to true or false questions, not general reasoning. The published method is a research pipeline you cannot paste into a chat box. The four recipes below are the shippable reduction, and they run on any frontier model, including Claude and GPT. Cost to test all four is about two cents.

First, two different things are called maieutic prompting

Search this term and you get two incompatible definitions on the same page of results, and nobody flags the conflict. Sort this out before you read anything else.

Both usages are live in 2026. One blog result on page one of Google defines it, in its own words, as "leading the user to their own conclusions through guided questions that encourage reflection and discovery." That is the teaching sense. It is not what the paper describes, and it is not what this page is about.

The name is shared for a reason. Maieutic means midwifery, Socrates' term for drawing out a belief someone already holds. The paper points that idea at the model instead of at a person. If you want the conversational version, that is Socratic prompting, and it is a different tool.

What the paper actually does, and why you cannot paste it

The method, per the abstract: it "induces a tree of explanations abductively (e.g. X is true, because ...) and recursively, then frames the inference as a satisfiability problem over these explanations and their logical relations."

Three parts, in order.

1. Abduce both ways. For a question Q, generate an explanation for why Q is true, and separately for why Q is false. Abductive means the answer is fixed first and the reasoning is generated backwards to support it.
2. Recurse. Treat each explanation as its own proposition and do the same to it. That builds the tree.
3. Resolve. Weight the explanations by how strongly the model holds them and how they contradict each other, then solve for the assignment of truth values that satisfies the most constraints. The paper frames this as a MAX-SAT problem.

Now the part no summary mentions. The official implementation is two Python entry points: main_generate.py builds trees with treelib and pickles them to disk, then main_inference.py runs verification and wants a GPU device id. It needs an OpenAI key set in the environment. There is no prompt in there to copy. Anyone selling you "the maieutic prompt" is selling you a reduction of it, this page included, and the honest move is to say so.

The reported result, verbatim, is "up to 20% better accuracy than state-of-the-art prompting methods." Read the scope before you get excited. The ACL Anthology entry scopes it to true or false QA, and the repo names the three benchmarks: Com2Sense, CSQA 2.0 and CREAK. Those are binary commonsense datasets. A popular Reddit thread on this method is titled "This method is way better than Chain of Thoughts," which takes a binary QA result and promotes it into a general claim. It does not carry. None of the accuracy numbers below transfer to the reduced recipes, because none of them run the solver. They are cheaper approximations of the same idea, and they are worth running for the failure they catch, not for a number.

Recipe 1: The abductive pair

Claim. One call, and you get the core of the method: the model is forced to build the case for both answers before it is allowed to pick one.

Receipt.

Question: {a true/false or judgment call}

Do not answer yet.

E+: Assume the answer is TRUE. Give the single strongest reason it is true.
E-: Assume the answer is FALSE. Give the single strongest reason it is false.

Now compare E+ and E- directly. Name the one fact that decides between them.
Answer TRUE or FALSE, then state that deciding fact in one sentence.

Why it works. A normal prompt lets the model commit to an answer in its first token and then spend the rest of the response defending it. Fixing the conclusion first and generating backwards, twice, in opposite directions, means the defence gets built for both sides before either wins. That is the abductive step from the paper, minus the tree.

The trick most people miss. The line that earns its keep is "name the one fact that decides between them." Without it the model writes two paragraphs and picks whichever it liked to begin with. Forcing a single crux is what makes the output checkable by a human in five seconds.

Failure mode. On a question with no real opposing case, E- is invented and reads as a hedge. Use it where the answer is genuinely contestable.

Recipe 2: Depth two, the recursion that matters

Claim. The paper's recursion is the difference between this and a pro and con list. You get most of it with one extra call, on the losing branch only.

Receipt.

Statement: {the explanation E+ from step 1}

Treat this statement as the new question.
E++: Give the strongest reason this statement is true.
E+-: Give the strongest reason this statement is false.

If E+- is stronger, say so plainly and mark the parent statement UNSOUND.
Otherwise mark it SOUND. One line, no elaboration.

Why it works. Wrong answers usually rest on one confident but unsound premise. Recursing on the explanation, rather than re-asking the question, is what surfaces that premise. In the paper this runs to full depth on every node. In practice depth two on the branch you are about to accept catches most of it.

The trick most people miss. Recurse on the branch you are inclined to believe, not the one you already rejected. Auditing the loser feels rigorous and tells you nothing. The expensive error is the premise you were about to accept unexamined.

Failure mode. Depth three and beyond gets abstract fast and the marginal catch rate falls off a cliff. Stop at two.

Recipe 3: The logical integrity filter

Claim. This is the load-bearing part of the paper and the part every summary skips. It is a two-line test that throws out explanations the model does not actually believe.

Receipt.

Statement: {an explanation}

Answer each independently, with only True or False.
A) Is this statement true?
B) Is the negation of this statement true?

Output exactly: A= B=

Keep the explanation only if A=True and B=False. Anything else, drop it.

Why it works. A model will happily agree with a claim and with its negation, because both were generated to be agreeable. An explanation the model endorses in both directions carries no information. The paper calls the surviving ones logically integral and uses exactly this criterion. It is the cheapest quality filter in this entire family of techniques and it is two boolean questions.

The trick most people miss. Ask A and B in separate calls, or at minimum insist they be answered independently. In one context window the model sees its own answer to A and stays consistent out of politeness, which is precisely the behaviour the test is supposed to detect.

Failure mode. Negating a compound statement is ambiguous, and you will test a negation you did not mean. Run it on atomic single clause explanations only.

Recipe 4: Resolving the survivors without a solver

Claim. You are not going to run MAX-SAT. You can still get the useful half of it by making the contradictions explicit and forcing a verifiable tie-break.

Receipt.

Surviving explanations:
1. {E1}
2. {E2}
3. {E3}

Step 1: List every pair that cannot both be true. Write them as "1 vs 3".
Step 2: For each conflicting pair, say which one is checkable against a
        source someone could look up, and which is a judgment call.
Step 3: Resolve each conflict in favour of the checkable one.
Step 4: Give the final answer, and list which explanations you kept.
        If the conflicts cannot be resolved this way, output UNRESOLVED.

Why it works. The solver in the paper picks the truth assignment satisfying the most weighted constraints. Steps 1 and 2 hand-build those constraints, and step 3 replaces the weights with a rule you can actually defend: verifiable beats plausible. Cruder than the paper, and unlike the paper it can tell you it failed.

The trick most people miss. UNRESOLVED is the output with the most value. A method whose only job is consistency should be allowed to report that the evidence is inconsistent. Strip that option out and you have built a machine that manufactures confident answers from contradictory inputs, which is the failure you started with.

Failure mode. With one surviving explanation there is nothing to resolve and step 1 returns empty. That is fine, and it means recipe 3 did the work.

Failure modes worth knowing before you ship this

• It is scoped to contestable binary questions. True or false, judgment calls, does this claim hold. On a lookup, a summary, or code generation there is no opposing case to abduce, and the whole structure is decoration.
• It cannot resolve a crux where every fact is unverifiable. If both branches rest on judgment, recipe 4 correctly returns UNRESOLVED and you are back to needing a human. Working as designed, still a dead end for automation.
• The accuracy number does not follow you. Up to 20 percent, on binary commonsense benchmarks, with the full tree and the solver. Not on your task, and not with these four prompts.
• Cost multiplies, not adds. Recipe 1 is one call, recipe 2 adds one, recipe 3 is two per explanation and they should be separate calls. A four-explanation run lands around ten calls against one for a plain answer.
• Consistency is not correctness. A model can be consistently wrong, and this method will hand you a beautifully reconciled wrong answer. It removes self-contradiction. It does not add knowledge.
• Do not stack it under n-vote sampling and call it rigour. Running self-consistency over the whole pipeline multiplies a ten call run into a fifty call one. Pick one. Majority vote across samples and logical resolution within one sample are two different bets, and paying for both rarely changes the answer.

When NOT to use it

If a wrong answer is cheap to fix, skip all of this. Ten calls and a crux to read is an expensive way to answer a question whose failure costs you nothing. This earns its keep on the small number of binary calls that are hard to reverse: is this contract clause enforceable, does this incident match the known root cause, is this claim safe to publish. If nothing downstream branches on being right, run the plain prompt and move on.

Cost to test: about $0.02 for all four recipes on a mid tier model, well under thirty calls.