project-brainstorming
Guides project ideation via Socratic questioning to produce a validated brief. Use before specification when requirements are unclear.
Install / Use
npx skills add athola/claude-night-market --skill project-brainstormingInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AutomationSupported Platforms
Our assessment of project-brainstorming
project-brainstorming scores 91/100 on our quality scale, 1101st of 2,771 Automation skills we index (top 40%).
Its SKILL.md is 14 KB long, well organised into 45 sections with 7 code examples: a thorough specification that gives an agent plenty to work with.
It has 338 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so project-brainstorming is actively maintained.
- Our last check on 2026-11-20 found the source still online.
- It is released under the MIT license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
project-brainstorming compared with similar skills
All 4 of these similar skills score higher than project-brainstorming; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| project-brainstorming (this skill)by athola | 91 | 338 | 57d ago | SKILL.md |
| Agent-Reachby Panniantong | 100 | 113.3k | 12d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 82.1k | today | CLAUDE.md |
| Claude-Code-Game-Studiosby Donchitos | 100 | 40.2k | 10d ago | CLAUDE.md |
| Scraplingby D4Vinci | 100 | 104.4k | 2d ago | MCP Server |
Frequently asked questions
- How do I install project-brainstorming?
- Run
npx skills add athola/claude-night-market --skill project-brainstorming. The install tabs above show the steps for each supported agent. - Which AI agents does project-brainstorming work with?
- It is written for Claude Code, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is project-brainstorming safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is MIT-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is project-brainstorming still maintained?
- The repository was last updated about 2 months ago, so project-brainstorming is actively maintained.
Skill content
View source on GitHubname: project-brainstorming description: Guides project ideation via Socratic questioning to produce a validated brief. Use before specification when requirements are unclear. alwaysApply: false
Custom metadata (not used by Claude for matching):
model: sonnet category: workflow tags: [brainstorming, ideation, planning, requirements, socratic-method] complexity: intermediate model_hint: standard estimated_tokens: 2800 progressive_loading: true dependencies: modules: - modules/spec-review-loop.md - modules/deferred-capture.md role: library
When To Use
- Starting a new project without clear requirements
- Exploring problem space before specification
- Need to compare multiple approaches systematically
- Validating project feasibility and scope
- Documenting decision rationale for stakeholders
- Need to clarify the core problem being solved
When NOT To Use
- Requirements and specification already exist (use
Skill(attune:project-planning)instead) - Refining existing specs (use
Skill(attune:project-specification)instead) - Project scope is well-defined (jump to
/attune:project-init) - Mid-project pivots (use
Skill(attune:war-room)for strategic decisions)
Integration
With superpowers:
- Delegates to
Skill(superpowers:brainstorming)for Socratic method - Augments with project-specific patterns
- Uses project brainstorm templates
Without superpowers:
- Standalone questioning framework
- Project-focused ideation patterns
- Structured output templates
War Room Integration (REQUIRED):
- After Phase 3 (Approach Generation), automatically invokes
Skill(attune:war-room) - All brainstorming context passed to War Room for expert deliberation
- War Room provides multi-LLM pressure testing and synthesis
- Only bypassed for Type 2 decisions (RS ≤ 0.40) with explicit user confirmation
Brainstorming Framework
Phase 1: Problem Definition
Socratic Questions:
- What problem are you solving?
- Who experiences this problem?
- What makes this problem worth solving now?
- What happens if this problem isn't solved?
- What existing solutions have been tried?
- Who reads what this project produces, and what do they already know? Name a role specific enough to point at someone who holds it.
Question 6 sets the audience tier that every document this
project generates inherits: newcomer, practitioner, expert,
or a one-line persona. Ask it here rather than at drafting
time, where the answer gets guessed to keep the draft moving.
Tier table and follow-up questions: scribe:slop-detector module
audience-targeting.md.
Output: Problem statement in docs/project-brief.md
Template:
## Problem Statement
**Who**: [Target users/stakeholders]
**What**: [The problem they face]
**Where**: [Context where problem occurs]
**When**: [Frequency/timing of problem]
**Why**: [Impact of the problem]
**Current State**: [Existing solutions and limitations]
**Doc audience**: [newcomer | practitioner | expert | persona: <one line>]
Verification: Run the command with --help flag to verify availability.
Phase 2: Constraint Discovery
Questions:
- What are non-negotiable technical constraints?
- What are resource constraints (time, budget, team)?
- What integration points are required?
- What compliance/regulatory requirements apply?
- What are success criteria and failure modes?
Output: Constraints matrix
Template:
## Constraints
### Technical
- [Constraint 1 with rationale]
- [Constraint 2 with rationale]
### Resources
- **Timeline**: [Duration with milestones]
- **Team**: [Size and skills]
- **Budget**: [If applicable]
### Integration
- [Required system 1]
- [Required system 2]
### Compliance
- [Requirement 1]
- [Requirement 2]
### Success Criteria
- [ ] [Measurable criterion 1]
- [ ] [Measurable criterion 2]
Verification: Run the command with --help flag to verify availability.
Phase 3: Approach Generation
Technique: Generate 3-5 distinct approaches
For each approach:
- Clear description (1-2 sentences)
- Technology stack
- Pros (3-5 points)
- Cons (3-5 points)
- Risks (2-3 points)
- Estimated effort
- Trade-offs
Template:
## Approach [N]: [Name]
**Description**: [Clear 1-2 sentence description]
**Stack**: [Technologies and tools]
**Pros**:
- [Advantage 1]
- [Advantage 2]
- [Advantage 3]
**Cons**:
- [Disadvantage 1]
- [Disadvantage 2]
- [Disadvantage 3]
**Risks**:
- [Risk 1 with likelihood]
- [Risk 2 with likelihood]
**Effort**: [S/M/L/XL or time estimate]
**Trade-offs**:
- [Trade-off 1 with mitigation]
- [Trade-off 2 with mitigation]
Verification: Run the command with --help flag to verify availability.
Design for Isolation:
When generating approaches, evaluate each against two isolation tests:
- Comprehension test: Can someone understand what each unit does without reading its internals? If a unit requires reading implementation details to understand its purpose, the boundary is wrong.
- Change test: Can you change a unit's internals without breaking its consumers? If changing implementation details forces changes elsewhere, the interface is leaking.
File size as design signal: Files exceeding 500 lines (Python/Go) or 300 lines (JavaScript/TypeScript) often indicate a unit is doing too much. This is a design smell, not just a style issue. When flagging large files, suggest extracting specific concerns (e.g., "Extract validation logic into a separate module to improve testability").
Verification: Run the command with --help flag to verify availability.
Phase 3.5: War Room Deliberation (REQUIRED)
Automatic Trigger: After generating approaches, MUST invoke Skill(attune:war-room) for expert deliberation
When War Room is invoked:
- All brainstorming context (problem, constraints, approaches) automatically passed to War Room
- Expert panel reviews, challenges, and pressures each approach
- Reversibility assessment conducted
- Multi-LLM deliberation identifies blind spots
- Supreme Commander provides synthesis with rationale
Command:
# Automatically invoked from brainstorm - DO NOT SKIP
/attune:war-room --from-brainstorm
War Room Output:
- Reversibility Score (RS) and decision type
- Red Team challenges for each approach
- Premortem analysis on selected approach
- Supreme Commander Decision document
- Implementation orders and watch points
Bypass Conditions (ONLY skip war room if ALL true):
- [ ] RS ≤ 0.40 (Type 2 decision - clearly reversible)
- [ ] Single obvious approach with no meaningful trade-offs
- [ ] Low complexity with well-documented pattern
- [ ] User explicitly declines after being shown RS assessment
Proceed to Phase 4 only after War Room completes
Phase 4: Approach Comparison
Comparison Matrix:
| Criterion | Approach 1 | Approach 2 | Approach 3 | Approach 4 | |-----------|------------|------------|------------|------------| | Technical Fit | 🟢 High | 🟡 Medium | 🟡 Medium | 🔴 Low | | Resource Efficiency | 🟡 Medium | 🟢 High | 🔴 Low | 🟡 Medium | | Time to Value | 🟢 Fast | 🟡 Medium | 🔴 Slow | 🟢 Fast | | Risk Level | 🟡 Medium | 🟢 Low | 🔴 High | 🟡 Medium | | Maintainability | 🟢 High | 🟡 Medium | 🟢 High | 🔴 Low |
Scoring: 🟢 = Good, 🟡 = Acceptable, 🔴 = Concern
Phase 5: Decision & Rationale
Selection Criteria:
- Alignment with constraints (must satisfy all)
- Risk vs. reward balance
- Team capability and experience
- Time to value
- Long-term maintainability
Template:
## Selected Approach: [Approach Name] ⭐
### Rationale
[2-3 paragraphs explaining why this approach was selected]
Key decision factors:
- [Factor 1]
- [Factor 2]
- [Factor 3]
### Trade-offs Accepted
- **Trade-off 1**: [Description] → Mitigation: [Strategy]
- **Trade-off 2**: [Description] → Mitigation: [Strategy]
### Rejected Approaches
- **Approach X**: Rejected because [reason]
- **Approach Y**: Rejected because [reason]
Verification: Run the command with --help flag to verify availability.
Phase 5.5: Record the Tradeoff (decision journal)
Persist the Phase 5 selection to docs/tradeoffs.md now, while the reasoning
is live. This is the entry that survives past the session: the decision, the
alternatives weighed, and what was given up. Draft and confirm:
- If leyline is installed, invoke
Skill(leyline:decision-journal)and follow it to append a tradeoff entry. The Phase 5 fields map directly: Selected Approach todecision, the rationale to a Y-statement, Trade-offs Accepted toconsequences_negative, and Rejected Approaches tooptions. Setphasetobrainstorm. Show the drafted entry; append on user confirmation (status startsproposed). - Fallback (leyline absent): append an entry to
docs/tradeoffs.mdby hand using the in-file ENTRY TEMPLATE; assign the nextTR-NNNid and add an active-index row.
Skip only when there was genuinely one obvious approach with no meaningful trade-off (the same condition that bypasses War Room).
Output: Project Brief
Final output saved to docs/project-brief.md:
# [Project Name] - Project Brief
**Date**: [YYYY-MM-DD]
**Author**: [Name]
**Status**: Draft | Approved
## Problem Statement
[From Phase 1]
## Goals
1. [Primary goal]
2. [Secondary goal]
3. [Tertiary goal]
## Constraints
[From Phase 2]
## Approach Comparison
[From Phase 3 & 4]
## War Room Decision
[From Phase 3.5 - includes RS assessment, Red Team challenges, premortem]
## Selected Approach
[From Phase 5, informed by War Room synthesis]
## Next Steps
1. `/attune:specify` - Create detailed specification
2. `/attune:blueprint` - Plan architecture and tasks
3. `/attune:project-init` - Initialize project structure
Verification: Run the command with --help flag to verify availability.
Questioning Patterns
Socratic Method
Clarification:
- "What do you mean by [term]?"
- "Can you give an example?"
- "What is the difference between X and Y?"
Probing Assumptions:
- "What are you assuming about [aspect]?"
- "Why do you think that assumption is valid?"
- "What if that assumption is wrong?"
Probing Reasoning:
- "Why do you think this approach is best?"
- "What evidence supports this?"
- "Are there alternative explanations?"
Questioning Viewpoints:
- "What would [stakeholder] think about this?"
- "What are the counterarguments?"
- "How might this fail?"
Probing Implications:
- "What happens if we choose this approach?"
- "What are the long-term consequences?"
- "What does this commit us to?"
Constraint-Based Thinking
Must Have (Non-negotiable):
- What absolutely must be true for success?
- What constraints cannot be changed?
Should Have (Important):
- What would significantly increase success?
- What preferences matter most?
Could Have (Nice to have):
- What would be beneficial but not critical?
- What can we defer or drop if needed?
Won't Have (Explicit exclusions):
- What are we explicitly NOT doing?
- What scope boundaries prevent creep?
Red Flags to Surface
During brainstorming, watch for:
- ⚠️ Vague problem statements ("make it better")
- ⚠️ Unclear success criteria
- ⚠️ Hidden assumptions about users or technology
- ⚠️ Single approach bias (not exploring alternatives)
- ⚠️ Scope creep in requirements
- ⚠️ Unrealistic constraints or timelines
- ⚠️ Missing stakeholder perspectives
Session State Management
Save session to .attune/brainstorm-session.json:
{
"session_id": "20260102-143022",
"started_at": "2026-01-02T14:30:22Z",
"current_phase": "approach-selection",
"problem": {
"statement": "...",
"stakeholders": ["..."]
},
"constraints": {
"technical": ["..."],
"resources": {"timeline": "...", "team": "..."}
},
"approaches": [
{
"name": "...",
"pros": ["..."],
"cons": ["..."
Truncated for display — read the full file on GitHub.
Related Skills
Agent-Reach
113.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
ruflo
82.1k🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
Claude-Code-Game-Studios
40.2kTurn Claude Code into a full game dev studio — 49 AI agents, 75 workflow skills, and a complete coordination system mirroring real studio hierarchy.
Scrapling
104.4k🕷️ The BEST Web Scraping framework that handles everything from a single request to a full-scale crawl! Don't be shy, join here: https://discord.gg/EMgGbDceNQ and follow here for daily tips and tricks: https://x.com/Scrapling_dev
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
