Skip to content
Skills Library
Programming · Planning

phx-brainstorm

/phx-brainstorm

Brainstorm Elixir/Phoenix features — explore ideas, compare approaches, gather requirements. Use when vague idea, not sure how to approach, or want to discuss before plan.

Licence
MIT
Last repository change
22.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 22.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Brainstorm Elixir/Phoenix features — explore ideas, compare approaches, gather requirements. Use when vague idea, not sure how to approach, or want to discuss before plan.

Original author description

Brainstorm Elixir/Phoenix features — explore ideas, compare approaches, gather requirements. Use when vague idea, not sure how to approach, or want to discuss before plan.

How it works

  1. Usage
  2. Workflow
  3. Phase 1: Adaptive Interview
  4. Phase 2: Decision Point
  5. Phase 3: Research (Diverge → Evaluate → Converge)
  6. Iron Laws
  7. Integration
  8. References
Original SKILL.md headings · 142 lines, 792 words
SKILL.md preview
---
name: phx-brainstorm
description: Brainstorm Elixir/Phoenix features — explore ideas, compare approaches,
  gather requirements. Use when vague idea, not sure how to approach, or want to discuss
  before plan.
---

# Brainstorm — Adaptive Requirements Gathering

Interactive interview → research → synthesis loop. Produces structured
`interview.md` that `/skill:phx-plan` detects and consumes (skipping clarification).

## Usage

```text
/skill:phx-brainstorm Add some kind of notification system
/skill:phx-brainstorm Improve authentication security
/skill:phx-brainstorm                    # starts with open question
```

## Workflow

```
/skill:phx-brainstorm {topic}
    |
    v
[INTERVIEW] ←──────────────────┐
    |                           |
    v (sufficient OR user exit) |
[DECISION POINT]                |
    ├─ Research ──→ [RESEARCH] ─┘
    ├─ Continue interview ──────┘
    ├─ Make a plan ──→ STOP (suggest /skill:phx-plan {slug})
    ├─ Store & exit ──→ STOP (artifacts saved)
    └─ Discuss ──→ freeform ──→ [DECISION POINT]
```

## Phase 1: Adaptive Interview

Create `.claude/plans/{slug}/` directory. Start asking ONE question at a time.

### Coverage Dimensions

Track coverage across 6 dimensions (0=uncovered, 1=partial, 2=sufficient).
**Ask Scope early** — for "optimize X" topics, ask about boundaries (upstream
OK? Local-only? CI vs dev?) before research, not during.

| Dim | Target | Sufficient signal |
|-----|--------|-------------------|
| What | Specific behavior/features | Concrete verbs, not "some kind of" |
| Why | Problem solved, user need | Clear benefit stated |
| Scope | In/out boundaries | Explicit exclusions stated |
| Where | Modules, contexts, pages | File paths or context names mentioned |
| How | Approach, constraints | At least one concrete constraint |
| Edge | Error states, scale, auth | 2+ edge cases identified |

Interview is "sufficient" when total score >= 8 out of 12.

### Context-Aware Questioning

**Before each question**, run a brief codebase scan on topics the user mentioned:

1. User mentions a topic (e.g., "notifications") → run Grep/Glob for related patterns
2. Use scan results to ground your next question in what actually exists
3. Unknown/niche topic → suggest research pause before continuing

### Signal Detection

- **Vague answer** ("maybe", "not sure") → probe deeper on same dimension
- **Niche topic** mentioned → "This involves {X}. Want me to research it first?"
- **Detailed answer** covering 3+ dimensions → mark all covered, advance
- **No new coverage** for 2 consecutive questions → suggest moving to Decision Point

## Phase 2: Decision Point

Write interview.md first, then use AskUserQuestion — every option below
relies on the saved file. Move past this point only on a formal choice.

1. Write current state to `.claude/plans/{slug}/interview.md`
2. Show coverage summary: "Coverage: What 2/2 | Why 2/2 | Scope 1/2 | ..."
3. Use AskUserQuestion with EXACTLY these options (4 max — the tool's
   hard limit; the auto-added "Other" covers freeform discussion):

   - **Research** — search codebase + internet for approaches (2 agents)
   - **Continue interview** — ask more questions
   - **Make a plan** — I'll suggest: `/skill:phx-plan .claude/plans/{slug}/interview.md`
   - **Store & exit** — save everything, come back later

