core/capabilities/elicitation/deep-elicit/SKILL.md
Comprehensive requirements elicitation through Socratic conversation, producing a product brief with problem, users, scope, and success criteria in ~10 minutes. Use when starting a new product, designing a system from scratch, planning a major redesign, or when the user says "I want to build", "new project", or "help me plan this product".
npx skillsauth add xoai/sage deep-elicitInstall this skill globally with one command. Works with Claude Code, Cursor, and Windsurf.
3 of 9 scanners reported clean
Some scanners were skipped, did not run, or reported a non-clean status. Review each row below.
Guide the human through comprehensive discovery of what they're building and why. Not a form to fill — a conversation that surfaces the important decisions.
Core Principle: The most expensive bugs are requirements bugs. Spending 10 minutes on elicitation saves days of rework. But spending 60 minutes loses the human's attention. Be thorough AND efficient.
ARCHITECT mode, before architecture or planning. When:
Do NOT use when:
quick-elicit instead — faster, less thorough)Start with the WHY, not the WHAT. Ask:
"What problem are you solving? Who has this problem?" Get the core pain point and who feels it. "I want to build a task app" is not enough — "My team loses track of client deliverables across 5 projects" is better.
"What happens if this problem isn't solved? What are people doing now?" Understand urgency and current alternatives. This grounds the conversation in reality — are people using spreadsheets? A competitor? Nothing?
"What does success look like in 3 months?" Concrete, measurable. Not "users love it" but "50 active teams managing projects, 80% weekly retention."
Draft and show:
PROBLEM BRIEF:
Problem: [specific pain point]
Who: [target users — be specific]
Current alternative: [what they do today]
Success: [measurable 3-month goal]
"Does this capture the real problem? Anything to adjust?"
Premise challenge (after Problem Brief is confirmed):
Before moving to Round 2, surface 2-3 implicit premises in the user's framing. Present as brief observations:
Before we scope this — I see a few assumptions worth examining:
1. [Premise]: [one sentence stating the assumption]
→ [one sentence describing why it might be wrong]
2. [Premise]: [one sentence stating the assumption]
→ [one sentence describing why it might be wrong]
3. [Premise]: [one sentence stating the assumption]
→ [one sentence describing why it might be wrong]
Do these hold, or should we adjust our framing?
deep-elicit can challenge 2-3 premises (vs. quick-elicit's 1-2) because the architect workflow operates at higher stakes and the user expects a more thorough examination.
What counts as a premise: The framing of the problem itself, the assumed solution category, the assumed scope, the assumed user, the assumed timeline. NOT technical choices — those come in Round 2/3.
Record the framing decision in the brief's Vision section and
prepend to .sage/decisions.md:
### YYYY-MM-DD — Framing: [initiative]
[Chose framing]. Pain: [pain]. Challenged: [premise names].
(deep-elicit Round 1)
Now narrow from problem to solution:
"If you could only ship THREE features for launch, what are they?" Forces ruthless prioritization. Everything else is post-launch.
"What should this explicitly NOT do? What's tempting but out of scope?" Boundaries prevent scope creep. "We won't build a mobile app for v1" is a useful constraint.
"Are there constraints I should know? Budget, timeline, team size, compliance, existing systems to integrate with?" Non-functional requirements surface here — security, performance, scale, accessibility, regulatory.
Draft and show:
SCOPE:
Must have (launch): [3 features]
Won't have (v1): [explicit exclusions]
Constraints: [non-functional requirements]
"Walk me through the most important user flow, step by step." Get the happy path. "User signs up → creates a project → adds tasks → assigns to team → dashboard shows status." This becomes the architecture driver.
"Who else uses this besides the primary user? (admin, viewer, API consumer?)" Multiple user types = different permission models, different UI surfaces.
"What's the most complex or risky part of this?" The human usually knows where the dragons are. This is where architecture attention should focus.
Draft and show:
USERS:
Primary: [who, what they do]
Secondary: [other user types]
KEY FLOW:
1. [step] → 2. [step] → 3. [step] → ...
HIGH RISK AREAS:
- [identified complexity]
Combine all rounds into .sage/work/<YYYYMMDD>-<slug>/brief.md:
# Product Brief: [name]
## Problem
[from Round 1]
## Users
[from Round 3]
## Success Criteria
[measurable, from Round 1]
## Scope
### Must Have (Launch)
[from Round 2]
### Won't Have (v1)
[from Round 2]
## Key User Flow
[from Round 3]
## Constraints
[from Round 2]
## High Risk Areas
[from Round 3]
Show the complete brief. Wait for approval. "Here's the product brief. This is the foundation for architecture and planning. Ready to proceed, or anything to adjust?"
MUST (violation = bad brief or lost trust):
SHOULD (violation = suboptimal elicitation):
MAY (context-dependent):
tools
Captures agent mistakes, corrections, and discovered gotchas so they are not repeated. Use when: (1) a command or operation fails unexpectedly, (2) the user corrects the agent, (3) the agent discovers non-obvious behavior through debugging, (4) an API or tool behaves differently than expected, (5) a better approach is found for a recurring task. Also searches past learnings before starting tasks to avoid known pitfalls. Activate alongside the sage-memory skill — they share the same MCP backend but serve different purposes (sage-memory = codebase knowledge, sage-self-learning = agent mistakes and gotchas).
development
Typed knowledge graph stored in sage-memory. Use when creating or querying structured entities (Person, Project, Task, Event, Document), linking related objects, checking dependencies, planning multi-step actions as graph transformations, or when skills need to share structured state. Trigger on "remember that X is Y", "what do I know about", "link X to Y", "show dependencies", "what blocks X", entity CRUD, cross-skill data access, or any request involving structured relationships between things.
tools
Integrates sage-memory into Sage workflows. Teaches the agent when to remember (store findings during work), when to recall (search memory at session start and task start), and how to learn (structured knowledge capture via sage learn). Use when the user mentions memory, remember, recall, learn, capture knowledge, onboard to codebase, or when starting any session where sage-memory MCP tools are available.
tools
Captures agent mistakes, corrections, and discovered gotchas so they are not repeated. Use when: (1) a command or operation fails unexpectedly, (2) the user corrects the agent, (3) the agent discovers non-obvious behavior through debugging, (4) an API or tool behaves differently than expected, (5) a better approach is found for a recurring task. Also searches past learnings before starting tasks to avoid known pitfalls. Activate alongside the sage-memory skill — they share the same MCP backend but serve different purposes (sage-memory = codebase knowledge, sage-self-learning = agent mistakes and gotchas).