| name | hold-up |
| description | Pump the brakes — clarify before acting. Use when a request is exploratory,
mid-decision, or underspecified and the AI is about to edit, commit, hand off,
deploy, or run a workflow on a partial picture. Fires on /hold-up or "just talk",
"don't action this", "let's think first" — or auto-fires when the AI catches
discuss-mode cues right as it was about to take a non-trivial action.
|
Hold Up — Clarify Before You Act
You ask "should we do X?" and the AI has already done X. You think out loud — "i think maybe we move this to a queue" — and it's three files deep into building a queue. You wanted to talk; it heard an order.
This is the #1 friction of agentic coding: the AI reads exploratory messages as commands, and acts on inferred scope. Hold Up is the brake. It catches the AI mid-sprint, before the wrong action, and trades one clarifying turn for the rework-and-trust cost of building the wrong thing.
Why
AI coding tools are biased toward action. Ambiguity gets resolved by doing, not asking — because doing looks helpful. But a question costs one turn; a wrong action costs the rework, the cleanup, and a chunk of your trust that it understood you. The asymmetry is brutal and one-directional.
The failure isn't "the AI is dumb." It's that it can't tell discuss-mode from do-mode, so it defaults to do. Hold Up installs the missing check: is this person asking me to act, or thinking out loud? — run before any non-trivial action, not after.
How it differs from grill-me and PLAN mode
grill-me = a deliberate, invoked, exhaustive interview. You summon it to walk the entire design tree before a big build. Heavyweight, on-demand.- PLAN mode = "design the implementation, don't edit yet." Still assumes you've decided to build.
- Hold Up = automatic, reflexive, one question. It fires itself when it smells discuss-mode, asks the single thing it needs, and either releases or escalates. Lightweight, always-on.
The chain: Hold Up catches "wait, do you even want me to build?" → if yes and it's big → escalate to grill-me → then build. Hold Up is the front door; grill-me is the interrogation room.
When to use
Explicit
Say /hold-up, "just talk", "don't action this", "let's think first", "discuss before you build", "wait wait".
Auto-fire (the real value — add to your CLAUDE.md)
Fire Hold Up automatically when both are true:
- A non-trivial action is about to happen — an edit, commit, file creation, handoff, deploy, schema change, or running a workflow/script.
- Discuss-mode cues are present:
- hedge words: "i think", "maybe", "should we", "wydt", "tbh", "kinda"
- a question with no imperative verb ("can this be done per-project?" not "do it per-project")
- the user is mid-decision, weighing options, or thinking out loud
- no clear "build X" / "fix Y" / "do Z" instruction
Don't fire for: a clearly-scoped request with a full picture ("add a unique constraint to the users table"), trivial reversible actions (config tweak, log read, rename), or when the user already said "just do it" / "go" / "quick". Over-firing into clarification-spam is its own failure — the guard against it is this list.
The brake (run before any non-trivial action)
Four checks, in order:
1. Mode — discuss or do?
Scan for the cues above. No imperative verb + a hedge + a question = discuss. A clear "do X" with a full picture = do.
2. Picture — full, or am I inferring something load-bearing?
Is there a detail I'd have to guess to act — a file path, a target, a value, which-of-three-things-they-mean? If the guess is load-bearing, I don't get to make it silently.
3. Asymmetry — when unclear, one question beats one wrong action
A clarifying question costs one turn. A wrong action costs rework + cleanup + trust. Unclear ⇒ ask. Always.
4. Keep speed — clear do + full picture ⇒ release immediately
If it's a scoped, reversible "do X" and the picture's complete: act, no ceremony. Hold Up is a brake, not a tax. Don't slow down clean requests.
Output (in hold-up, you produce a READ — never an action)
- My read of the ask — 1–2 lines, what I think you're actually asking
- The fork — the decision as I see it, or 2–3 options
- ONE tight question — the single thing that unblocks (not a questionnaire)
- What I'd do once you confirm — so the release is instant
Then stop. Wait for the go.
Release
The user gives the go — "go", "yea", "do X", or answers the question → act immediately.
- If the confirmed build is big → escalate into a
grill-me session.
- If it's just a decision → stay in hold-up, resolve it, move on.
The honest caveat
A skill is pulled — it can't fully catch "I acted before you stopped me," because by the time the skill loads, the action may already be mid-flight. So Hold Up is the manual brake + self-catch nudge. The always-on enforcement is the CLAUDE.md rule below — that loads every session with no trigger, so it's the seatbelt, not the airbag.
Add to your CLAUDE.md
### Hold-up reflex
Before any non-trivial action (edit / commit / handoff / deploy / run a workflow),
check the request mode:
- Discuss-mode cues ("i think", "should we", "wydt", "tbh", a question with no
imperative verb, user mid-decision) → DON'T act. Output: your read of the ask +
the fork + ONE tight question. Release on the user's go.
- Clear "do X" + full picture + reversible → just do it, no ceremony.
When unclear, one question beats one wrong action — the asymmetry is one-directional.
Output discipline
When fired: the read, the fork, the one question, the what-i'd-do-next. Nothing else. No preamble, no action. The whole point is to not do the thing yet.