4. Wait for user response. Do NOT proceed without explicit choice

**AskUserQuestion discipline**: decisions only, never narration or
rhetorical check-ins. Every option states concrete impact (what happens,
what it costs) so the user can pick without follow-up questions.

## Phase 3: Research (Diverge → Evaluate → Converge)

**First cycle: MAX 2 agents** — keep it fast (~2-3 min). Spawn in ONE
Tool Use block with `run_in_background: true`:

- `phoenix-patterns-analyst`: "How does this codebase handle {topics}?"
  Write to `.claude/plans/{slug}/research/codebase-scan.md`
- `web-researcher`: "Elixir/Phoenix approaches to {topics}"
  Return 500-word summary

**Do NOT spawn additional specialist agents** in the first cycle.
If user wants deeper investigation, they pick "More research" at the
next Decision Point — then spawn focused agents for specific questions.

**Evaluate** — for each approach found:

- Thesis: why it works for THIS codebase
- Antithesis: why it might NOT work (scale, complexity, pattern conflicts)

**Converge** — present 2-3 approaches with honest trade-offs.
Do NOT recommend one. Return to Decision Point (AskUserQuestion).

See `references/research-integration.md` for details.

## Iron Laws

1. **NEVER auto-transition** to `/skill:phx-plan` — always present as option, let user choose
2. **ONE question at a time** — never dump a question list
3. **Always write artifacts** — `interview.md` is the contract with `/skill:phx-plan`
4. **Scan codebase between questions** — every question must be context-aware
5. **AskUserQuestion at EVERY decision point** — never flow past without formal choice.
   This is the most critical law. After interview, after research, after discuss — ALWAYS
   present options via AskUserQuestion. Never let conversation skip the checkpoint
6. **STOP after presenting options** — do not proceed without user input
7. **MAX 2 agents in first research cycle** — deeper dives are subsequent cycles.
   User picks "More research" to go deeper, not the skill

## Integration

```
/skill:phx-brainstorm ──→ interview.md ──→ /skill:phx-plan (skips clarification)
                                 ──→ /skill:phx-plan --existing (deepens)
                                 ──→ stored for later session
```

Position: optional upstream of `/skill:phx-plan` in workflow cycle.

## References

- `references/interview-techniques.md` — coverage scoring,
  question templates, scan patterns, signal detection, interview.md format
- `references/research-integration.md` — diverge-evaluate-converge,
  agent spawn templates, approach presentation format
Files in this package (3)
  • SKILL.md 6 KB
  • references/interview-techniques.md 9 KB
  • references/research-integration.md 7 KB

Versions

RepositoryScoreLicence
This page · oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT
oliver-kriska/claude-elixir-phoenix100MIT

Database snapshot: 13.11.2026 · package version a0960d02598a (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100brainstorm
    Brainstorm Elixir/Phoenix features — explore ideas, compare approaches, gather requirements. Use when vague idea, not sure how to approach, or want to discuss before plan.
  • 100phx-full
    Run portable end-to-end lifecycle with gates. Use for full features; use $elixir-phoenix:phx-work for an existing plan.
  • 100elixir-expert
    Expert-level Elixir, Phoenix, OTP, and concurrent systems. Use when the user mentions Phoenix, OTP, Erlang, concurrent, or functional, or when the task involves Elixir Fundamentals or Phoenix Framework.
  • 100gendiff
    Use elixirstream.dev's gendiff API to see exactly what changed between two versions (and flag sets) of an Elixir/Phoenix code generator, so you upgrade from real diffs instead of guessing. Trigger this whenever the user wants to upgrade or bump Phoenix, phx.new, phx.gen.auth,…
  • 100brainstorm
    Explores requirements and approaches through collaborative dialogue before planning implementation. Use when the user says "brainstorm", "explore idea", "what should we build", "think through this", or "let's discuss approaches".
  • 95sentry-elixir-sdk
    Full Sentry SDK setup for Elixir. Use when asked to "add Sentry to Elixir", "install sentry for Elixir", or configure error monitoring, tracing, logging, or crons for Elixir, Phoenix, or Plug applications. Supports Phoenix, Plug, LiveView, Oban, and Quantum.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.