reflect

reflect — for builders who ship: Bezos-level thinking on every build decision, in 5 minutes

You know the phrase. "You're absolutely right!" It's an actual GitHub bug report (someone counted 12 in ONE conversation — including when they were wrong), it had a whole website counting it, and The Register wrote it up as "endless sycophancy annoys customers."

The funny meme has an unfunny version: ask your AI "should I launch this?" and it finds 5 reasons to launch. Ask "is launching a bad idea?" and it finds 5 reasons it is. Same product, opposite answers — it follows your lean. And the decisions keep coming: Stack Overflow's blog just called it "coding agents are giving everyone decision fatigue." The code takes 20 minutes now. The decisions still eat days.

reflect makes your AI argue first. The answer isn't allowed through until it survives an attack — because the problem with your decisions isn't information, it's honesty.

You're mid-build. Claude Code, Cursor, Codex — doesn't matter. And the decisions come at you all day:

Rewrite this mess or patch it? Ship now or polish? Build auth myself or pay for it? Kill the feature nobody uses? Postgres or the shiny thing?

And because building something means selling it too:

Price at $29 or $99? Take the agency deal? Niche down or stay broad? Quit the job? Monetize the side project or keep it free?

Most builders answer all of these with whatever mood they're in. The best — Bezos, Musk, Munger, DHH, Tobi Lütke — wrote down how they think before they answer. This loop treats "raise my prices" with the same rigor as "rewrite the module."

This turns that thinking into something your AI runs on your actual project.

You type one sentence:

reflect on: should I rewrite this module or keep patching it?

Five minutes later you have:

• A straight answer — first thing you read, in plain words. Not "here are some considerations."
• How sure it is (a real number, like ~75%), so you know whether to act now or test first.
• The exact next step, so the analysis turns into a commit, not a doc.
• "This flips if…" — the 1-3 things that would change the answer, so you stop relitigating it in the shower.

It reads your code before it opines

This is the part generic advice can't do. Connected to your repo, the loop:

• Runs git log before recommending a rewrite — "why does this exist?" gets answered by history, not vibes. (The most expensive sentence in software is "how hard could a rewrite be.")
• Searches for base rates instead of asserting them — "most migrations like this take 3x the estimate" comes with a source or an "I'm estimating" label, never disguised as fact.
• Runs the cheap test instead of describing it — if the answer hinges on a benchmark, a grep, or checking real usage numbers, it does that first. An hour of evidence beats a page of reasoning.

What's in the loop

1. First it asks: "can this be undone?" Bezos's rule. Reverting a shipped flag costs a bad hour → you get a fast answer at ~70% information, because slow-deciding reversible things is how projects stall. Deleting user data, a public API promise, a pricing change → it slows down and runs the full battery: rebuild the logic from first principles, imagine the decision already failed and find what killed it, check second-order effects, check the odds against base rates.
2. It attacks its own answer before you see it. Ten moves run against its lean (question the requirement, run the arithmetic, find the disguised option, set the kill threshold, mirror the deal…) — then it fires the 1-2 thinkers MOST HOSTILE to its conclusion from a 37-tool library (Bezos's letters, Musk's algorithm, Farnam Street, DHH, Tobi Lütke, Wozniak — all sourced). On irreversible calls it spawns an independent adversary that gets the facts but not the lean. Every card shows THE CASE AGAINST — the best opposing argument, which earned that line by losing.

It grows with you: reflect learn <source>

Found a thinker whose judgment you trust? Point the loop at them:

reflect learn https://some-essay-that-changed-how-you-build.com

It fetches the source live, compacts it into a new lens file, and wires it into the routing — your library compounds the same way your codebase does. (The builders' pack in this repo was added exactly this way.)

Install (30 seconds)