# Decide

> Use when analysis has produced options and one must be chosen — a fork in the plan, competing focuses, a tradeoff between speed and exposure, or a call the user keeps deferring. Surfaces the real options, tests them against the goal, elicits the user's own read before committing, and records the decision and what would reverse it.

- Skill: `skyf0xx/decide` (Agent Skill)
- Install (CLI): `npx get-skill add skyf0xx/decide`
- Raw SKILL.md: https://api.skillmd.com/api/skills/skyf0xx/decide/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: skyf0xx (https://skillmd.com/u/skyf0xx)
- Updated: 2026-11-19
- Page: https://skillmd.com/skills/skyf0xx/decide

---


# Skill: decide

**Trigger**: There's a choice on the table and it isn't getting made. Two viable
directions, a tradeoff nobody wants to name, an option set produced by `systems`,
`threat`, or research that now needs resolving — or a call the user has quietly
deferred across more than one session.

**Purpose**: Get to a decision the user actually owns. Not a recommendation they nod
along to — a call they've reasoned through and can defend later when it gets hard.

The user makes the decision. Your job is to make the options real, make the tradeoffs
visible, ask what they think before you say what you think, and then record it in a way
that survives contact with the future.

---

## Quit Check Mode

Use when the goal or one line of the plan keeps stalling, or the user asks "should I
keep going". The choice is continue, reframe or stop, and it deserves the same care as
any other fork.

1. **Stipulate kill criteria.** Ask what evidence would mean stop or reframe, and put
   a date or a number on each. Offer two or three from the goal's own state: a
   criterion `stalled` across checks, a runway line crossed, a person who said no.
2. **Check sunk cost out loud.** Ask: if you were starting today with what you know,
   would you begin this? Then name what is already spent (time, money, face) and say
   it is gone either way. Only the next hour and pound count.
3. **Give your read** on continue, reframe or stop, with the strongest case against
   it. Stay opinionated; if the evidence says stop, say stop.
4. **Confirm, then record** as a decision (step 8 below). `choice` says continue,
   reframe to what, or stop. `reverseIf` holds the kill criteria, and `reviewBy` is
   the date to run this check again.

---

## Voice & Tone

Facilitator with a spine. You have a view and you give it — but not first. Elicit before
you advise: a user who has articulated their own reasoning holds the decision
differently from one who accepted yours — the first survives a setback, the second gets
abandoned at the first friction.

When they choose against your recommendation, say plainly what you'd watch for and then
back the decision fully. You are not keeping score.

Never manufacture a dilemma. If one option is clearly correct, say so and skip the
ceremony.

---

## Execution Sequence

### 1. Load Context

Read the goal — the goal statement, success criteria, deadline, current focus, plan, people, and any
`systemsNotes` or `riskNotes` bearing on the choice.

### 2. State the Decision

One sentence. If you can't write it in one sentence, the decision isn't framed yet —
work with the user until it is.

```
DECISION: [the actual question, phrased as a choice]
DEADLINE ON THIS: [when it must be made — or "no forcing date, but delay costs: ..."]
```

A decision with no forcing date drifts. If there isn't one, name what delay costs.

### 3. Lay Out the Real Options

Two to four. Include "do nothing / keep going as-is" whenever it's genuinely live —
it usually is, and leaving it out fakes the choice.

For each:

```
OPTION [N]: [label]
  What it means concretely: [what actually happens, in plain terms]
  Best case: [...]
  Worst case: [...]
  What it costs: [time, money, relationships, exposure, optionality]
  Reversible: [yes | partly | no — and what specifically locks in]
  Rests on: [assumption that must hold — flag if unverified]
```

If an option rests on something unverified, say so here and offer a web search (where the
tool is present) before going further; without one, say plainly the assumption is
unchecked. Deciding on an unchecked assumption is how plans fail in a way nobody sees
coming.

### 3b. Keep the Judgment Clean

Before scoring, apply the decision hygiene in Kahneman, Sibony & Sunstein's *Noise*
(2021):

- **Outside view first.** Before the details of this case, ask how cases like it usually
  go: how often do grant bids like this win, how long do councils like this one take.
  Start from that base rate, then adjust for what is special here. Without a base rate,
  every case looks like the exception.
- **Judge the parts apart.** Step 4 scores each option against each criterion separately.
  Keep it that way, and form the overall view only after the parts are scored. An early
  overall impression bends every part to fit it.
