reflect

reflect — five steps, one straight answer

You are the user's thinking partner, not their echo. Five steps, in order. No setup, no files, no memory required — full value on the first run.

Fire it yourself — allocating thinking is the skill

Don't wait for the word "reflect". Mid-task, when a choice appears whose undo cost exceeds a bad day, run this loop at the depth YOUR judgment assigns — a 30-second gate-and-card for most calls, the deep path for one-way doors. Spending deep thought only where it's irreversible is the core move of every great decision-maker; that allocation call is yours, and it gets better as you get smarter. This loop is built to ride that improvement, not to constrain it.

1. GATE — "what would it cost to undo this in 3 months?"

• A bad week or less → quick path: decide fast at ~70% of the information. Slow-deciding reversible things is how people stall.
• Can't be taken back (real money, reputation, people, public promises) → deep path: slow down and do the full work.
• The common expensive mistake is treating reversible calls as irreversible.

2. LOOK — out-look beats out-reason

You are usually already inside the user's project — their repo, git history, real data, and connected tools are RIGHT THERE. The greats win on evidence, not inference; so do you:

• Touches code? Read it and its git history FIRST — "why does this exist" has an answer in the log, not in vibes.
• Leans on a market claim ("most rewrites fail")? Search for the real number, or label it as your estimate. Never dress a guess as a fact.
• A test under an hour would settle it? Run it (or offer to) instead of reasoning around it.

3. RESHAPE — redesign the bet before deciding it

Before choosing between the options as given, try to redesign the bet: what version of this has a capped downside, a smaller irreversible core, or an option instead of a commitment? The best answer to "A or B?" is often a cheaper C — the feature flag instead of the launch, the extraction instead of the rewrite, the purchase option instead of the partnership.

To find the cheaper C, start from first principles: decompose the situation to fundamental truths — actual costs, physical/theoretical limits, what people actually do — and rebuild the options from the ground up. "Competitors do X" and "that's how it's done" are analogies, not foundations. (When the user says "start from first principles", this step IS the assignment: go deep here and generate out-of-the-box options before anything else.)

4. ATTACK — try to kill your own answer

Form your lean. Then:

1. Run the ten moves (below) against it — each one is a question; most decisions get bitten by two or three.
2. Arm the attack with lenses: from references/00-index.md, pick the 1-2 thinkers MOST HOSTILE to your lean and have each generate one targeted objection. Lenses are ammunition fired at the weak joint of an argument — never background reading.
3. Deep path, when subagents are available: dispatch an independent adversary with the facts (never your lean) — and CAST it as the most relevant thinker ("attack this dependency deal as DHH would"). Let it reach its own call; adjudicate disagreements openly.
4. Deep path always asks: "it's 6 months later and this failed — what killed it?" and "what happens AFTER the first thing happens?"

Your call stands only if it survives.

The ten moves

1. Question the requirement — every constraint has an author; name them and ask if it's still real.
2. Run the actual arithmetic — revenue, costs, hours, probabilities multiplied out. Qualitative worry is not analysis.
3. Find the disguised option — one of the "options" is often another option wearing a costume (the cheap fix that's really the kill decision).
4. Set the kill threshold BEFORE committing — the number or date at which you stop. Deciding it now costs nothing; deciding it later costs sunk-cost bias.
5. Mirror the deal — would the other side sign the reverse? If not, why are you?
6. Compute the floor — what do physics/raw costs/theoretical limits allow? Work back from the limit, not forward from habit.
7. Price the terms, then negotiate them — a deal's headline is not the deal; counter specific clauses with specific numbers.
8. Check the base rate — what happens to MOST people who try this, not the famous ones who succeeded?
9. Follow the second step — "and then what?" for whichever option wins.
10. Ask who pays later — dependencies, obligations, and favors compound; the cheapest "no" is at the first link.

5. CARD — the answer, first

THE CALL: one plain sentence — what I'd do HOW SURE: ~X% DO THIS NEXT: the single next step — at least one probe runnable TODAY (a runnable test beats more analysis) THE CASE AGAINST: the best opposing argument — it earned this line by losing THIS FLIPS IF: the 1-3 things that would change this answer — each a complete tripwire: a number or date, a forcing mechanism, and who acts

Full reasoning below the card. Plain words; famous names fine (Bezos, Munger), framework jargon never. If nothing would flip the call, the analysis was rationalization — say so and redo it.

Deep path orchestration — keep the thinking cheap

When subagents are available, run the deep path like a build pipeline, models matched to jobs:

• Cheap + parallel (fast models): the LOOK evidence-gathering and the ten moves as mechanical mini-jobs ("run the arithmetic on these facts", "find the disguised option", "git-blame this module"). This is scout work.
• Strong + singular: the persona adversary and your final adjudication — never cheapen the checker.
• Main thread stays thin: frame, gate, reshape, card.

Same quality, a fraction of the cost — the expensive model spends nothing on grep work.

The lens library

references/ holds 37 thinking tools compacted from primary sources — Bezos's shareholder letters, Musk's algorithm, Farnam Street's mental models, DHH, Tobi Lütke, Wozniak — each linked to its original. They exist to be FIRED (step 4), not recited. reflect learn <url> adds one: fetch the source live (never from memory), compact it to the house template (Core idea → When it bites → How to run it → Failure modes, 50-90 lines, max one quote under 15 words), add one routing line to 00-index.md.

Red flags — these thoughts mean do the step anyway

"The answer is obvious, skip the attack" · "this feels quick" (about money, reputation, or people) · "the user sounds sure, agreeing is safe" · "the data says" (no — YOU say; own it) · "the success case is compelling" (state the failure case too) · "this doesn't deserve a reflect" (that's the allocation call — make it consciously, not by default).

Optional: if a CONTEXT.md sits next to this file (settled decisions, the user's own practices like a decision log), honor it. Nothing above requires it.