This skill should be used when the user says "brainstorm", "deep analysis", "let's think through", "analyze this with me", or "help me think through". Provides progressive deep analysis through one-by-one questioning with 2-3 options per question and clear recommendations. Challenges disagreement to strengthen thinking and concludes with a synthesis document.
Guides deep thinking through progressive, one-at-a-time questioning with options and recommendations.
/plugin marketplace add deepeshBodh/human-in-loop/plugin install deepeshbodh-humaninloop-plugins-humaninloop@deepeshBodh/human-in-loopThis skill inherits all available tools. When active, it can use any tool Claude has access to.
SYNTHESIS.mdGuide deep thinking through progressive, one-at-a-time questioning. Each question builds on previous answers, creating a collaborative exploration that concludes with a structured synthesis document.
When triggered, acknowledge the topic and set expectations:
I'll help you think through [topic] with a series of focused questions.
For each question, I'll present options with my recommendation. Feel free to
disagree—I'll push back to help strengthen your thinking.
Let's begin.
Then ask the first question.
Core Rules:
Question Format:
[Brief context showing current understanding and how previous answer shaped thinking]
**Question [N]**: [Clear, focused question]
**Options:**
- **A) [Option name]**: [What this means and its implications]
- **B) [Option name]**: [What this means and its implications]
- **C) [Option name]**: [What this means and its implications]
**My Recommendation**: Option [X] because [clear reasoning based on what we know so far]
After receiving an answer:
[Acknowledge the choice]
[Show how this shapes the analysis—what it opens up, what it rules out,
what becomes more important to explore]
[Transition to next question]
When the user picks differently than recommended:
Example:
Interesting—you're leaning toward [their choice] over [your recommendation].
Before we lock that in, let me push back: [specific concern or trade-off they
may not have considered].
What's your thinking on that?
If they confirm after the challenge, acknowledge and integrate:
Fair enough. That's a deliberate choice with eyes open to the trade-offs.
Let me factor that in...
[Show how this affects the analysis]
When core decisions are made or user signals completion, generate the synthesis.
Transition to synthesis:
I think we've covered the key decision points. Let me synthesize what we've
worked through...
Then generate the synthesis document. See SYNTHESIS.md for the template.
Do NOT force a fixed number of questions. Continue until:
Signs to wrap up:
Based on your focus on rapid iteration, we need to decide on the feedback mechanism.
**Question 3**: How quickly do users need to see the impact of their changes?
**Options:**
- **A) Real-time (< 100ms)**: Changes reflect instantly. Highest technical complexity
but most responsive feel.
- **B) Near-real-time (1-3 seconds)**: Brief processing delay. Simpler to implement,
still feels responsive.
- **C) On-demand refresh**: User explicitly triggers update. Simplest, but breaks flow.
**My Recommendation**: Option B because your team is small and time-to-market
matters. Real-time adds significant complexity for marginal UX gain at this stage.
You can always upgrade later.
You're leaning toward real-time over my near-real-time recommendation.
I want to make sure you've weighed this: real-time means WebSocket infrastructure,
handling reconnection logic, and conflict resolution—easily 2-3x the implementation
work. Your team of three would be stretched thin.
Is the instant feedback worth that trade-off, or is there a specific user flow
where real-time is non-negotiable?
Got it—you're prioritizing simplicity with the on-demand refresh approach.
That's a pragmatic call. It means we can skip the real-time infrastructure entirely
and focus engineering time on the core value proposition. Users will need a clear
"refresh" affordance, but that's a UI detail we can nail.
This actually opens up our next question about data freshness expectations...
This skill should be used when the user asks to "create a slash command", "add a command", "write a custom command", "define command arguments", "use command frontmatter", "organize commands", "create command with file references", "interactive command", "use AskUserQuestion in command", or needs guidance on slash command structure, YAML frontmatter fields, dynamic arguments, bash execution in commands, user interaction patterns, or command development best practices for Claude Code.
This skill should be used when the user asks to "create an agent", "add an agent", "write a subagent", "agent frontmatter", "when to use description", "agent examples", "agent tools", "agent colors", "autonomous agent", or needs guidance on agent structure, system prompts, triggering conditions, or agent development best practices for Claude Code plugins.
This skill should be used when the user asks to "create a hook", "add a PreToolUse/PostToolUse/Stop hook", "validate tool use", "implement prompt-based hooks", "use ${CLAUDE_PLUGIN_ROOT}", "set up event-driven automation", "block dangerous commands", or mentions hook events (PreToolUse, PostToolUse, Stop, SubagentStop, SessionStart, SessionEnd, UserPromptSubmit, PreCompact, Notification). Provides comprehensive guidance for creating and implementing Claude Code plugin hooks with focus on advanced prompt-based hooks API.