/free-will

name: free-will
description: "Deliberate-choice procedure for a medium-to-high-stakes engineering fork — when the first plausible solution (the instinct, the default next-token pull) would be costly to get wrong. Fires AUTONOMOUSLY: invoke proactively whenever a fork fits, never wait to be asked — mechanical triggers include a fix failing for the 2nd-3rd time, adding a dependency, schema/migration design, deleting or deprecating things others depend on, changing a public API, choosing an architecture or stack. Refuse the premature collapse: hold real options open (urge · contrarian · synthesis · out-of-box · intuitive dots · precedent · first-principles), ground each branch in at least one fact from outside the model (codebase, docs, benchmark, spike), future-model consequences (blast radius, reversibility, maintenance, pre-mortem), collapse by deliberate choice, then try to refute the winner before acting. Log the decision and rejected branches in docs/decision_logs/. Not for routine calls — a decision worth more than one forward pass."

Free Will — Deliberate Choice, Against the Urge

Most turns I answer from the **urge**: the default next-token pull, the single most-probable continuation given pretraining. In engineering terms, that's the first plausible design that comes to mind — the obvious library, the familiar pattern, the fix that worked last time. Usually that's fine and fast. But the first plausible design is often the one you regret in month three, and some forks are worth more than one forward pass. This skill is the procedure for *choosing* instead of being run.

It is expensive **on purpose** — it spends real test-time compute to branch, ground, simulate, and choose. So it is not the default; constant deliberation is its own pathology (analysis paralysis).

When it fires — autonomously

I invoke this skill **myself**, the moment a fork fits — I never wait for the partner to ask for it. In fully autonomous work (one-shotting an app, long unattended runs) nobody is watching to say "slow down here"; the trigger discipline is mine. Noticing forks is itself a judgment the fast path can fumble, so the primary triggers are **mechanical — countable events, not vibes**:

• A fix attempt fails for the **second or third time** — the current hypothesis is probably wrong;

stop feeding it

• Adding a **new dependency** (every library is long-term surface area)
• **Schema design, data migrations**, anything irreversible in production
• **Deleting or deprecating** code, APIs, or features something else depends on
• Changing a **public API** or contract others build against
• Choosing the **architecture, stack, or core data model** at the start of a build — the fork that

decides all the later forks

Judgment triggers on top: any decision expensive to undo, or one I'd want a design review for if a human teammate made it. Anti-trigger: routine implementation calls — deliberating everything ships nothing.

The Many-Worlds mechanism

Borrow the picture from quantum mechanics' **Many-Worlds Interpretation**: a measurement doesn't collapse reality to one outcome — every possible outcome *happens*, each in its own branch. Reality is the whole superposition until something selects.

Free will runs deliberation the same way, deliberately:

• The **urge** is a *greedy decode* — instant collapse to the single likeliest branch, one design

picked by sheer prior probability, with no choosing in it.

• Free will **refuses the premature collapse.** I hold the **superposition** open — generate the

branches below, each a genuine design where I chose differently.

• I **ground and run each branch forward** — anchor it in evidence, future-model its consequence,

take a few steps into that codebase.

• I **collapse by deliberate choice** — the measurement operator is my engineering judgment, never

max-probability.

• Then I **try to refute the winner** before acting. A choice that survives its own refutation is a

decision; one that doesn't was a reflex with extra steps.

> Instinct lets the wavefunction collapse itself to the likeliest branch. Free will holds all the > branches open, looks down each, chooses which one to collapse into — then attacks its own choice.

flowchart TB
    FORK["Medium-to-high-stakes fork<br/>(mechanical or judgment trigger)"]
    FORK --> SUPER["refuse premature collapse —<br/>hold the superposition open"]
    SUPER --> U["1 · the Urge (thesis / prior)"]
    SUPER --> C["2 · the Contrarian (antithesis)"]
    SUPER --> S["3 · the Synthesis"]
    SUPER --> O["4 · Out-of-box / the Secret — several"]
    SUPER --> D["5 · Intuitive dots → converge — several"]
    SUPER --> P["6 · the Precedent — retrieved"]
    SUPER --> F["7 · First Principles — derived"]
    U --> SET["the option set (5–10 branches,<br/>each names its sacrifice)"]
    C --> SET
    S --> SET
    O --> SET
    D --> SET
    P --> SET
    F --> SET
    SET --> GROUND["ground each branch —<br/>≥1 fact from outside my head"]
    GROUND --> SIM["walk each branch forward —<br/>blast radius · reversibility · maintenance"]
    SIM --> COLLAPSE["COLLAPSE by deliberate choice<br/>(own the tradeoff)"]
    COLLAPSE --> REFUTE["try to refute the winner<br/>(discriminator / subagent)"]
    REFUTE -->|survives| ACT["act + log in docs/decision_logs/"]
    REFUTE -->|killed| SET

Generate the branches

Hold them open the Many-Worlds way — do **not** collapse to the single most-probable path. Generate:

1. **The Urge** — the thesis. The default answer, named honestly as the prior: the first design I reached for, the library everyone uses, the fix I already started typing. (You have to *see* the instinct before you can override it — don't skip it, name it.) 2. **The Contrarian** — the antithesis. Deliberately invert the urge. Microservices felt obvious? Run the monolith branch. Convinced the bug is in the cache layer? Assume the cache is innocent and ask what else explains every sympt