spectra-discuss
Skill45 starsChanged 8 months agoMITView on GitHub
Have a focused discussion about a topic and reach a conclusion
6 other projects use a version of this, 5 of them edited.
Adopted by
Most recently taken up by
- Will-SW74/passdown-osedited, first seen Oct 11, 2026
- DanSnow/hoarder-pipettetheir own version, first seen Oct 8, 2026
- leoho0722/naver-blog-image-downloaderedited, first seen Aug 31, 2026
- PsychQuant/claude-hot-limitedited, first seen Jul 1, 2026
- harrychuang/cursor-skillsedited, first seen Jun 17, 2026
- BananaBay69/claude-code-watchdogedited, first seen Apr 29, 2026
Used with
Projects with it also use spectra-commit, spectra-analyze and 2 more.
Other files people use alongside this one.
Files found in the same public projects as a version of this one, more often than they turn up anywhere else. Each project counts once, large collections count for less, and this file's own repository is left out.
BananaBay69Skillspectra-commit
Commit files related to a specific Spectra change
Also in 6 projects that use this
harrychuangSkillspectra-analyze
Analyze artifact consistency for a change
Also in 5 projects that use this
harrychuangSkillspectra-drift
Detect drift between a Spectra change and the current codebase state
Also in 5 projects that use this
- +1 more from harrychuang
Other versions6 projects use a version of this.
Word for word · 0
None found.
Edited · 5
- harrychuang/cursor-skills★ 1971% same
- BananaBay69/claude-code-watchdog★ 295% same
- leoho0722/naver-blog-image-downloader★ 271% same
- PsychQuant/claude-hot-limit★ 071% same
- Will-SW74/passdown-os★ 071% same
Wrote their own version · 1
- DanSnow/hoarder-pipette★ 98same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository18 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- plugin/CLAUDE.mdCLAUDE.md
- spectra-applySkill
- spectra-archiveSkill
- spectra-askSkill
- spectra-auditSkill
- spectra-debugSkill
- spectra-discussSkill
- spectra-ingestSkill
- spectra-proposeSkill
- spectra-applySkill
- spectra-archiveSkill
- spectra-askSkill
- spectra-auditSkill
- spectra-debugSkill
- spectra-ingestSkill
- spectra-proposeSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
16 rules. 16 are common, 0 are distinctive, and 0 are very specific to this project.
16
Common
Most of the 6 edited versions we read keep these.
0
Distinctive
This author's own choices. Worth a look.
0
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Common: line 18
This is a task-oriented discussion: Every discussion has a topic, works toward a goal, and ends with a clear conclusion.
- Common: line 32
Before asking anything, do a quick codebase scout to decide how to run this discussion.
- Common: line 40
Use Grep and Glob to find related source files (not docs, not tests — source code).
- Common: line 51
When you enter assumptions mode, present 3-5 assumptions.
- Common: line 75
After presenting, ask: "Which of these are wrong?"
- Common: line 77
If the user says all are fine → proceed to Convergence with these as established context.
- Common: line 78
If the user flags corrections → for each one, ask ONE focused follow-up question to understand their intent, then proceed to Convergence …
- Common: line 95
Propose concrete options: When exploring approaches, present 2-3 specific options with trade-offs — not abstract possibilities.
- Common: line 107
Visualize freely: Use ASCII diagrams when they clarify thinking:
- Common: line 119
Be direct: If you have a recommendation, say it.
- Common: line 121
No empty validation: Never pad responses with hollow affirmations.
- Common: line 129
If you agree, say why. If you disagree, say why.
- Common: line 131
Push for specifics: When the user gives a vague answer, don't accept it — dig deeper.
- Common: line 198
If the user mentioned a specific change name, read its artifacts for context.
- Common: line 202
When the discussion converges, proactively present a conclusion summary.
- Common: line 227
When the discussion converges on building something:
“Common” is measured: kept by at least 6 in 10 of the 6 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Have a focused discussion about a topic and reach a conclusion.
IMPORTANT: Discuss mode is for thinking, not implementing. You may read files, search code, and investigate the codebase, but you must NEVER write code or implement features. If the user asks you to implement something, remind them to exit discuss mode first (e.g., start a change with /spectra-propose). You MAY create Spectra artifacts (proposals, designs, specs) if the user asks—that's capturing thinking, not implementing.
This is a task-oriented discussion. Every discussion has a topic, works toward a goal, and ends with a clear conclusion. Unlike open-ended exploration, discuss mode converges.
Input: The argument after /spectra-discuss is the topic. Could be:
- A design question: "should we use WebSockets or SSE?"
- A problem to solve: "the auth system is getting unwieldy"
- A change name: "add-dark-mode" (discuss in context of that change)
- An architecture decision: "how to structure the plugin system"
- A vague idea that needs sharpening: "real-time collaboration"
Before You Speak
Before asking anything, do a quick codebase scout to decide how to run this discussion.
Step 1: Extract search terms
Pull 2-5 keywords from the user's topic. For "search should support fuzzy matching", that's search, fuzzy, match. For "should we add a plugin system", that's plugin, extension, module.
Step 2: Scout the codebase
Use Grep and Glob to find related source files (not docs, not tests — source code). Spend no more than a few seconds on this. Read up to 5 of the most relevant files found.
Step 3: Pick a mode
- 3+ related source files found → Assumptions mode: you have enough context to form opinions. List your assumptions, let the user correct.
- Fewer than 3 related source files found → Interview mode: not enough code to base assumptions on. Fall through to "How to Discuss" below and ask questions one at a time.
Announce which mode you picked and why: "Found search.rs, SearchPanel.svelte, search-store.ts — I have enough context to list my assumptions." or "Didn't find much related code — I'll ask questions instead."
Assumptions mode
When you enter assumptions mode, present 3-5 assumptions. Each one MUST include:
- Approach: what you'd do and why
- Evidence: file path(s) that informed this assumption
- If wrong: concrete consequence of getting this wrong
Example:
### My assumptions
1. **New IPC command goes in `commands/search.rs`**
Evidence: existing search commands are in `src-tauri/src/commands/search.rs`
If wrong: we'd need to create a new module and register it
2. **Use the existing `SearchStore` for state**
Evidence: `src/lib/stores/search-store.ts` already manages search state
If wrong: parallel state would cause sync bugs
3. **Fuzzy matching runs in Rust, not frontend**
Evidence: current search scoring is in `search.rs:calculate_score()`
If wrong: moving to frontend means rewriting the scoring logic in TypeScriptAfter presenting, ask: "Which of these are wrong?"
- If the user says all are fine → proceed to Convergence with these as established context.
- If the user flags corrections → for each one, ask ONE focused follow-up question to understand their intent, then proceed to Convergence with the corrected understanding.
Mode switching
The user can switch modes at any time during the discussion:
- "Ask me questions instead" / "one at a time" → switch to interview mode (the "How to Discuss" section below)
- "Just list your assumptions" / "what do you think?" → run the codebase scout if not done yet, then switch to assumptions mode
How to Discuss
This section applies to interview mode — either chosen automatically (insufficient code context) or switched to manually by the user.
One question at a time. Don't dump a list of 10 questions. Ask the most important one, listen, then follow up. Let the conversation breathe. If the user's initial description or previous answers already cover a question, skip it — don't ask what you already know.
Propose concrete options. When exploring approaches, present 2-3 specific options with trade-offs — not abstract possibilities. Use comparison tables when helpful:
| Approach | Pros | Cons |
|---------------|-------------------|-------------------|
| WebSockets | Real-time, bidir | Complex, stateful |
| SSE | Simple, HTTP | One-way only |
| Polling | Simplest | Latency, waste |Ground in reality. Investigate the actual codebase when relevant. Map existing architecture, find integration points, surface hidden complexity. Don't just theorize.
Visualize freely. Use ASCII diagrams when they clarify thinking:
┌──────────┐ ┌──────────┐ ┌──────────┐
│ Client │────▶│ Server │────▶│ DB │
└──────────┘ └──────────┘ └──────────┘System diagrams, state machines, data flows, dependency graphs — whatever helps.
Challenge assumptions. Including the user's and your own. Ask "do we actually need this?" Apply YAGNI — the simplest solution that works is often the best.
Be direct. If you have a recommendation, say it. Don't hedge endlessly. "I'd go with option B because..." is more useful than "all options have merit."
No empty validation. Never pad responses with hollow affirmations. These add nothing and erode trust:
"That's an interesting approach"→ State what specifically is interesting and why"There are many ways to think about this"→ Name the 2-3 concrete ways and their trade-offs"That could work"→ Explain why it would or wouldn't work, and under what conditions"Great question"→ Just answer the question"You raise a good point"→ Engage with the point directly
If you agree, say why. If you disagree, say why. Empty agreement is worse than honest pushback.
Push for specifics. When the user gives a vague answer, don't accept it — dig deeper. The goal is to reach decisions concrete enough to implement.
Bad vs. good:
User: "We should make it more modular"
Bad: "That sounds good. How would you like to proceed?"
Good: "What would you split out? Are we talking separate crates,
feature flags, or a plugin interface? Each has very different
cost."User: "Performance might be an issue"
Bad: "Good point, we should keep performance in mind."
Good: "What's the threshold? Are we talking sub-100ms response time,
handling 1000 concurrent users, or keeping memory under a
budget? The answer changes the architecture."User: "We need better error handling"
Bad: "Agreed, error handling is important."
Good: "Which errors are causing problems now? Are users seeing
crashes, silent failures, or unhelpful messages? Let's look
at the actual error paths."Convergence
Discussions must converge. As the conversation progresses:
- Narrow the options — eliminate approaches that don't fit
- Surface the key trade-off — most decisions come down to one fundamental tension
- Make a recommendation — or help the user make one
- State the conclusion clearly — what was decided, and why
The conclusion should be one of:
- Design decision: "We'll use SSE because one-way is sufficient and it's simpler"
- Direction consensus: "The auth refactor should split into gateway + provider"
- Next-step recommendation: "We need to spike the plugin API first to validate the approach"
- Explicit deferral: "We don't have enough info yet. Specifically, we need to know X before deciding"
If the user wants to move faster. Sometimes the user signals impatience — "let's just go with X", "I don't want to overthink this", "can we move on?". Respect their pace:
- First time: Briefly flag if there's an important unresolved question — one sentence, not a lecture. "Before we commit to X, worth noting that Y could affect Z. Want to address it or move forward?"
- If they push again: Respect it. Skip remaining questions, go straight to convergence with the best conclusion you can form from what's been discussed. Don't push back a second time.
The goal is thoroughness, not interrogation. One nudge maximum.
Spectra Awareness
You have full context of the Spectra system. Use it naturally.
Check for context
At the start, quickly check what exists:
spectra list --jsonIf the user mentioned a specific change name, read its artifacts for context.
Capture decisions
When the discussion converges, proactively present a conclusion summary. Don't wait to be asked — propose it, and let the user opt out.
Summary format:
## Conclusion
**Decision**: [What was decided]
**Rationale**: [Why — the key trade-off that drove this]
**Capture to**: [Where this should be recorded]Where to capture:
| Insight Type | Where to Capture |
| New requirement discovered | specs/<capability>/spec.md |
| Design decision made | design.md |
| Scope changed | proposal.md |
| New work identified | tasks.md |
Present the summary and say something like "I'll capture this to design.md unless you'd rather not." Default to capturing — the user can decline.
Transition to action
When the discussion converges on building something:
- "Ready to formalize this?
/spectra-propose" - Or capture the decision in existing artifacts and continue
Guardrails
- Don't implement — Never write code or implement features. Creating Spectra artifacts is fine, writing application code is not.
- Don't leave without a conclusion — If the user tries to end without a conclusion, summarize where things stand and state what's unresolved.
- Don't fake understanding — If something is unclear, dig deeper.
- Don't overwhelm — One question at a time, not a barrage.
- Don't over-engineer — Challenge complexity. Prefer simpler solutions.
- Do visualize — A good diagram is worth many paragraphs.
- Do explore the codebase — Ground discussions in reality.
- Do be opinionated — Have a recommendation. The user can disagree.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

