/elicitation

name: elicitation
description: "Use when an expert agent self-reviews and self-corrects code after the Execute phase, before sniper validation (BMAD-METHOD elicitation techniques)."
argument-hint: "[--auto | --manual]"
color: purple
user-invocable: false

<objective> Elicitation lets an expert agent self-review and self-correct its own code before external validation, drawing on 75 elicitation techniques across 12 categories (code quality, security, performance, architecture, testing, docs, UX, data, concurrency, integration, observability, maintainability) inspired by BMAD-METHOD. Two modes control how techniques are chosen: AUTO (default, auto-detected and applied silently) and MANUAL (only when the owner asks: the owner picks from 5 presented options). eLicit is never skipped.

It sits between Execute and Verify/eXamine in the APEX flow, scores itself against an exit threshold (>=90% proceed, 70-89% document gaps, <70% iterate), reports its verdict in the agent REPORT, and — when it must persist — writes `docs/verify/elicit-<branch-slug>.json` (never under `.claude/`) so a later pass can diff against prior verdicts instead of restarting. </objective>

Elicitation Skill

Purpose

Enable expert agents to **self-review and self-correct** their code before external validation (sniper). Based on BMAD-METHOD's 75 elicitation techniques.

---

2 Execution Modes

Mode 1: AUTO (default, --auto)

Expert auto-detects code type → Auto-selects techniques → Applies silently

Mode 2: MANUAL (--manual, only when the owner asks)

Expert presents 5 relevant techniques → Owner chooses → Expert applies

There is no skip mode: eLicit runs on every APEX task, before Verify and eXamine.

---

Quick Start

**After Execute phase, expert runs:**

# Auto mode (default, no prompts)
> Apply elicitation skill

# Manual mode (owner asked to choose)
> Apply elicitation skill --manual

---

Workflow Overview

┌─────────────────────────────────────────────────────────┐
│              ELICITATION WORKFLOW                       │
│                                                         │
│  Step 0: Init           → Load context                 │
│  Step 1: Analyze Code   → Detect code type             │
│  Step 2: Select         → Choose techniques (or auto)  │
│  Step 3: Apply Review   → Execute techniques           │
│  Step 4: Self-Correct   → Fix own issues               │
│  Step 5: Report         → Summary before sniper        │
└─────────────────────────────────────────────────────────┘

---

Auto-Detection Matrix

| Code Type Detected | Auto-Selected Techniques | |--------------------|--------------------------| | Authentication/Security | Security Audit, OWASP Check, Input Validation | | API Endpoints | Error Handling, Type Coverage, API Contracts | | Database/ORM | N+1 Detection, Migration Safety, Data Integrity | | UI Components | Accessibility, Edge Cases, Loading States | | Business Logic | SOLID Compliance, Unit Test Coverage, Edge Cases | | Refactoring | Breaking Changes, Regression Analysis, Backward Compat | | Performance Critical | Profiling, Memory Analysis, Complexity Check | | Config/Docs/Plugin files (`.md` agents/skills, `hooks.json`, frontmatter YAML) | CQ-01, DOC-01, INT-01 + validation by the **strictest parser in the consumption chain** (e.g. `js-yaml` strict for frontmatter, `json.tool` for JSON) -- never "looks well-formed" |

---

Technique Categories (12)

Full catalog: `references/techniques-catalog.md`

1. **Code Quality** (7): Code review, Pattern detection, Complexity analysis... 2. **Security** (7): OWASP audit, Input validation, Auth check... 3. **Performance** (6): Profiling, N+1 detection, Memory analysis... 4. **Architecture** (6): SOLID check, Dependency analysis, Coupling review... 5. **Testing** (6): Edge cases, Boundary testing, Error paths... 6. **Documentation** (6): API review, Comment check, Type coverage... 7. **UX** (6): Accessibility, Error messages, Loading states... 8. **Data** (6): Schema validation, Migration safety, Data integrity... 9. **Concurrency** (6): Race conditions, Deadlock analysis, State sync... 10. **Integration** (7): API contracts, Backward compat, Breaking changes... 11. **Observability** (6): Logging, Metrics, Error tracking... 12. **Maintainability** (6): Readability, Naming, File organization...

**Total: 75 techniques**

---

Integration with APEX

A-nalyze → P-lan → E-xecute → [ELICIT] → X-amine
                       │          │           │
                       ▼          ▼           ▼
                    Expert    Expert       sniper
                     code    self-review   (final)

**Benefits:**

• Expert catches own mistakes before sniper
• Faster validation (less sniper corrections)
• Knowledge retention (expert learns from self-review)

---

Forbidden

• ❌ Skip init step (must load context)
• ❌ Apply techniques without understanding code type
• ❌ Self-correct without documenting changes
• ❌ Report without listing applied techniques
• ❌ Use techniques outside expertise domain

---

Exit Criteria (Step 5: Report)

**Score** = techniques applied / techniques selected, weighted by critical category (Security, Architecture).

| Score | Status | Action | |-------|--------|--------| | ≥ 90% | 🟢 | Proceed to sniper | | 70-89% | 🟡 | Document gaps, then proceed | | < 70% | 🔴 | Iterate before sniper |

**Self-correction failure**: If a self-correction breaks the code → revert that correction and keep the finding as a report item instead.

---

Artifact Contract

Step 5 puts the verdict in the agent REPORT and, when it must persist, writes `docs/verify/elicit-<branch-slug>.json` (never under `.claude/`, which the harness protects) so a later pass diffs against prior verdicts instead of restarting from scratch. Full contract, `<branch-slug>` derivation, and JSON schema: `references/artifact-contract.md`.

---

Steps Reference

| Step | File | Purpose | |