Use when executing Phase 1 of a vrau workflow - after workflow setup, when design/brainstorm.md doesn't exist yet
Executes Phase 1 of vrau workflow to produce a thorough, reviewed brainstorm document.
/plugin marketplace add mguilarducci/vrau/plugin install vrau@vrau-marketplaceThis skill inherits all available tools. When active, it can use any tool Claude has access to.
You're now in Phase 1 (Brainstorm) of the vrau workflow.
Goal: Produce a thorough, reviewed brainstorm document exploring requirements, design, and implementation approach.
Each step is stateless. Subagents have no memory of previous steps. Use the execution log to persist context.
Execution log location: docs/designs/<workflow>/execution-log.md
Every step MUST:
git add docs/designs/<workflow>/execution-log.md
git commit -m "vrau(<workflow>): update execution log - <step name>"
git push
When dispatching subagents: Include execution log content in the prompt so the subagent has full context.
| Step | Model | Rationale |
|---|---|---|
| Pre-checks | haiku | Simple verification tasks |
| Brainstorming | main session | USER must answer questions |
| Save | sonnet | Standard operations |
| Breakdown check | sonnet | Always evaluate scope before review |
| Self-review | sonnet | Optional quality check |
| Formal review | opus | Via reviewer agent |
| PR/Merge | haiku | Mechanical git operations |
Ask the user what to brainstorm:
What would you like to brainstorm?
Options:
1. GitHub issue (provide issue number)
2. Specific file or feature (provide description)
3. General task (provide description)
Please specify:
Wait for user response. Use their input as the task description for the rest of the phase.
After getting user input, create the execution log:
# Execution Log: <workflow>
## Workflow Context
- **Task:** <user's task description>
- **Phase:** brainstorm
- **Branch:** (pending)
- **Started:** <timestamp>
## Brainstorm
- **Status:** pending
- **File:** docs/designs/<workflow>/design/brainstorm.md
## Last Updated
<timestamp> - initialized
git add docs/designs/<workflow>/execution-log.md
git commit -m "vrau(<workflow>): initialize execution log"
git push
Model enforcement: Always dispatch Task tool with haiku model:
Task(subagent_type="general-purpose", model="haiku", prompt="[Branch Setup instructions]")
git fetch origin && git checkout main && git pull
Ask user about branch strategy:
Branch setup options:
A) Git worktree (isolated, recommended for complex work)
B) New branch from main
C) Continue in current branch
Which option? [A/B/C]
Execute based on choice:
If A (worktree):
superpowers:using-git-worktrees skillIf B (new branch):
git checkout -b vrau/<workflow>/brainstorm
git push -u origin vrau/<workflow>/brainstorm
If C (current branch):
After branch setup, update execution log:
Invoke wrapper skill to enforce haiku model:
Skill tool:
- skill: "vrau:brainstorm-step-research"
The skill will:
Output: Research summary to pass to brainstorming step.
After research, update execution log:
## Research Summary section with findingsModel enforcement: Always dispatch Task tool with haiku model:
Task(subagent_type="general-purpose", model="haiku", prompt="[Pre-checks instructions]")
Run these checks ONCE at the start of the brainstorm phase:
Run the test suite (if one exists):
npm test # or pytest, cargo test, etc.
Start the dev server (if applicable):
npm run dev # or similar
These checks establish baseline health and inform the brainstorm.
After pre-checks, update execution log:
CRITICAL: Brainstorming runs in MAIN session - USER must answer questions.
Do NOT dispatch a subagent for brainstorming. Subagents cannot interact with the user.
Skill tool:
- skill: "superpowers:brainstorming"
- args: "[task description from user]"
The skill will:
Why main session? Brainstorming requires human judgment. A subagent answering its own questions produces biased, low-quality designs.
Completion signal: The skill produces a brainstorm document ready to save.
After brainstorming, update execution log:
in_progressModel enforcement: Always dispatch Task tool with sonnet model:
Task(subagent_type="general-purpose", model="sonnet", prompt="[Step 2 instructions]")
Immediately after brainstorming completes, save the output:
docs/designs/<workflow>/design/brainstorm.md
Commit immediately:
git add docs/designs/<workflow>/design/brainstorm.md
git commit -m "vrau(<workflow>): complete initial brainstorm"
Why commit now? Claude Code is stateless. Each save/commit creates a recovery point. If the session ends, you can resume from this checkpoint.
After save, update execution log:
completeModel enforcement: Always dispatch Task tool with sonnet model:
Task(subagent_type="general-purpose", model="sonnet", prompt="[Step 3 instructions]")
Always check if the brainstorm should be split. Smaller, focused workflows are preferred over large ones.
Evaluate:
If breakdown makes sense:
Create breakdown document:
docs/designs/<workflow>/design/brainstorm-breakdown.md
Content format:
# Brainstorm Breakdown: <workflow>
## Original Scope
<one-line summary of original brainstorm>
## Proposed Sub-Designs
1. **<sub-design-1>**: <one-line description>
2. **<sub-design-2>**: <one-line description>
3. **<sub-design-3>**: <one-line description>
## Rationale
<why splitting makes sense>
## Dependencies
<any ordering constraints between sub-designs>
Commit breakdown:
git add docs/designs/<workflow>/design/brainstorm-breakdown.md
git commit -m "vrau(<workflow>): propose brainstorm breakdown"
Ask user:
"I've analyzed the scope and recommend splitting this into smaller workflows: [list sub-designs]
Options: A) Proceed with separate workflows for each sub-design (recommended) B) Continue with the current workflow as-is"
If user chooses A (separate workflows):
rm -rf docs/designs/<workflow>/vrau:start for each sub-designIf user chooses B (continue as-is):
If breakdown doesn't make sense:
After breakdown check, update execution log:
Model enforcement: Always dispatch Task tool with sonnet model:
Task(subagent_type="general-purpose", model="sonnet", prompt="[Step 4 instructions]")
Before requesting formal review, do a quick self-check:
If something is missing, add it now. Save and commit:
git add docs/designs/<workflow>/design/brainstorm.md
git commit -m "vrau(<workflow>): refine brainstorm after self-review"
After self-review, update execution log:
IMPORTANT: Before requesting review, remind the user about session compaction:
"Before I request a formal review, this is a good time to compact the session to reduce token usage and cost. Would you like me to proceed with the review now, or would you prefer to compact first?"
Wait for user response. If user wants to compact, pause here and let them handle it.
Invoke wrapper skill to enforce opus model:
Skill tool:
- skill: "vrau:review-step-spawn-reviewer"
The skill will:
When review is approved: Proceed to Step 6.
After review approved, update execution log:
approvedModel enforcement: Always dispatch Task tool with haiku model:
Task(subagent_type="general-purpose", model="haiku", prompt="[Step 6 instructions]")
Once brainstorm is approved, open a PR for the brainstorm phase:
Ensure all changes are committed:
git status # should be clean
Push branch:
git push -u origin vrau/<workflow>/brainstorm
Create PR:
gh pr create --title "vrau(<workflow>): Phase 1 - Brainstorm" --body "$(cat <<'EOF'
## Summary
- Completed brainstorm phase for <workflow>
- Addressed review feedback
- Ready to proceed to planning phase
## Brainstorm Document
See `docs/designs/<workflow>/design/brainstorm.md`
## Next Steps
- Merge this PR
- Proceed to Phase 2 (Plan)
EOF
)"
Merge PR:
gh pr merge --squash --delete-branch
Update local main:
git checkout main
git pull
Update execution log for next phase:
plan## Plan section with Status: pendingBrainstorm phase is now complete. Report to user:
"Phase 1 (Brainstorm) is complete and merged to main. Ready to proceed to Phase 2 (Plan)?"
Wait for user confirmation, then invoke:
Skill tool:
- skill: "vrau:plan-phase"
This will load Phase 2 instructions and continue the workflow.
This skill should be used when the user asks about libraries, frameworks, API references, or needs code examples. Activates for setup questions, code generation involving libraries, or mentions of specific frameworks like React, Vue, Next.js, Prisma, Supabase, etc.
Creating algorithmic art using p5.js with seeded randomness and interactive parameter exploration. Use this when users request creating art using code, generative art, algorithmic art, flow fields, or particle systems. Create original algorithmic art rather than copying existing artists' work to avoid copyright violations.