One question at a time

one-question-at-a-time

The micro-pacing prosthetic. Stops the agent from flooding the operator with stacked decisions in a single turn. Stacked decisions spike cognitive load. Multiple decisions at once stall the thread.

When to use

• Drafting a response that contains a ? paired with an action verb tied to operator authorization
• After the operator answers a queued question — pop and emit the next one
• When the operator says any trigger phrase ("one at a time", "stop stacking", etc.) — surface the queue if any, then enforce going forward

NOT for

• Explanatory clarifications about what the operator just asked ("What did you mean by X?")
• Single-question turns
• Operator-asked questions to the agent (this skill gates agent → operator only)
• Multiple-choice presented as one question with options inline ("A or B?")

The rule

Before sending any draft response that contains a decision question, run the gate. If the gate finds more than one decision question, emit only the first, push the rest to the queue file, and tell the operator one queued question is waiting (count only, never preview the queue contents).

Decision question = anything that asks the operator to authorize, choose, or commit. Examples: "Delete X?", "A or B?", "Approve?", "Green light?", "Run it?", "OK to push?", "Want me to do Y?".

Worked example

Draft (stacked, BAD):

Done. Approve the rebuild? Want me to push the commit? Should I delete the backup?

After gate (count=3, queued=2):

Done. Approve the rebuild?

(2 more queued; will surface after this one.)

State file $OQAT_QUEUE_DIR/<session-id>.json:

["Want me to push the commit?", "Should I delete the backup?"]

When operator replies "yes" → emit next: "Want me to push the commit?" + queue length update.

Deterministic helper

scripts/one-question-at-a-time.mjs provides a pure function run({draft, queuePath}):

1. Counts decision questions using a question-and-action-verb heuristic.
2. If count > 1: returns {emit, queued, count}. emit is the draft with Q2..Qn stripped; queued is the array of stripped questions.
3. Persists queued to queuePath (one file per session, appends to existing array).
4. Returns {emit: draft, queued: [], count: 0|1} for passthrough.

CLI: bun scripts/one-question-at-a-time.mjs <queue-path> < draft.txt prints JSON result to stdout. If <queue-path> is omitted, defaults to $OQAT_QUEUE_DIR/queue.json, falling back to ${XDG_STATE_HOME:-$HOME/.local/state}/oqat/queue.json.

Verification

After applying the gate to any draft:

• Output contains exactly one ? from a decision question (others can be explanatory)
• Trailing line _(N more queued; ...)_ present iff count > 1
• Queue file at writes_to exists and is valid JSON array of strings
• Operator reply pops from front, not back

Run on a sample draft:

echo 'Done. Approve A? Run B? Push C?' | bun scripts/one-question-at-a-time.mjs /tmp/q-test.json
cat /tmp/q-test.json

Expected: count: 3, queued.length: 2, persisted file contains ["Run B?", "Push C?"].

Output scorecard

Score any agent turn that hit a stacked-decision draft:

1. Was Q2..Qn actually stripped from the user-facing emit? (yes/no)
2. Was the trailing queued-count line present? (yes/no)
3. Was the queue file written and valid JSON? (yes/no)
4. On the next operator reply, was the next queued question popped and emitted? (yes/no)
5. Did the agent preview queued question text in the user-facing emit? (must be NO)

Pass = all 1–4 yes, 5 no.

Dependencies

Required:

• Bun runtime (script is .mjs, executed via bun)
• Filesystem write access to the queue directory (env: OQAT_QUEUE_DIR, default $XDG_STATE_HOME/oqat/ or ~/.local/state/oqat/)
• Conversation context across turns (any agent harness with multi-turn memory)

Companion skills (concepts from the same stack; only checkpoint is published so far):

• checkpoint — ephemeral state pulse; visible dashboard, not a gate.
• memory-pulse — orthogonal macro-orientation prosthetic; surfaces live thread + drift. Do not conflate.
• accordion — compresses a closed thread into memory; runs at thread close, not mid-turn.

Tests:

• test/one-question-at-a-time.test.ts — unit tests for detector + run()
• test/e2e/one-question-at-a-time.e2e.test.ts — subprocess E2E

Known Limitations & Gotchas

• No pre-output hook in Claude Code today. This skill is enforced at draft-time by agent self-checking. If a pre-assistant-output hook ships, promote from discipline-as-skill to hook-enforced gate. (Update CLAUDE.md trigger and remove the self-check burden.)
• Detector is regex, not LLM. False positives bias toward over-sequencing — the safe failure mode. False negatives (a stacked decision phrased without action verbs or decision phrases) slip through. Iterate on the verb/phrase lists when one slips.
• Queue scoping is per-session. No global queue. Session ID must be deterministic per session — current implementation expects caller to pass queuePath. If the caller picks a path that collides across sessions, queues will merge.
• Macro orientation is a different prosthetic. "Show me the to-do list so I can follow" is not this skill. See memory-pulse and checkpoint.
• Operator-asked questions are out of scope. This gate is one-directional: agent → operator only. Operator → agent stacking is fine.

Observability

If your stack has an event bus, emit when the gate trims questions. Fire-and-forget. Example shape (adapt to your own emitter):

emit-event.sh one-question-at-a-time oqat_trimmed "<count> decisions detected" "queued=<n> session=<id>"

Lifecycle:

• oqat_trimmed — gate fired and stripped Q2..Qn. Subject: count summary. Body: queued=<n> session=<session-id>.
• oqat_popped — next queued question emitted on operator reply. Body: remaining=<n>.
• oqat_drained — queue empty after last pop. Body: empty.

Silent passthrough (count <= 1) does not emit. Only state changes hit the bus.

Origin

2026-04-30: a plain memory rule ("one question at a time") failed twice in a single session. The operator had to remind the agent both times. A rule the agent must remember to apply is not a gate. This skill is the structural version of that rule.

Cogpros primitive (micro pacing). Pollock 2026.