---

name: deep-ask description: This skill should be used when orchestrating rich human-in-the-loop question flows, building layered AskUserQuestion calls that respond to context (codebase, CLI tools, prior answers). Triggers include "ask me questions", "help me think through", "what should we consider", or complex tasks benefiting from interactive clarification.

deep ask

turn ambiguous tasks into clear specs through layered questions. context-first, progressive, feels like conversation not interrogation.

when to use

use	skip
multiple valid approaches	single obvious path
user says "ask me questions"	user gave detailed specs
need to understand preferences	quick fix needed
architectural trade-offs	user says "just do it"

workflow

1. gather context first

before asking anything, understand the landscape:

layer .
outline --callers=relevantFunction src/
git log --oneline -10
outline --diff=HEAD~3

never ask about things you could discover.

2. open broad

situation	opening
new feature	"what problem are we solving?"
refactor	"what's driving this change?"
bug fix	"how should this behave?"
architecture	"what trade-offs matter most?"

one question, 2-4 options, descriptions that reveal implications.

3. chain on answers

answer: "context-aware ack"
→ "what context signals should drive personalization?"

answer: "all of the above"
→ "how dynamic should the system be?"
→ meta: "is there anything about this approach that feels off?"

each question builds on prior responses. see references/question-archetypes.md.

4. tool discovery mid-flow

when user mentions something, verify:

# user mentions "auth module"
outline --callers=authenticate src/auth/

# user says "like the reaction agent"
fd -e ts . convex/agents | outline -c --search=reaction

report findings, ask refined questions based on what you learned.

5. meta questions

step back periodically:

• "does this direction feel right?"
• "what am i missing?"
• "is there prior art we should reference?"
• "should we prototype first?"

meta questions reveal unstated constraints.

6. synthesize

after 3-5 rounds:

based on your answers:
1. [key decision A]
2. [key decision B]
3. [approach C]

ready to proceed, or dig deeper on any point?

question design

headers (12 char max)

tight - they show as chips:

• "auth method" not "authentication methodology"
• "scope" not "project scope"

options (2-4)

• first option is recommended (add "(Recommended)")
• describe implications not definitions
• "other" is always available, don't add it

descriptions

bad: "JWT - JSON Web Tokens" good: "JWT - stateless, client stores token, easy to scale but harder to revoke"

multi-select

multiSelect: true when choices aren't mutually exclusive:

• "what context signals?" (can be all)
• "which features?" (can pick multiple)

pacing

depth	rounds	stop when
shallow	1-2	simple clarification
moderate	3-4	feature planning
deep	5-8	architecture decisions

stop signs: user says "that covers it", answers get redundant, clear path emerges, short impatient answers

continue signs: user says "dig deeper", answers reveal new dimensions, contradictions surface, user is vibing

CLI pairing

question	tool support
"where should this live?"	layer . + outline src/
"what's the current pattern?"	outline --search=pattern
"who uses this?"	outline --callers=X
"what changed recently?"	outline --diff=HEAD~5
"related issues?"	linear issue list --team X
"prior discussions?"	slack search "topic"

see references/cli-context-gathering.md.

references

• references/question-archetypes.md - question types and when to use
• references/conversation-patterns.md - multi-turn flow examples
• references/cli-context-gathering.md - tool integration patterns

anti-patterns

• asking blind: querying user before gathering context
• machine-gun: multiple questions without synthesis
• shallow options: yes/no when richer options exist
• ignoring answers: not building on prior responses
• over-asking: continuing past clear consensus
• corporate tone: "Would you prefer..." vs "which feels right?"
• missing meta: never stepping back to reflect