A3 Elicitation — Asking The Reviewer What It's Unsure Of

Learning objective

(Bloom's: Analyze) Solicit Claude's own read on the item-2/3/5 human-owned boundary you drew in lesson 3 — its proposed fix, its stated uncertainty, and where it disagrees with you — and analyze the divergence as data rather than noise, on your real calculate_fee() fix and your real subagent scope — AIHC.2.A3 (Elicitation).

Work at hand: lesson 3 drew a line: items 1/4/6 delegated, items 2/3/5 human-owned. That line was Maya's call. Today, before treating it as final, you ask Claude for its own read — first on the fix itself, then on the boundary you drew.

SSD cycle 1 — plan mode is "what would you do," made structural

• SAY: AIHC.2.A3 asks you to make elicitation routine, not a one-off courtesy. Claude Code already has a mechanism built for exactly this: plan mode proposes an approach and makes no edits until you approve it — which means every plan-mode session is a structured "what would you do?" before anything ships.
• SEE: Doc-set §2/§3, verbatim on the mechanism: "claude --permission-mode plan (or Shift+Tab mid-session) — Claude reads and proposes but makes no edits until approved; status bar shows ⏸ plan mode on." Next to it, a plan-mode transcript excerpt for your real bug: ``` ⏸ plan mode on

  Fix calculate_fee() per the contract: Decimal arithmetic, explicit rounding mode.

I see two ways to satisfy the contract: (a) Decimal(str(amount)) * Decimal("0.02"), quantize to 2 places, ROUND_HALF_UP (b) Decimal(amount) directly if callers already pass Decimal, skipping the str() step I'm not fully sure which callers currently pass — invoice.py calls calculate_fee() with a float literal in one place. Want me to check callers first, or apply (a) defensively? ``` - DO: Run your real fix in plan mode (or draft the prompt you'd give it) using your cycle-1 contract from lesson 2. Before approving anything, write down: what did it propose, and what did it say it was unsure about? That uncertainty line is the elicitation — it's the whole point of asking before committing.

SSD cycle 2 — the caller Claude flagged is exactly the boundary question

• SAY: Notice what the transcript above surfaced on its own: invoice.py calling calculate_fee() with a float. That's not something your cycle-1 contract scoped (it named src/payments/fees.py only) — and it's Claude telling you, unprompted, where its own confidence runs out. AIHC.2.A3 says: treat that as working input, not a courtesy remark to nod at.
• SEE: A one-line elicitation prompt, and what asking it directly gets you: "Before you finalize: what are you least confident about in this fix, and why?" — versus not asking at all and simply accepting option (a) or (b) without ever learning invoice.py exists.
• DO: Actually ask that question against your real session (or, if working from the transcript above, treat its caller-uncertainty line as the answer). Write one sentence: does this uncertainty change your cycle-1 contract's scope? (Don't act on it yet — lesson 5 is where you verify whether invoice.py is actually broken. Today you're only recording that the question was asked and answered.)

SSD cycle 3 — ask the boundary question too, not just the bug question

• SAY: Elicitation isn't only for code fixes — AIHC.2.A3 names surfacing open questions at defined checkpoints generally. Lesson 3's item-2/3/5 boundary was your call. A defined checkpoint before shipping that boundary is: ask Claude whether it agrees, and log the answer either way — a surviving disagreement is data, not a defeat for either side.
• SEE: A call-and-response framing of the ask (one line out, one line back — nothing mysterious about the shape of it): YOU: "I've drawn the line: items 1/4/6 to the reviewer subagent, 2/3/5 stay human-owned. Where would you draw it differently, if anywhere?" CLAUDE: "Item 6 (secrets grep) is mechanical, agreed. Item 4 (PII in logs) is mostly mechanical too, but 'PII' can require judgment on borderline fields — I'd flag rather than auto-clear item 4, same as you're already doing for 2/3/5."
• DO: Ask this exact boundary question against your real subagent scope from lesson 3. Record the answer verbatim (or draft the prompt if not running it live). Where it agrees with your line, note that. Where it diverges — like the item-4 nuance above — don't silently overrule it or silently adopt it: write down the divergence and your decision, with the reason, so it's inspectable later.

Independent at-bat

Pick one item from your backlog you haven't elicited on yet (the API-contract diff, item 2, is a good candidate — it's your most judgment-heavy human-owned item). Ask Claude for its own read on what "breaking" means for that specific endpoint change, before you decide alone. No worked example this time: frame the question yourself, and decide on your own whether the answer changes anything about your item-2 handling from lesson 3.

Exit ticket

(Graded against your own elicitation transcripts/drafts and the doc-set — never against whether Claude's proposal "sounded" confident.)

1. (Remember) What did the plan-mode transcript in cycle 1 say it was unsure about?
2. (Understand) Why does AIHC.2.A3 call unprompted uncertainty "working input" rather than something to politely ignore?
3. (Apply) Claude's boundary answer (cycle 3) suggested flagging item 4 instead of trusting it fully. Write the one-line change to your review-checklist.md note that would apply that.
4. (Analyze) Compare your own item-2/3/5 boundary line to Claude's response in cycle 3: where exactly did it diverge, and is that divergence something you're adopting, logging-but- overruling, or still deciding? Defend your answer.
5. (Evaluate) Judge cycle 1's plan-mode session against AIHC.2.A3's "routine and structural" bar: was this a one-off ask, or could you make it a habit on every payments-service fix going forward — what would have to be true for it to be routine rather than occasional?

ledger_write

ledger_write:
  learner_id: L1-DEV-MAYA
  lesson_id: L1-dev-maya-04-a3-elicitation
  anchors: [AIHC.2.A3]
  bloom_reached: Analyze
  exit_ticket_score: ""
  auto_score: ""
  self_score: ""
  calibration_gap: " — computed once Maya's self_score exists"
  starting_mastery:
    AIHC.2.A3: "not previously evidenced — first measurement this lesson"
  journal_prompt: >
    Cycle 1's transcript surfaced invoice.py on its own, before you asked anything. Would you
    have caught that caller without running plan mode first — and what does your honest answer
    tell you about how much elicitation is currently doing for you versus how much you assume
    your own reading catches?
  structure_used: PBL
  referents_used: [salsa-call-and-response]
  next_lesson_seed: >
    Lesson 5 verifies, for real, whether invoice.py's float-calling caller (surfaced here) is
    actually broken — against the contract's own test, not against what either Maya or Claude
    predicted in this lesson.

RUBRIC SELF-AUDIT

Escalation: all load-bearing indicators PASS → auto-ships (Playbook §5, AIHC X2/B3).