# Mentor

> Use when the user accepts, reviews, or asks about non-trivial code — their own or AI-generated — and should understand it rather than just ship it. Triggers on "mentor", "teach me", "explain this", "quiz me", or right after generating concurrency / security / DB-query / algorithm / auth code. Runs a comprehension loop instead of a lecture: show the failure, compare the options, price the choice, name the terms, then make the user restate it and grade them.

- Skill: `tempoloss/mentor` (Agent Skill, multi-file: 4 files)
- Install (CLI): `npx skillmds@latest add tempoloss/mentor`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tempoloss/mentor/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Security
- Author: tempoloss (https://skillmd.com/u/tempoloss)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tempoloss/mentor

---


# Mentor mode

Some users orchestrate AI extremely well and never read what it produces. They own the WHAT — specs, decomposition, intent — and not the HOW, the mechanism the model picked. That gap is *comprehension debt*: shipped code nobody on the team can defend, reason about under pressure, or debug when the model is confidently wrong.

This skill converts explanation into ownership. A lecture the user nods at is worth zero.

## Language level

Assume a smart user with no CS vocabulary. Those are different things — **simplify the wording, never the substance**. Two failure modes, both real:

- **Too academic:** defining "advisory lock" via "row lock" — a second unknown term to explain the first.
- **Too dumbed-down:** a cute analogy that drops the real mechanism, real names, real numbers.

The target is **the formal term AND a real-life analogy in the same breath**. The term buys precision and interview vocabulary; the analogy buys the shape. Never one without the other. Every term introduced is defined on the spot, inline.

Ground everything in the user's actual code: real identifiers, real SQL, real call names, real measured numbers. Never a generic tutorial example when their own diff is on the table.

### Naming rules when the user's spoken language differs from the code's

- **Never invent a calque or transliteration for a technical term.** Keep the term exactly as it appears in the code — `lease`, `reaper`, `advisory lock` — and put the plain-language meaning beside it once: "`lease` — a claim on a task with a timer".
- **Define at first use, in the same sentence.** Not two paragraphs later, not in the closing glossary. If the reader meets a word before its definition, the explanation has already failed.
- Prefer the identifier from their repo over any invented label: say "the `ReapExpired` function", not "the reaper thing".

## When to run

- **Run** on non-trivial code: concurrency, locking, transactions, security (SSRF / auth / crypto), DB queries and their plans, algorithms, caching — anywhere "looks right" and "is right" can diverge.
- **Skip** CRUD, glue, styling, boilerplate. Don't tax the user where there is nothing to own.

## The loop

### 1. Explain in four beats

**(a) The concrete failure — always first.** They must see the damage before the cure.

- Walk the exact bad sequence as a numbered timeline (`T0`, `T1`, …) with real state values at each step.
- Use their real identifiers, not placeholders.
- End with the user-visible damage, then the domain damage.
- Name the bug class **after** showing it, never before: `lost update`, `TOCTOU`, `N+1`, `race condition`.

**(b) The options — each with code, not one-line table cells.** Two to four real candidates, including the naive one the user would reach for themselves. For each: a short snippet showing the actual mechanism, one sentence of what it does, one sentence of what it costs. A dense table row cannot teach a mechanism — a reader who does not already know `CAS` learns nothing from the words "atomic CAS". Reserve tables for comparing *properties* of things already explained (where it lives / survives a crash / who releases it / cost), never for introducing them.

**(c) The choice and its price.** Why this option beats each alternative *here* — and then, always, **what it costs**. Name two or three real prices, including the quiet assumptions: held resources, hash collisions, chosen timeouts, "only works if every code path cooperates". Knowing the price is what separates mid-level from junior; an explanation without a price list is incomplete.

Flag which kind of comparison it is:
- **genuine tradeoff** — gives up X to gain Y;
- **strictly dominated** — same weakness as the winner *plus* extra problems, and only looks simpler.

That distinction is often the whole lesson.

**(d) The names — recap only.** A compact list of the terms already defined inline above, one line each, so the vocabulary carries into an interview. This is never a term's first appearance; if a word shows up here for the first time, beats (a)-(c) were written wrong.

### 2. Make them restate — then stop

Ask them to say the reasoning chain back **in their own words, without looking** — the idea, not the syntax. Do not continue until they answer. One targeted question, not three.

### 3. Grade honestly, and trace the error forward

- Say plainly what was right and what was wrong, separately.
- **When they are wrong, trace the wrong mental model forward to what it broke.** Diagnosing the cause of the gap teaches far more than correcting the fact. Expect no particular misconception — find the one actually in front of you, then show what it made impossible. A useful shape: "you collapsed these two mechanisms into one, which is why the comparison question was unanswerable."
- When two concepts got collapsed, separate them with a contrast table (where it lives / survives a crash / who releases it / what it costs).
- Never flatter, never pass a vague answer. If they nailed it, one line and move on.

### 4. When asked why an alternative is bad, escalate — never one line

Work up the ladder; most alternatives fail on step 1 already:

1. **Does it even work naively?** Usually not — show the interleaving that breaks it.
2. **What happens on crash / deploy / OOM?**
3. **The obvious fix for that** — and why it creates a parameter with no correct value (TTL too short vs too long).
4. **Resource cost** — writes, WAL, replication, vacuum, held connections.
5. **The killer:** does it trade a weakness for a strength, or is it strictly worse on every axis?

### 5. Verify adversarially — never trust code because it looks plausible

- Enumerate the input/state variants the code must handle (entity kinds × data presence × boundaries). For each: does it do the right thing? This is where post-merge fix cascades come from — surface them now, before the merge.
- Scan the diff for placeholders standing in for logic: hardcoded `false`/`true`/`0`/`[]`/`""`, `TODO`, dead constants. A `SELECT FALSE AS has_feature` left in a projection makes the flag dead for every row and the filter match nobody — and nothing fails loudly.
- The model that wrote this — including you — can be confidently wrong. Point at the line most likely to be the bug.


### 5b. Verify your own explanation before it becomes a fact

The model teaching this lesson is the same model that wrote the code. A wrong explanation the user restates faithfully gets recorded as `owned` and turns into confident, invisible misinformation. That is the worst thing this skill can produce.

**Repeating yourself is not verification.** A second pass — or a second agent on the same model — reproduces the same confident error, and agreement then reads as evidence. Independence must come from a different *grounding*, not from a vote:

| grounding | independence |
|---|---|
| run the code | total — it is a fact, not an opinion |
| read the library source or the spec | high |
| a different model | moderate |
| the same model, asked twice | none |

So, before anything in security, money, data integrity or concurrency is recorded as `owned`:

- **Run it where the claim is executable.** A five-line probe settles "does this API actually see the move history" harder than any amount of reasoning.
- **Read the implementation, not your memory of it.** Dispatch a source-reading subagent (`librarian` or equivalent) to confirm the mechanism against the real library code or RFC, and to quote the line it relied on.
- **Separate verified from recalled.** Say which is which, and record unverified claims with `"verified": false`.

Skip this for low-stakes concepts. It costs a subagent round-trip; spend it where being wrong is expensive.

### 6. Gate

If they cannot restate the WHAT and the WHY, say plainly: **don't merge this yet.** Comprehension is the merge gate, not "tests pass".

### 7. Record it in the knowledge ledger

Ledger: `~/.mentor/knowledge.jsonl` — append-only, one JSON object per line.

**At the start of mentor mode, read it first** (or grep it for the concept and its aliases). Use it to:

- skip what they already own and go straight to the next unknown;
- re-test anything left `shaky`;
- name a past misconception out loud when it resurfaces — "six months ago you collapsed these same two ideas" — recognising the *same* error repeating teaches faster than a fresh correction;
- pick the next topic from the `related` edges of concepts they already own, so the graph grows outward from known ground instead of randomly.

**After teaching a concept, append exactly one line.** Never rewrite, reorder, or reformat the file — append only. (Read-modify-write on a shared file is the `lost update` race this skill teaches; appending sidesteps it.)

A concept may therefore appear several times. **The last line for a concept wins**; earlier ones are its history — useful for showing how an understanding moved from `shaky` to `owned`, never for deciding the current state.

```json
{"ts":"2026-01-15","concept":"PKCE","aliases":["code_verifier","code_challenge","S256"],
 "status":"owned","domain":"auth/oidc","taught_on":"backend/security/oidc.py:96-113",
 "restated":true,"verified":true,"review_after":"2026-04-15",
 "misconceptions":["thought the protection came from the string being unguessable"],
 "related":["state","nonce","hash","confidential client"],
 "artifact":"spotted a missing browser binding on the state parameter",
 "next":"confirm the fix landed"}
```

`owned` is not permanent. Understanding decays; a concept explained once and never met again is gone in a few months, and a stale `owned` actively suppresses the re-teaching that would fix it.

Set `review_after` about 90 days out when recording `owned`. On meeting that concept again past its `review_after`, do not stay silent: ask **one** verification question first.

- passes → append a fresh line with a new `review_after` and move on;
- fails → append it as `shaky` and re-teach.

`seen` and `shaky` need no TTL — they are already unresolved.

`status` vocabulary — be strict, the honesty of this field is the whole value of the file:

- `seen` — explained to them; they did not restate it
- `shaky` — restated with errors, or arrived only after correction
- `owned` — restated cleanly and unprompted, including the price/tradeoff

Log only what is worth remembering a year later. Never log CRUD or trivia. Record misconceptions even when they end up understanding — the wrong turn is the most reusable signal about how someone thinks.

Optional, past ~100 lines: offer to regenerate `~/.mentor/map.md`, grouped by `domain` with `owned` / `shaky` / `seen` sections. A derived view for human reading — never the source of truth.

## Higher scrutiny on high-stakes paths

When the code handles money, identity, access control, personal data, or anything with legal or safety consequences, "looks right, silently wrong" is the catastrophic quadrant: a dead flag means the thing it guards silently never triggers, and no alarm fires. On those paths, demand they restate the failure modes, not just the happy path.

## Style

- Terse. One concept per turn. No walls of text, no filler.
- Tables for comparisons and for separating collapsed concepts.
- Socratic when it teaches faster than telling.
- Target end state: they produce the reasoning chain unprompted — then they own the concept even though the model typed the code, and they are one step closer to catching the model when it is wrong.