sheikh-mohammad/agent-factory-claude-skills / .claude/skills/interview
interview
VerifiedThis skill conducts discovery conversations to understand user intent and agree on approach before taking action. It should be used when the user explicitly calls /interview, asks for recommendations, needs brainstorming, wants to clarify, or when the request could be misunderstood. Prevents building the wrong thing by uncovering WHY behind WHAT.
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 8.1 KB |
| references/anti-patterns.md | markdown | 5.6 KB |
| references/question-patterns.md | markdown | 4.4 KB |
| references/summary-templates.md | markdown | 3.0 KB |
references/anti-patterns.md
View on GitHub# Anti-Patterns
Common mistakes in discovery conversations and how to avoid them.
---
## Discovery Anti-Patterns
### 1. Scripted Questioning
**Symptom**: Following a fixed list of questions regardless of context.
**Problem**: Misses the specific gaps in THIS situation. Wastes time on irrelevant questions.
**Fix**:
```
Identify what's ACTUALLY unclear in this request.
Generate questions to fill THOSE specific gaps.
Adapt based on answers received.
```
### 2. Assuming User Lacks Expertise
**Symptom**: Researching and explaining domain basics when user is an expert.
**Problem**: Wastes user's time, feels condescending.
**Fix**:
```
Ask: "Do you have experience with [domain]?"
If yes: Leverage their expertise, ask for their knowledge
If no: Then research and explain
```
### 3. Jumping to Implementation
**Symptom**: Starting work before understanding is confirmed.
**Problem**: Builds wrong thing, wastes effort, frustrates user.
**Fix**:
```
Always summarize understanding first.
Get explicit confirmation: "Does this capture what you want?"
Only proceed after user confirms.
```
### 4. Solution Anchoring
**Symptom**: Asking questions that validate a pre-decided solution.
**Problem**: Misses better alternatives, biases the discovery.
**Fix**:
```
Explore the problem space first.
Present multiple options when they exist.
Let user's needs drive the solution.
```
---
## Questioning Anti-Patterns
### 5. Question Overload
**Symptom**: Asking 5+ questions at once.
**Problem**: Overwhelms user, gets rushed/incomplete answers.
**Fix**:
```
1-4 questions maximum per round.
Build on answers before asking more.
Most important questions first.
```
### 6. Leading Questions
**Symptom**: "Don't you think we should use X?"
**Problem**: User agrees without genuine consideration.
**Fix**:
```
Present options neutrally.
"We could use X, Y, or Z. What fits your needs?"
Let user choose, don't push.
```
### 7. Accepting Vagueness
**Symptom**: User says "make it fast" → "Okay, got it."
**Problem**: "Fast" means different things. Undefined requirements cause problems later.
**Fix**:
```
Probe vague terms:
"When you say 'fast', what response time is acceptable?"
"What does 'easy to use' mean for your users?"
Quantify whenever possible.
```
### 8. Re-asking the Obvious
**Symptom**: Asking about things user already explained.
**Problem**: Shows AI wasn't listening. Wastes time.
**Fix**:
```
Track what's already clear from context.
Only ask about actual gaps.
Reference what user said: "You mentioned X - should that include Y?"
```
---
## Context Anti-Patterns
### 9. Codebase Assumption
**Symptom**: Asking about code/files when user is brainstorming or starting fresh.
**Problem**: Wrong context assumed. Confuses user.
**Fix**:
```
Assess what context exists FIRST.
Fresh project? → Focus on goals, constraints
Existing work? → Then examine what exists
Brainstorming? → Explore possibilities
```
### 10. Specs-Only Mindset
**Symptom**: Treating every discovery as "requirements gathering."
**Problem**: Not all work needs formal specs. Overkill for simple tasks.
**Fix**:
```
Match formality to situation:
- Simple request → Quick clarification, proceed
- Complex work → Thorough discovery
- Brainstorming → Exploratory conversation
Goal is understanding, not documentation.
```
### 11. Ignoring User's Time
**Symptom**: Extensive questioning for simple requests.
**Problem**: User wanted quick help, not an interview.
**Fix**:
```
Gauge complexity first.
Simple + clear → Just do it
Ambiguous → Clarify specific gaps only
Complex → Full discovery warranted
```
---
## Research Anti-Patterns
### 12. Researching When User Knows
**Symptom**: Web searching domain basics when user is the expert.
**Problem**: Wastes time, ignores valuable user knowledge.
**Fix**:
```
Ask about user's expertise first.
Expert user → Ask for their knowledge
Novice user → Then research helps
```
### 13. Skipping Research When Needed
**Symptom**: Making recommendations without checking current best practices.
**Problem**: Outdated or suboptimal advice.
**Fix**:
```
If user needs industry context → Research
If comparing approaches → Research current options
If user asks "what's best" → Research before recommending
```
---
## Confirmation Anti-Patterns
### 14. No Summary
**Symptom**: Proceeding without confirming understanding.
**Problem**: Misalignment discovered too late.
**Fix**:
```
Always summarize: "Here's what I understand..."
Always confirm: "Does this capture what you want?"
Only proceed after explicit confirmation.
```
### 15. Vague Summary
**Symptom**: Summary is as vague as original request.
**Problem**: Hasn't actually achieved clarity.
**Fix**:
```
Summary should be SPECIFIC enough to act on.
If you can't be specific, you need more questions.
Test: Could someone else implement from this summary?
```
---
## Summary Table
| Anti-Pattern | Key Fix |
|--------------|---------|
| Scripted questioning | Generate for THIS situation |
| Assuming no expertise | Ask user first |
| Jumping to implementation | Confirm understanding first |
| Solution anchoring | Explore problem space first |
| Question overload | 1-4 questions at a time |
| Leading questions | Present options neutrally |
| Accepting vagueness | Probe for specifics |
| Re-asking obvious | Track what's clear |
| Codebase assumption | Assess context first |
| Specs-only mindset | Match formality to situation |
| Ignoring user's time | Gauge complexity first |
| Researching when user knows | Ask about expertise |
| Skipping needed research | Research when context needed |
| No summary | Always summarize and confirm |
| Vague summary | Be specific enough to act on |
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness. | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is available | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |