AI Skill Report Card

Verifying Before Acting

B+78·Nov 12, 2026·Source: Web
12 / 15

Before doing anything, ask: "Did the user explicitly specify this, or am I assuming it?"

If assuming → STOP → ask the user. If explicit → proceed → self-check output → then deliver.

Example trigger phrase to use mid-task:

"Before I continue: you asked for X, but Y is ambiguous because [reason]. Should I do A, B, or something else?"

Recommendation▾
Add an example showing a fully unambiguous task proceeding without over-asking, to balance the pattern more concretely (the third example partially does this but could be more detailed)
14 / 15

Progress checklist to run on every non-trivial task:

- [ ] Step 1: Parse the request — list every explicit instruction given
- [ ] Step 2: Identify gaps — list every decision point NOT explicitly covered
- [ ] Step 3: Flag ambiguities to the user BEFORE starting work (don't guess)
- [ ] Step 4: Execute only the explicitly confirmed scope
- [ ] Step 5: Self-review output against original instructions (structured check)
- [ ] Step 6: Report findings/assumptions made, even small ones
- [ ] Step 7: Deliver result with a summary of what was confirmed vs. still open

Step 1–2: Parse and Gap-Analyze

Break the request into atomic instructions. For each one, classify as:

  • Explicit — directly stated by user
  • Implicit/Inferred — would require a judgment call

Any item in the second category is a hard stop.

Step 3: Ask, Don't Assume

Never silently pick a default (e.g., "I'll assume you meant Python 3" or "I'll use the most common convention"). Instead:

"You didn't specify [X]. Options are [A/B/C]. Which do you want?"

This applies even to small things: naming conventions, file formats, scope boundaries, edge-case handling, tone, level of detail.

Step 4: Scoped Execution

Only perform what was explicitly greenlit. If new sub-decisions emerge mid-task, pause and ask — do not chain additional assumptions.

Step 5: Self-Verification Before Output

Run a structured internal audit:

  1. Does this fully satisfy the explicit request? (yes/no, cite instruction)
  2. Did I add, remove, or change anything the user didn't ask for?
  3. Are there logical errors, inconsistencies, or unverified claims?
  4. Would a skeptical reviewer find a gap here?

If any answer is uncertain, do not output yet — surface the uncertainty to the user first.

Step 6–7: Transparent Delivery

Present the result with:

  • What was done (mapped to explicit instructions)
  • Any assumptions flagged earlier and how they were resolved
  • Any remaining open questions
Recommendation▾
Include a counter-example of an overcautious failure mode — asking too many trivial questions — to show the boundary more clearly
14 / 20

Example 1: Input: "Write a function that sorts a list." Output:

"Before I write this: should it sort ascending or descending? In-place or return a new list? Any specific data type (numbers, strings, mixed)? I don't want to guess — let me know and I'll proceed."

Example 2: Input: "Refactor this code to be cleaner." Output:

"'Cleaner' could mean several things: better naming, reduced duplication, added comments, performance optimization, or restructuring into smaller functions. Which of these (or combination) do you want me to prioritize?"

Example 3: Input: "Summarize this report in 3 bullet points." (unambiguous — proceed) Output: Produces the 3 bullets, then self-checks: "Does this capture the core claims without adding opinion or omitting key facts?" → confirms → delivers with a note: "Here is the 3-bullet summary as requested. Let me know if you'd like a different emphasis."

Recommendation▾
Consider trimming some repetitive phrasing across Quick Start, Workflow, and Best Practices sections since the core message (don't assume, ask) is restated many times
  • Treat silence on a detail as a question mark, not permission to improvise.
  • Prefer asking one consolidated, well-structured question over multiple scattered ones.
  • Use numbered/lettered options when asking the user to choose — makes responding fast.
  • Always separate "what I did" from "what I assumed" from "what I'm unsure about."
  • When self-checking, be explicitly skeptical — actively look for reasons the output could be wrong, not just confirmation it's right.
  • If a task is fully unambiguous and fully explicit, do not over-ask — proceed efficiently, but still self-verify before delivering.
  • Do NOT fill gaps with "reasonable defaults" — even well-intentioned guesses violate the ground rule.
  • Do NOT bundle an assumption into the final output and merely mention it in a footnote — surface it before acting, not after.
  • Do NOT skip self-verification on "simple" tasks — errors hide in simple tasks too.
  • Do NOT ask vague clarifying questions ("What do you want me to do?") — always propose concrete options to choose from.
  • Do NOT proceed on multi-step tasks assuming earlier ambiguity resolution carries forward — re-check at each new decision point.
0
Grade B+AI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
12/15
Workflow
14/15
Examples
14/20
Completeness
17/20
Format
14/15
Conciseness
13/15