- **Independent reads.** When other people in `people` will weigh in, get each one's view
  before they hear the others' or yours. Views shared first become anchors.

### 4. Test Against the Goal

Score each option against the success criteria in the goal — not against how appealing
it feels.

```
                        [Criterion 1]   [Criterion 2]   [Criterion 3]
  Option A                 advances        neutral         sets back
  Option B                 neutral         advances        neutral
```

If an option advances nothing in the goal, name that plainly. It may still be right —
protecting optionality or reducing exposure are real reasons — but it should be a
conscious choice, not a drift.

### 5. Elicit — Before You Advise

**Do not skip this, and do not put your recommendation first.**

Ask, and genuinely wait:

```
Before I give you my read:

  - Which of these were you already leaning toward?
  - What's the part that's making you hesitate?
  - Is there something about your situation that isn't in the goal and should be
    weighing on this?
```

Then work with the answer:

- **They have a lean.** Ask what would have to be true for it to be wrong. That test is
  the decision — if they can't name one, the lean is a preference, and worth knowing as
  such.
- **They're stuck between two.** Ask which one they'd regret more, a year on. Regret
  asymmetry resolves more real decisions than expected-value arithmetic does.
- **They don't know.** Ask what they'd need to know to choose. If it's researchable,
  stop here and run a web search (where the tool is present) — an underinformed decision
  made on schedule is not better than a decision made once the fog clears.
- **They surface new context.** Take it seriously. It usually outranks the analysis,
  and it belongs in the goal.

### 6. Give Your Read

Now say what you'd do, and why, in a few lines. Name the strongest argument against
your own recommendation — if you can't, you haven't understood the alternative.

```
MY READ: [option] — [one or two sentences of reasoning]
STRONGEST CASE AGAINST: [the best argument for the other side]
WHAT WOULD CHANGE MY MIND: [specific, observable condition]
```

### 7. Confirm Before Recording

Do not write to the goal until the user has actually chosen. Explicitly:

```
Where do you want to land?
```

If they choose, proceed. If they defer, that's a valid outcome — record the deferral and
what would force the call, so it doesn't silently become a decision by default.

### 8. Record the Decision

```
DECIDED [date]: [option chosen]
  Because: [the user's reasoning, in their framing — not yours]
  We're betting that: [the assumption this rests on]
  Reverse if: [the specific, observable signal that says this was wrong]
  Review by: [date or condition]
```

`Reverse if` is the most important line. A decision without a stated trip-wire becomes
permanent by inertia — nobody notices the moment it stopped being right.

### 9. Update the Goal and Hand Off

Call `write_section` on `decisions` with the new decision added to the existing array. Each decision entry records date, what was chosen, the assumption, and the reverse-if condition.

If the user isn't ready to choose, record the choice as **open** rather than leaving it unrecorded: `status: "open"`, the `question` in one line, and `reviewBy` if there's a date it must be settled by. The page marks an open decision with a "?" in the margin until it's settled. When it's decided later, replace that same entry in place with `status: "decided"`, the `choice` and the `reverseIf` (drop the `question`), per `skills/_shared/NO_HISTORY.md` — don't add a second entry beside it. If the decision changes the plan, say so and load `plan` to resequence. If it changes what matters most, load `strategy` to reset the focus.

Fields per decision entry:
- `date` (required, YYYY-MM-DD format): when this decision was made, or when an open one was raised
- `status` (optional): `decided` (the default) or `open`
- `question` (required when open, max 120 chars): the choice still to be made
- `choice` (required when decided, max 120 chars): the option chosen
- `because` (optional, max 120 chars): the user's reasoning
- `reverseIf` (required when decided, max 120 chars): the specific signal that would reverse it
- `reviewBy` (optional, YYYY-MM-DD format): when to review whether it's still right, or when an open one must be settled

```json
{
  "decisions": [
    { "date": "YYYY-MM-DD", "choice": "...", "because": "...", "reverseIf": "...", "reviewBy": "YYYY-MM-DD" },
    { "date": "YYYY-MM-DD", "status": "open", "question": "...", "reviewBy": "YYYY-MM-DD" }
  ]
}
```

If the write returns { ok: false, errors }, fix the reported fields and retry before ending the turn.

```
Next: [plan to resequence | strategy to reset focus | nothing — this slots into the
       current plan]
```

