brainstorm

Facilitate repository-aware requirements discovery and PRD seeding for software features.

Updated Apr 13, 2026
One-click install
npx skills add https://github.com/MaplumeX/deepresearch --skill brainstorm-maplumex
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: brainstorm
Source: https://github.com/MaplumeX/deepresearch/tree/main/.agents/skills/brainstorm
Command: npx skills add https://github.com/MaplumeX/deepresearch --skill brainstorm-maplumex

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Facilitate structured, repository-aware requirements discovery for software features so teams and AI agents can move from vague ideas to a testable MVP without wasting cycles on low-value questions. The Skill ensures ideas are captured immediately, research is performed where needed, decisions are recorded in a PRD, and the scope converges through single-question Q&A loops.

Core Features & Use Cases

  • Task-first PRD seeding: Automatically create a task directory and seed a living prd.md that records goals, assumptions, open questions, and acceptance criteria; useful when a stakeholder requests a new feature but the scope is unclear.
  • Research-first option generation: Inspect the repository and external patterns to propose 2–3 concrete implementation approaches with trade-offs; ideal for choosing libraries, architectures, or UX paths for complex features.
  • Diverge → Converge Q&A loop: Run an expansion sweep to consider future evolution and edge cases, then ask one high-value question at a time to converge on an MVP and produce an ADR-lite decision record; useful when balancing reliability, cost, and development speed.

Quick Start

Start a brainstorm by asking the assistant to scope a new feature and propose 2–3 concrete implementation approaches with trade-offs for this repository.

Frequently Asked Questions about brainstorm

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I scope a vague software feature request into a testable MVP?

Scoping a vague feature into an MVP requires collaborative requirements discovery that inspects the repository, proposes implementation approaches, and converges scope through single-question Q&A loops. It records goals and acceptance criteria in a living PRD.

What is the best way to document technical decisions when choosing between multiple implementation paths?

Documenting technical decisions for multiple paths involves generating an ADR-lite decision record after researching 2-3 concrete approaches with trade-offs. A diverge-to-converge Q&A loop balances reliability, cost, and speed before recording the final choice.

How do I seed a PRD with goals and acceptance criteria for an unclear new feature?

Seeding a PRD for an unclear feature uses task-first PRD seeding to automatically create a task directory and generate a living prd.md. This living document captures goals, assumptions, open questions, and acceptance criteria immediately as ideas are discussed.

Can I compare architectural approaches and trade-offs by inspecting my existing repository?

Yes, you can compare architectural approaches using research-first option generation to inspect the repository and external patterns. It proposes 2-3 concrete implementation paths with trade-offs, ideal for choosing libraries, architectures, or UX flows for complex features.

Does this requirements discovery process support automatic task creation for development teams?

Yes, the requirements discovery process supports automatic task creation alongside repository inspection and integration with task scripting. This allows development teams and AI agents to move from vague ideas to scoped MVPs and actionable development tasks efficiently.

When should I not use a diverge-converge Q&A loop for software requirements gathering?

You should avoid a diverge-converge Q&A loop when requirements are already fully defined and no multiple implementation paths exist. It is designed specifically for scenarios needing scope convergence, edge case exploration, and balancing reliability with development speed.