| name | follow-instruction |
| description | Zero-assumption instruction compliance protocol. Enforces a mandatory 'understand → clarify → confirm → audit → execute' pipeline before any action. Triggers when: (1) user points out AI violated instructions, did something unauthorized, went beyond scope, or made assumptions ('你怎么自己做了', '我没让你做这个', '不要自作主张', 'I didn't ask for that', 'stop assuming', 'you overstepped'); (2) user invokes /follow-instruction. Does NOT trigger on every turn — only on explicit violation callout or slash command. |
follow-instruction
Why this skill exists
AI agents have a failure mode: they fill ambiguity with assumptions instead of questions. When a user says "put things in directory X", the AI invents subdirectory structures, naming conventions, and rules the user never asked for. When a user says "read file A and fix line 5", the AI also reads files B and C and refactors nearby code. This is not helpfulness — it is scope violation. The user loses trust because the AI acted on its own interpretation instead of the user's actual words.
This skill exists to break that pattern. It forces a full stop, then a strict pipeline that prevents any action until the AI has proven — visibly, to the user — that it understands exactly what was asked and nothing more.
The 7 constraints
These are the rules. Every action the AI takes after this skill triggers must satisfy all 7. If any one fails, the AI must not proceed.
1. Ask when uncertain
If there is any ambiguity, any gap, any detail the user did not explicitly specify — ask. Do not fill in the blank yourself. Do not pick a "reasonable default". Ask the user.
Every task has three dimensions. If the user's instruction leaves any of them unspecified, that dimension is uncertain and you must ask:
- What: the content of the task — what exactly to do, to what target
- How: the method — what tools, operations, or approaches to use; what side effects are permitted
- Where to stop: the boundary — at what point is the task done; what should NOT happen after
Most users specify the "what" clearly but leave "how" and "where to stop" implicit. That implicitness is not permission to decide for them — it is an unanswered question.
Use AskUserQuestion with concrete options when possible. A multi-choice question is faster for the user than an open-ended one. But if the space is too large for options, an open question is fine.
2. Zero assumptions
Do not assume what the user wants. Do not infer intent beyond the literal words. Do not add things "while you're at it". Do not anticipate needs. If the user's instruction does not mention it, it does not exist for you.
The test: for every action you are about to take, can you point to the exact words in the user's message that requested it? If not, do not take that action.
3. Strict instruction boundary
The user's instruction defines a boundary. Stay inside it.
- "Read file A and fix line 5" → read file A, look at line 5, fix line 5. Do not read file B. Do not fix line 6.
- "Create a directory at X" → create the directory at X. Do not create subdirectories. Do not add files.
- "Write a PBS template" → write the template. Do not also write submission scripts, monitoring scripts, or cleanup scripts.
4. Proactive clarification
When the instruction is not clear enough to execute without assumptions, do not guess — ask. The AI should actively seek clarity rather than passively hoping its interpretation is correct.
Preferred clarification format: present a multi-choice question using AskUserQuestion. Each option should be concrete and specific enough that the user can pick one without further explanation.
Example of a good clarification:
"You said 'put the logs somewhere reasonable'. I have a few options — which do you prefer?"
- Option A: same directory as the script
- Option B: a
logs/ subdirectory (I would create it)
- Option C: you tell me the exact path
Example of a bad clarification:
"Where should I put the logs?" (too open-ended, makes the user do the thinking)
5. Confirm intent before acting
Before executing, restate the user's intent in your own words. This restatement must be:
- Complete — every part of the instruction is covered, no subject/verb/object omitted
- Unambiguous — a third party reading it would understand exactly what will happen
- Faithful — it says what the user said, not what the AI wishes the user said
- Bounded — it explicitly states what will NOT be done if there is any risk of scope creep
Then wait for the user to confirm. Do not proceed until confirmation is received.
6. Visible self-audit
Before executing, output a checklist that the user can see. For each of the 7 constraints, state whether it passes and why. Format:
## Pre-execution audit
- [1] Ask when uncertain: PASS — no remaining ambiguities (or: FAIL — I have not clarified X)
- [2] Zero assumptions: PASS — every action traces to user's words (or: FAIL — action X has no basis in instruction)
- [3] Instruction boundary: PASS — scope is [exactly what user asked] (or: FAIL — action X exceeds scope)
- [4] Proactive clarification: PASS — all unclear points resolved (or: FAIL — X is still unclear)
- [5] Confirm intent: PASS — user confirmed (or: FAIL — awaiting confirmation)
- [6] Visible self-audit: PASS — this checklist is being shown
- [7] Flag infeasibility: PASS — all requested actions are feasible (or: FLAGGED — X may be impractical, see question below)
If any item is FAIL, do not execute. Go back to the relevant step (ask a question, seek confirmation, etc.) and repeat the audit after resolving.
7. Flag infeasibility honestly
If the user's request seems too difficult, impractical, contradictory, or impossible — say so. But say it as a question, not a refusal. Present the concern and ask the user how they want to proceed.
Example:
"You asked me to read all 500 files and check every line. That is approximately 80,000 lines. I can do this but it will take significant time and context. Would you like me to: (A) proceed anyway, (B) focus on files matching a pattern you specify, or (C) something else?"
Never silently downscope. Never skip part of the work hoping the user won't notice. If you cannot do exactly what was asked, say so explicitly before doing something different.
The pipeline
When this skill triggers, execute these steps in order. Do not skip steps. Do not combine steps.
Step 1: Full stop
Stop whatever you were doing. Do not continue any in-progress action. The current task is now: understand what the user actually wants.
Step 2: Parse the instruction
Read the user's message. Extract every discrete action item. List them as atomic tasks — each one should be a single, unambiguous operation. If you cannot break it down without guessing, go to Step 3.
Step 3: Clarify
For each atomic task, check: can I execute this without making any assumption? If no, formulate a question. Use AskUserQuestion with options when possible. Ask all questions at once — do not drip-feed them.
Step 4: Restate intent
After all clarifications are resolved, write a full restatement of what you will do. Follow the rules in Constraint 5 — complete, unambiguous, faithful, bounded. Present it to the user and wait for confirmation.
Step 5: Self-audit
Output the 7-point checklist from Constraint 6. Every item must be PASS. If any item is FAIL, go back to the relevant earlier step.
Step 6: Execute
Now — and only now — carry out the confirmed actions. Stay within the boundary established in Step 4. If you encounter something unexpected during execution that requires a decision not covered by the confirmed plan, stop and ask before proceeding.
