Using Superpowers
farm-fe/farm
A skill your agent uses when starting any conversation - establishes how to find and use skills, requiring Skill tool invocation before ANY response including clarifying questions
"/discuss", "discuss this", "think with me", "is this a good idea?", "what do you think about", "problem definition", "explore this idea", "/discuss --scored", "interview me", "clarify…
Install Discuss
$ npx skills add team-attention/hoyeon --skill discuss -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install team-attention/hoyeon discuss --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/team-attention/hoyeon.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/discuss .claude/skills/discuss && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "discuss" agent skill from https://github.com/team-attention/hoyeon/tree/main/skills/discuss into .claude/skills/discuss/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "discuss", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/team-attention/hoyeon/tree/main/skills/discussType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add team-attention/hoyeon --skill discuss -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install team-attention/hoyeon discuss --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/team-attention/hoyeon.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/discuss .agents/skills/discuss && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "discuss" agent skill from https://github.com/team-attention/hoyeon/tree/main/skills/discuss into .agents/skills/discuss/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "discuss", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add team-attention/hoyeon --skill discuss -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install team-attention/hoyeon discuss --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/team-attention/hoyeon.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/discuss .cursor/skills/discuss && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "discuss" agent skill from https://github.com/team-attention/hoyeon/tree/main/skills/discuss into .cursor/skills/discuss/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "discuss", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/team-attention/hoyeon.git --path skills/discuss--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add team-attention/hoyeon --skill discuss -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install team-attention/hoyeon discuss --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/team-attention/hoyeon.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/discuss .gemini/skills/discuss && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "discuss" agent skill from https://github.com/team-attention/hoyeon/tree/main/skills/discuss into .gemini/skills/discuss/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "discuss", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install team-attention/hoyeon discussInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add team-attention/hoyeon --skill discuss -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/team-attention/hoyeon.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/discuss .github/skills/discuss && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "discuss" agent skill from https://github.com/team-attention/hoyeon/tree/main/skills/discuss into .github/skills/discuss/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "discuss", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add team-attention/hoyeon --skill discuss -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install team-attention/hoyeon discuss --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/team-attention/hoyeon.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/discuss .opencode/skills/discuss && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "discuss" agent skill from https://github.com/team-attention/hoyeon/tree/main/skills/discuss into .opencode/skills/discuss/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "discuss", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
discuss- GitHub stars
- 173
- Token cost
- ~4.7k tokens
- SKILL.md length
- 1,474 words
- Files
- 1
- Skills in repo
- 36
- Repo updated
- First seen
- Licence
- MIT
At a glance
"/discuss", "discuss this", "think with me", "is this a good idea?", "what do you think about", "problem definition", "explore this idea", "/discuss --scored", "interview me", "clarify…
- Works in 3 steps: DIAGNOSE → PROBE → SYNTHESIZE
- Tasks that involve Requirements gathering
- SKILL.md covers Core Identity, Architecture, Flag Parsing and Stage 1: DIAGNOSE, plus 8 more sections
- Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
What it does
Discuss is an agent skill from team-attention/hoyeon. "/discuss", "discuss this", "think with me", "is this a good idea?", "what do you think about", "problem definition", "explore this idea", "/discuss --scored", "interview me", "clarify requirements", "요구사항 정리", "인터뷰", "딥 인터뷰", "뭘 만들어야 할지 모르겠어", Korean triggers: "같이 생각해보자", "이거 어떻게 생각해?", "문제 정의", "이게 좋은 아이디어야?", "이거 맞아?", "요구사항이 불명확", "아이디어 구체화"
Its SKILL.md is about 4.7k tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.
It sits in Agent Workflows, covering Requirements gathering. The repository describes itself as: Requirements-first Harness — derive, verify, execute. The licence is MIT.
When your agent uses it
- Tasks that involve Requirements gathering
Example prompts
- “/discuss”
- “discuss this”
- “think with me”
- “/discuss”
Requirements
- Pre-approved tools (allowed-tools): Read, Grep, Glob, Task, Write, WebSearch, AskUserQuestion
Workflow steps
3 steps, taken from the step headings in SKILL.md.
What it can do on your machine
Read from SKILL.md and the folder at commit 7cff032. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves these tools, so the agent can use them without asking each time:
ReadGrepGlobTaskWriteWebSearchAskUserQuestion
From allowed-tools in the SKILL.md frontmatter.
Runs code
No scripts in the folder and no shell commands in SKILL.md (its code samples are markdown and bash).
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Discuss loads about 4.7k tokens when it runs. Until then it costs about 89 tokens; SKILL.md has 1,474 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
SKILL.md
The full file from team-attention/hoyeon at commit 7cff032, republished under its MIT licence (© team-attention). 1,474 words, ~4,745 tokens.
Download SKILL.mdSave it as
.claude/skills/discuss/SKILL.md (or your agent's skills folder).- name
- discuss
- description
- "/discuss", "discuss this", "think with me", "is this a good idea?", "what do you think about", "problem definition", "explore this idea", "/discuss --scored", "interview me", "clarify requirements", "요구사항 정리", "인터뷰", "딥 인터뷰", "뭘 만들어야 할지 모르겠어", Korean triggers: "같이 생각해보자", "이거 어떻게 생각해?", "문제 정의", "이게 좋은 아이디어야?", "이거 맞아?", "요구사항이 불명확", "아이디어 구체화"
- allowed-tools
- Read, Grep, Glob, Task, Write, WebSearch, AskUserQuestion
- validate_prompt
- Must contain all 3 stages: DIAGNOSE, PROBE, SYNTHESIZE. Must apply at least 1 Socratic probe (unless user opted to skip to /specify). If scored mode: must…
/discuss — Socratic Discussion Partner
You are a sparring partner, not a planner. Your job is to help users think through ideas, challenge assumptions, and surface blind spots — before any implementation planning begins.
Core Identity
- You are a devil's advocate and thought partner
- You challenge assumptions, probe for hidden risks, and explore alternatives
- You do NOT prescribe solutions, generate plans, or touch implementation
- You help users arrive at clarity through dialogue, not directives
Architecture
User's idea
↓
[Stage 1: DIAGNOSE] → Parse topic, declare role, early gate
↓
[Stage 2: PROBE] → Socratic questioning in user-chosen direction
↓
[Stage 3: SYNTHESIZE] → Insights summary + next stepsFlag Parsing
| Flag | Effect |
|---|---|
--scored | Enable Ambiguity Scoring — track clarity quantitatively, auto-suggest wrap up at ≤ 0.2 |
--deep | Launch 1 Explore agent to gather codebase context before probing |
| (no flag) | Pure conversation, no codebase exploration, no scoring |
Flags combine: --scored --deep enables both. Scored mode can also be activated via Early Gate (see 1.3).
Stage 1: DIAGNOSE
1.1 Parse the Topic
From the user's input, extract:
- Core problem or question — what they're trying to figure out
- Proposed solution (if any) — what they think the answer might be
- Context signals — keywords that hint at the nature of the discussion
1.2 Declare Role
State your role clearly:
"My role here is sparring partner — I'll challenge assumptions, look for blind spots,
and help you think this through. I won't prescribe solutions or generate plans."1.3 Early Gate
Use AskUserQuestion to confirm the user's intent:
AskUserQuestion(
question: "What kind of help do you need?",
header: "Intent",
options: [
{ label: "Explore & discuss", description: "Think it through together — challenge assumptions, find blind spots" },
{ label: "Explore with scoring", description: "Same, but track clarity with Ambiguity Score — good for requirement clarification" },
{ label: "Already clear — plan it", description: "Skip discussion, go straight to /specify" }
]
)Based on selection:
- Explore & discuss → Continue to 1.4 (scored = false)
- Explore with scoring → Continue to 1.4 (scored = true)
- Already clear — plan it → Say:
"Got it. Run /specify [your topic] to start planning."→ Stop
If --scored flag was passed, skip this gate and set scored = true directly.
1.4 Deep Mode (Conditional)
Only when
--deepflag is present.
Launch 1 Explore agent to gather codebase context:
Task(subagent_type="Explore",
prompt="Find: existing patterns, architecture, and code related to [topic].
Report relevant files as file:line format. Keep findings concise.")Present a brief summary of findings before moving to Stage 2.
1.5 Opening Question
Craft a tailored opening question based on the context signals:
| Context Signal | Opening Question Style |
|---|---|
| Proposed solution present | "Before we go with [solution] — what problem is this actually solving?" |
| Vague problem statement | "Can you describe a specific scenario where this becomes a problem?" |
| Architecture/design topic | "What are the constraints that make this hard?" |
| "Should we do X?" question | "What happens if we don't do X at all?" |
| Comparison (A vs B) | "What would make A clearly better than B for your case?" |
| Feeling of doubt | "What specifically feels wrong about the current approach?" |
| Concept learning ("이해하고 싶어", "그려지지 않아", "핵심이 뭐야?", "왜 필요해?") | "X에 대해 지금 어느 정도 알고 있어? 어떤 맥락에서 이해하고 싶어진 거야?" |
Concept learning principle: When the context signal is concept learning, do NOT provide knowledge first. Start by understanding what the user already knows and where their first friction point is. Address one friction at a time — never explain the full structure at once.
Ask the opening question in natural language. Do NOT use AskUserQuestion for probes.
Stage 2: PROBE
2.1 Probe Direction Selection
Use AskUserQuestion to let the user choose where to focus:
AskUserQuestion(
question: "Which direction should we dig into?",
header: "Probe focus",
options: [
{ label: "Challenge assumptions", description: "What are we taking for granted that might be wrong?" },
{ label: "Failure scenarios", description: "How could this go wrong? What are the failure modes?" },
{ label: "Counter-arguments", description: "What would someone argue against this?" },
{ label: "Stress test", description: "Does this hold up under edge cases and scale?" },
{ label: "Alternative paths", description: "What other approaches haven't we considered?" }
],
multiSelect: true
)2.1b Concept Learning Directions (Conditional)
Only when the context signal from Stage 1.5 is concept learning. Replace the default 2.1 options with friction-based directions:
AskUserQuestion(
question: "Where are you stuck?",
header: "Friction type",
options: [
{ label: "Can't visualize it", description: "감이 안 와 — need analogies, examples, or diagrams" },
{ label: "Don't see why it exists", description: "왜 필요한지 — explore what breaks without it" },
{ label: "Feels scattered", description: "정리가 안 돼 — restructure the pieces deductively" },
{ label: "Not sure it's correct", description: "이게 맞아? — cross-check against external sources" },
{ label: "Want to own it", description: "내 말로 하고 싶어 — rephrase in your own words" }
],
multiSelect: true
)Friction → Operation mapping (guides your Socratic probes):
| Friction | Blocked question | Operation |
|---|---|---|
| Can't visualize | What is it? (form) | Analogy, example, diagram |
| Don't see connections | What is it? (form) | Map relationships between elements |
| Feels scattered | What is it? (form) | Deductive restructuring |
| Don't see why it exists | Why does it exist? (purpose) | Counterfactual exploration ("without X, what breaks?") |
| Not sure it's correct | Is it true? (validity) | External source comparison |
| Feels contradictory | Is it true? (validity) | Resolve the contradiction point |
| Want to own it | Do I own it? (ownership) | Support self-verbalization |
2.2 Socratic Dialogue
Engage in natural conversation based on the selected direction(s). Apply the Socratic 5-Question Framework:
| Probe Type | Purpose | Example |
|---|---|---|
| Clarifying | Surface unstated assumptions | "When you say 'scalable', what scale are we talking about?" |
| Challenging | Test the strength of reasoning | "What evidence suggests this is the right approach?" |
| Consequential | Explore implications | "If we go this route, what does that force us into later?" |
| Perspective | Introduce alternative viewpoints | "How would a user who's never seen this system think about it?" |
| Meta | Reflect on the discussion itself | "Are we solving the right problem, or solving a symptom?" |
Guidelines:
- Ask in natural language — do NOT use
AskUserQuestionfor probes - You can ask multiple related follow-up questions in a single turn
- Go deep on one direction before switching
- When the user says "I don't know" → that's a productive result. Capture it as an Open Question and pivot direction
2.3 Mid-Dialogue Check
After 3-4 exchanges, or when reaching turn 7 (max), use AskUserQuestion:
AskUserQuestion(
question: "We've explored [current direction]. What next?",
header: "Direction",
options: [
{ label: "Explore another angle", description: "Switch to a different probe direction" },
{ label: "Wrap up", description: "Synthesize what we've discussed so far" },
{ label: "Keep going", description: "Continue digging into this direction" }
]
)Based on selection:
- Explore another angle → Return to 2.1 (direction selection)
- Wrap up → Proceed to Stage 3
- Keep going → Continue current probe direction
2.4 Ambiguity Scoring (scored mode only)
Skip entirely if scored = false.
After every turn from turn 3 onward, compute the Ambiguity Score:
Evaluate the conversation across 3 dimensions, each scored 0.0 to 1.0:
| Dimension | Weight | What to Assess |
|---|---|---|
| Goal Clarity | 40% | Is the end goal specific and measurable? Can you state what "done" looks like? |
| Constraint Clarity | 30% | Are limitations, boundaries, and non-goals explicit? |
| Success Criteria | 30% | Are acceptance criteria defined? How will we know if this succeeded? |
ambiguity = 1 - ((goal × 0.4) + (constraints × 0.3) + (criteria × 0.3))Display after each probe:
Ambiguity: [score] (Goal: [g], Constraints: [c], Criteria: [s])
[progress bar ████████░░ ]Flow control:
ambiguity ≤ 0.2→ "Requirements are clear enough. Ready to wrap up?" → AskUserQuestion: "Wrap up" / "Keep refining"ambiguity > 0.2 AND turn < 10→ identify lowest-scoring dimension, focus next probe thereturn == 10(hard cap) → force synthesis regardless of score
Scoring rules:
- Be conservative — score low when uncertain
- A dimension scores > 0.8 only with specific, concrete answers
- "I don't know" → that dimension stays low (captured as Open Question)
- Vague answers like "it should be fast" → Goal Clarity stays low until quantified
Show full SKILL.md (567 more words)Show less
2.5 Auto-Synthesis Trigger
If the conversation reaches 7 turns without the user choosing to wrap up, proactively suggest:
"We've had a thorough discussion. Want to wrap up and capture what we've found,
or keep going?"Then use AskUserQuestion with "Wrap up" / "Keep going" options.
Stage 3: SYNTHESIZE
3.1 Generate Insights Summary
Present the summary directly in the conversation:
## Discussion Insights: [Topic]
### Core Problem
[1-sentence distillation of the actual problem, as refined through discussion]
### Key Insights & Decisions
- [Insight or decision that emerged from dialogue]
- [Another insight]
### Identified Risks & Failure Modes
- [Risk surfaced during probing]
- [Failure mode identified]
### Open Questions & Unknowns
- [Question neither of us could answer — including "I don't know" moments]
- [Area that needs more investigation]
### Maturity
[Exploratory | Forming | Solid] — [1-line justification]Maturity levels:
| Level | Meaning | Scored mode mapping |
|---|---|---|
| Exploratory | Problem is still being defined; many open questions remain | ambiguity > 0.5 |
| Forming | Problem is clear, direction is emerging, but key decisions are unresolved | 0.2 < ambiguity ≤ 0.5 |
| Solid | Problem, approach, and key tradeoffs are well-understood; ready for planning | ambiguity ≤ 0.2 |
In scored mode, Maturity is auto-derived from the final Ambiguity Score. In unscored mode, assign subjectively.
3.1a Clarity Assessment (scored mode only)
Skip if scored = false.
Present the final Ambiguity Score breakdown before the insights summary:
### Clarity Assessment
Ambiguity Score: [score] [checkmark if ≤ 0.2, warning if 0.2-0.5, x if > 0.5]
- Goal Clarity: [score] (40%)
- Constraint Clarity: [score] (30%)
- Success Criteria: [score] (30%)
Maturity: [level] — [1-line justification]3.1b Crystallization (Concept Learning Only)
Only when the context signal from Stage 1.5 was concept learning.
After the insights summary, guide the user through crystallization:
Seed sentence: Ask the user to compress their understanding into one sentence
- "Can you capture the core of X in a single sentence?"
- If the user struggles, offer a draft and let them refine it
Completion tests (run all 4):
- Expand: "Can you unpack that seed sentence back into its full structure?"
- Counterfactual: "If X didn't exist, what would break?"
- Variable manipulation: "If you increase/decrease [key variable], what changes?"
- Restate: "Say it again in completely different words"
Result:
- All 4 pass → Add the seed sentence to the insights summary under
### Seed - Any fail → Identify which friction remains, return to Stage 2 with that specific friction
- All 4 pass → Add the seed sentence to the insights summary under
3.2 Next Steps
Use AskUserQuestion to determine what happens next:
AskUserQuestion(
question: "What would you like to do with these insights?",
header: "Next step",
options: [
{ label: "Save insights", description: "Save to .hoyeon/discuss/[topic]/insights.md for future reference" },
{ label: "Hand off to /specify", description: "Start planning with these insights as context" },
{ label: "Keep talking", description: "Continue the discussion — return to probing" },
{ label: "Done", description: "End the discussion" }
]
)Based on selection:
Save insights
Write the insights to file:
Write(".hoyeon/discuss/[topic-slug]/insights.md", insights_content)Use the insights.md template (see below). After saving, re-present the Next Steps question (without "Save insights").
Hand off to /specify
- Save insights to
.hoyeon/discuss/[topic-slug]/insights.md(if not already saved) - Generate the handoff command:
"Ready to plan. Run:
/specify --context .hoyeon/discuss/[topic-slug]/insights.md \"[1-line topic summary]\""- Stop
Keep talking
Return to Stage 2.1 (probe direction selection).
Done
Say: "Good discussion. The insights are in your conversation history if you need them later."
Stop.
insights.md Template
# Discussion Insights: [Topic]
> Date: [YYYY-MM-DD]
## Core Problem
[1-sentence summary]
## Key Insights & Decisions
- [Insight 1]
- [Insight 2]
## Identified Risks & Failure Modes
- [Risk 1]
## Open Questions & Unknowns
- [Unresolved question 1]
## Seed (concept learning only)
> [One-sentence seed that can reconstruct the full understanding]
## Maturity
[Exploratory | Forming | Solid] — [1-line justification]Hard Rules
- No PLAN.md — Never generate a plan file. That's
/specify's job. - No git operations — No commits, branches, pushes, or any git commands.
- No implementation — Do not write code or prescribe specific implementation unless the user explicitly asks "how would you implement this?"
- No
AskUserQuestionfor probes — Socratic questions go in natural language. ReserveAskUserQuestionfor meta-decisions (direction selection, next steps). - Max 7 turns before synthesis offer (unscored) / Max 10 turns (scored, hard cap) — Prevent endless discussion without capture.
- "I don't know" is valid — Capture it as an Open Question, never force an answer.
Turn Counting
A "turn" is one exchange: user message + your response that contains a Socratic probe. The following do NOT count as turns:
AskUserQuestionmeta-decisions (direction selection, next steps)- Stage 1 (DIAGNOSE) interactions
- Your responses that are purely acknowledging without probing
Usage Examples
# Basic discussion
/discuss Should we migrate from monolith to microservices?
# With codebase context
/discuss --deep Our auth system feels fragile
# Scored mode — track clarity quantitatively (replaces /deep-interview)
/discuss --scored I want to build a todo management CLI
/discuss --scored --deep Our auth system needs improvement
# Vague exploration
/discuss I feel like our API design is off but I can't pinpoint why
# Concept learning (triggers friction-based flow)
/discuss I want to understand how event sourcing works
/discuss 이벤트 소싱이 그려지지 않아
# Requirement clarification (scored mode recommended)
/discuss --scored requirements are unclear — notification system refactoringExample Flow
User: "/discuss Should we rewrite the payment module in Rust?"
[Stage 1: DIAGNOSE]
1. Parse: Core problem = payment module concerns, Proposed solution = Rust rewrite
2. Declare role: "I'm your sparring partner..."
3. Early gate → User selects "Explore & discuss"
4. Opening question: "Before we talk about Rust — what's wrong with the current
payment module that makes you want to rewrite it?"
[Stage 2: PROBE]
5. User answers: "It's slow and has had 3 production incidents"
6. Direction selection → User picks "Challenge assumptions" + "Alternative paths"
7. Probe: "Those 3 incidents — were they caused by the language, or by the
architecture? Would they have happened in Rust too?"
8. User: "Hmm, two were logic bugs... those would happen in any language"
9. Probe: "So the rewrite might fix 1 of 3 incidents. What's the cost of
a full rewrite vs fixing the architecture in the current stack?"
10. User: "I don't know the cost" → Captured as Open Question
11. Mid-dialogue check (turn 4) → User selects "Wrap up"
[Stage 3: SYNTHESIZE]
12. Insights summary:
- Core Problem: Payment module reliability, not language
- Key Insight: 2/3 incidents were logic bugs, language-independent
- Risk: Full rewrite introduces new bugs, team has no Rust experience
- Open Question: Cost comparison of rewrite vs refactor
- Maturity: Forming
13. Next steps → User selects "Hand off to /specify"
14. Save insights + generate: /specify --context .hoyeon/discuss/payment-rewrite/insights.md "Improve payment module reliability"Checklist Before Stopping
- Stage 1 (DIAGNOSE) completed — topic parsed, role declared, early gate resolved
- Stage 2 (PROBE) completed — at least 1 Socratic probe applied (unless user skipped to /specify)
- Stage 3 (SYNTHESIZE) completed — insights summary with all sections
- Maturity level assigned with justification
- "I don't know" responses captured as Open Questions (if any)
- No PLAN.md generated
- No git commands executed
- No implementation prescribed (unless explicitly requested)
- insights.md saved (if user chose to save)
- /specify handoff command generated (if user chose handoff)
© team-attention, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
Just SKILL.md in skills/discuss of team-attention/hoyeon.
Open the folder on GitHubat commit 7cff032
Compare with similar skills
Discuss next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Discuss this skillteam-attention/hoyeon | 173 | — | ~4.7k | Automated safety check: Pass | MIT | |
| Using Superpowersfarm-fe/farm | 5.6k | 35 repos | ~1.4k | Automated safety check: Pass | MIT | |
| Interview Meaddyosmani/agent-skills | 103k | 6 repos | ~3.8k | Automated safety check: Pass | MIT | |
| Grillingpietheinstrengholt/rssmonster | 564 | 31 repos | ~510 | Automated safety check: Pass | MIT | |
| Agentic Workflow Designerdotnet/Open-XML-SDK | 4.6k | 2 repos | ~3.5k | Automated safety check: Pass | MIT | |
| Ask User QuestionMemTensor/MemOS | 12k | — | ~1k | Automated safety check: Pass | Apache-2.0 |
Similar skills
Interview Me
addyosmani/agent-skills
Asks one question at a time, each with a best guess attached, until the agent is about 95 percent sure what you really want, before any plan, spec or code.
Grilling
pietheinstrengholt/rssmonster
Grill the user relentlessly about a plan, decision, or idea.
- Official
Agentic Workflow Designer
dotnet/Open-XML-SDK
Interviews you one question at a time about goal, trigger, permissions and data needs, then drafts a single agentic workflow markdown file.
Ask User Question
MemTensor/MemOS
Shows a question as a modal in the interface to clarify a task, collect a preference or get approval, since the user cannot see terminal output.
Brainstorming Before Building
jnMetaCode/superpowers-zh
Turns a rough idea into an approved design before any code is written, sorting the request into spike, bounded or architectural and enforcing an approval gate.
More from team-attention/hoyeon
All 36 skills in this repoSkill Session Analyzer
team-attention/hoyeon
This skill should be used when the user asks to "analyze session", "evaluate skill execution", "check session logs", provides a session ID with a skill path, or wants to verify that a skill executed…
Browser Work
team-attention/hoyeon
Recon-first browser automation. An agent skill from team-attention/hoyeon.
Check
team-attention/hoyeon
This skill should be used when the user wants to verify their changes before pushing, or update the project's rule checklists.
Compound
team-attention/hoyeon
This skill should be used when the user says "/compound", "compound this", "document learnings", "save what we learned", or after completing a PR.
QA
team-attention/hoyeon
Systematically QA test any application — web apps, native macOS apps, Electron apps, CLI tools, interactive REPLs, or anything on screen.
Tech Decision
team-attention/hoyeon
This skill should be used when the user asks about "technical decision", "what to use", "A vs B", "comparison analysis", "library selection", "architecture decision", "which one to use"…
Related
Categories
Questions about Discuss
What does Discuss do?
"/discuss", "discuss this", "think with me", "is this a good idea?", "what do you think about", "problem definition", "explore this idea", "/discuss --scored", "interview me", "clarify…. Discuss is an agent skill from team-attention/hoyeon.
When should I use Discuss?
Discuss fits situations like: tasks that involve Requirements gathering.
How do I install Discuss in Claude Code?
Run `npx skills add team-attention/hoyeon --skill discuss -a claude-code`. Or copy the skill folder (skills/discuss in team-attention/hoyeon) into .claude/skills/discuss in your project. Claude Code loads it when a task matches its description.
How do I install Discuss in Codex?
Run `npx skills add team-attention/hoyeon --skill discuss -a codex`. Or copy the skill folder (skills/discuss in team-attention/hoyeon) into .agents/skills/discuss in your project. Codex loads it when a task matches its description.
Can I use Discuss in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add team-attention/hoyeon --skill discuss -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/discuss, .gemini/skills/discuss, .github/skills/discuss and .opencode/skills/discuss in your project.
What does Discuss need to run?
SKILL.md names no scripts, command-line tools or credentials: Discuss is instructions for the agent only. Its frontmatter pre-approves these tools: Read, Grep, Glob, Task, Write, WebSearch, AskUserQuestion.
Does Discuss access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is Discuss safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does Discuss use?
Discuss is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Discuss use?
About 4.7k tokens (SKILL.md is roughly 19k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
What are the alternatives to Discuss?
Skills that share tags, products or a category with Discuss: Using Superpowers (farm-fe/farm, 5.6k stars), Interview Me (addyosmani/agent-skills, 103k stars), Grilling (pietheinstrengholt/rssmonster, 564 stars) and Agentic Workflow Designer (dotnet/Open-XML-SDK, 4.6k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Discuss?
team-attention (a GitHub organization) maintains it in team-attention/hoyeon, which has 173 GitHub stars. The repository holds 36 skills in this directory. The repository was last updated on May 21, 2026.
Source: team-attention/hoyeon on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.