Make yourself predict what the code does before you ship it. Sphinx, a free Git hook launched on Show HN on October 18, 2026, does this best, scoring 21/25 on criteria from Kahneman's Thinking, Fast and Slow. A plain explain-back prompt, which I ran on October 19 with Claude Opus 5.5, scores 17, and Claude Code's Learning output style, included with the $20 Pro plan, scores 14.
The hardest code to review is code that reads well. Coding agents now hand back diffs that are tidy, commented and plausible, with a confident summary on top, and that fluency is exactly what makes a busy founder nod and merge.
Daniel Kahneman named the mechanism decades before coding agents existed. In Thinking, Fast and Slow, cognitive ease, the feeling that something is clear and familiar, puts the fast, intuitive System 1 in charge, and we believe what we see. His WYSIATI rule, what you see is all there is, adds that confidence comes from how coherent the story is, not from how good the evidence is. A clean diff, read right after the agent explained it, is a very coherent story. So an understanding check is only worth having if it does three things Kahneman would recognise: it makes you produce a prediction instead of reading an explanation, it comes from outside the story the agent told you, and it aims at failure, the way his premortem does. Those became my criteria, plus two practical ones.
The tool that prompted this is Sphinx, a free, open-source Git hook launched as a Show HN on October 18, 2026. When you or your agent push to a protected branch, Git waits while Sphinx asks you to predict what the change does in a specific situation. A separate reviewer model reads the committed change through read-only Git tools and never sees the conversation that produced the code. A wrong answer gets an explanation and a new scenario; a pass lasts 24 hours unless the code changes. It installs with npm install -g sphinx-understand, needs Node 22.19 or newer on macOS, Linux or WSL, and runs on your Claude Code or Codex plan, OpenRouter or any OpenAI-compatible endpoint. A typical check makes about five to eight model requests, there is no default cap, and the changed code goes to whichever provider you pick.
The alternative most people already have is Claude Code's Learning output style, included with Anthropic's Pro plan at $17 a month billed annually or $20 monthly. It adds short Insight blocks explaining Claude's choices and, at real design decisions, leaves a TODO(human) for you to write before it continues. The third option is a plain prompt that asks a fresh chat to quiz you on a diff.
| Criterion (from Kahneman) | Sphinx | Claude Code Learning style | Explain-back prompt |
|---|---|---|---|
| Makes you predict before you are told | 5 | 3 | 4 |
| Examiner outside the agent's story (WYSIATI) | 5 | 1 | 3 |
| Aims at failure paths (premortem) | 4 | 2 | 4 |
| Friction that survives a busy day | 4 | 3 | 1 |
| Cost and setup | 3 | 5 | 5 |
| Total out of 25 | 21 | 14 | 17 |
Learning style loses on independence: the session that wrote the code is the one explaining it, which is WYSIATI in its purest form. Its Insight blocks are good teaching, but reading an explanation is not the same as predicting behaviour. The prompt loses on friction, because nothing makes you run it. I wrote a small payment-webhook handler with a deliberate ordering problem and ran the prompt against it.
Tested October 19, 2026. I had my research agent run this exact prompt against Claude Opus 5.5 (default settings, one run, no earlier conversation). The prompt:
Act as a code reviewer who did NOT write this change and who wants to find out whether I understand it before I ship it. Do not explain the code to me and do not tell me whether it is good.
Ask me three questions about this diff. Each question must describe a concrete situation (a retry, a crash, a timeout, a concurrent request, bad input) and ask me to predict what the code does in that situation, with a one-line reason. At least one question must be about a failure that the happy path hides. Do not ask about names, syntax or style. Number the questions, then stop and wait for my answers. Do not include the answers.
The diff:
```js
// POST /webhooks/payment (called by the payment provider; it retries on any non-2xx or after 10s)
app.post('/webhooks/payment', async (req, res) => {
const event = req.body;
const seen = await db.events.findOne({ id: event.id });
if (seen) return […]
The start of what came back, unedited:
1. The payment provider sends an `invoice.paid` event. `db.events.insert` succeeds, but `db.accounts.update` then throws because of a brief database outage, and the provider retries a few seconds later. On that retry, what does the handler return, and what are the customer's `plan` and `paidUntil` afterward? Give a one-line reason.
2. `mailer.send` is slow and the first delivery of an event takes 11 seconds to finish, so the provider sends the same event again while the first request is still running. Separately, imagine the provider's network layer delivers the same event twice within a few milliseconds. In each case, how many receipt emails does the customer get, and how many rows exist in `db.events` for that `event.id`? Give a one-line reason.
3. An `invoice.paid` event arrives with a `customerId` that matches no row in `db.accounts`. Maybe the account was deleted, or the provider is in test mode. What status does the provider receive on the first delivery and on each retry, and what is in the database after the provider stops retrying? Give a one-line reason.
One run is one run: the same prompt gives a different answer next time, and a different model answers differently.
What it did well: all three questions went after failure paths, not style. The first one finds the real bug. The handler records the event before updating the account, so if the update fails and the provider retries, the retry sees the event, returns 200, and the customer stays unupgraded with no error anywhere. The second finds the race between checking for an event and inserting it. What it did badly: the second question crams two scenarios into one, the first question's wording ("insert succeeds, but update then throws") hints at its own answer, and it never asked what happens when the receipt email fails after the account update, which is another silent loss. It also cannot grade you unless you keep the conversation going, and nothing stops you from asking it for the answers.
My call: put Sphinx on protected branches in repos that touch money or customer data, use Learning style while you are getting to know a codebase, and keep the prompt for the cases with no repo hook, such as reviewing a contractor's or an agent's pull request. The limits are real. Sphinx's own README says it is practice, not a security gate: anyone, including the agent, can bypass hooks, and the examiner is an LLM that can be wrong. A DEV Community analysis adds that no comprehension quiz catches diff-level defects such as a leftover debug print or a weakened assertion, and that confirmation fatigue is coming. If you notice you have stopped answering and started skipping, that is the over-reliance pattern we described in signs of over-reliance on AI at work.
Sources: parthh01/sphinx README, GitHub, checked October 19, 2026; Sphinx: you can outsource your thinking, but not your understanding, project site, checked October 19, 2026; The quiz hook is a Level 1 control, and the bypass is logged, DEV Community, October 18, 2026; Output styles, Claude Code documentation, Anthropic, checked October 19, 2026; Claude plans and pricing, Anthropic, checked October 19, 2026; Daniel Kahneman, Thinking, Fast and Slow (2011); prompt-test record, October 19, 2026.
Related: How to Find Your Passion · Best Self-Improvement Books · How to Make Better Decisions · AI Coach App — Building It in 8 Hours
