Goal: Create DSP architecture specification (architecture.md)

Duration: 5-10 minutes

Process:

1. Read creative brief:

cat plugins/${PLUGIN_NAME}/.ideas/creative-brief.md

2. Identify plugin technical approach:

   • Audio effect, MIDI effect, synthesizer, or utility?
   • Input/output configuration (mono, stereo, sidechain)
   • Processing type (time-domain, frequency-domain, granular)

3. Research JUCE DSP modules:

   • Search for relevant juce::dsp classes for the identified plugin type
   • Use WebSearch for JUCE documentation and examples
   • Document specific classes (e.g., juce::dsp::Gain, juce::dsp::IIR::Filter)

4. Research professional plugin examples:

   • Search web for industry leaders (FabFilter, Waves, UAD, etc.)
   • Document 3-5 similar plugins
   • Note sonic characteristics and typical parameter ranges

5. Research parameter ranges:

   • Industry-standard ranges for plugin type
   • Typical defaults (reference professional plugins)
   • Skew factors for nonlinear ranges

6. Check design sync (if mockup exists):

   • Look for plugins/${PLUGIN_NAME}/.ideas/mockups/v*-ui.yaml
   • If exists: Compare mockup parameters with creative brief
   • If conflicts found: Invoke design-sync skill to resolve
   • Document sync results

Output:

Create plugins/${PLUGIN_NAME}/.ideas/architecture.md using the template from assets/architecture-template.md.

Required sections:

1. Title: # DSP Architecture: [PluginName]
2. Contract header (immutability statement)
3. ## Core Components - Each DSP component with structured format
4. ## Processing Chain - ASCII diagram showing signal flow
5. ## Parameter Mapping - Table mapping parameter IDs to components
6. ## Algorithm Details - Implementation approach for each algorithm
7. ## Special Considerations - Thread safety, performance, denormals, sample rate
8. ## Research References - Professional plugins, JUCE docs, technical resources

State management:

1. Create/update .continue-here.md:

Create .continue-here.md using template from assets/continue-stage-0-template.md with variables:

• ${PLUGIN_NAME} - Plugin name
• ${TIMESTAMP} - Current timestamp

2. Update PLUGINS.md status to 🚧 Stage 0 and add timeline entry

3. Git commit:

git add plugins/${PLUGIN_NAME}/.ideas/architecture.md plugins/${PLUGIN_NAME}/.continue-here.md PLUGINS.md
git commit -m "$(cat <<'EOF'
feat: [PluginName] Stage 0 - research complete

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>
EOF
)"

Decision menu (numbered format):

Display menu from assets/decision-menu-stage-0.md

Goal: Calculate complexity and create implementation plan (plan.md)

Duration: 2-5 minutes

Preconditions:

PARAM_SPEC_EXISTS=$(test -f "plugins/${PLUGIN_NAME}/.ideas/parameter-spec.md" && echo "true" || echo "false")
ARCH_EXISTS=$(test -f "plugins/${PLUGIN_NAME}/.ideas/architecture.md" && echo "true" || echo "false")

echo "Parameter spec: ${PARAM_SPEC_EXISTS}"
echo "Architecture: ${ARCH_EXISTS}"

Exit skill and wait for user to create contracts.

Process (contracts confirmed present):

1. Read all contracts:

cat plugins/${PLUGIN_NAME}/.ideas/parameter-spec.md
cat plugins/${PLUGIN_NAME}/.ideas/architecture.md

2. Calculate complexity score:

Formula:

score = min(param_count / 5, 2.0) + algorithm_count + feature_count
Cap at 5.0

Extract metrics:

From parameter-spec.md:

• Count parameters (each parameter definition = 1)
• param_score = min(param_count / 5, 2.0)

From architecture.md:

• Count distinct DSP algorithms/components
• algorithm_count = number of juce::dsp classes or custom algorithms

Features to identify (from architecture.md):

• Feedback loops present? (+1)
• FFT/frequency domain processing? (+1)
• Multiband processing? (+1)
• Modulation systems (LFO, envelope)? (+1)
• External MIDI control? (+1)
• feature_count = sum of above

Display breakdown:

Complexity Calculation:
- Parameters: [N] parameters ([N/5] points, capped at 2.0) = [X.X]
- Algorithms: [N] DSP components = [N]
- Features: [List features] = [N]
Total: [X.X] / 5.0

3. Determine implementation strategy:

   • Simple (score ≤ 2.0): Single-pass implementation
   • Complex (score ≥ 3.0): Phase-based implementation with staged commits

4. For complex plugins, create phases:

Stage 4 (DSP) phases:

• Phase 4.1: Core processing (essential audio path)
• Phase 4.2: Parameter modulation (APVTS integration)
• Phase 4.3: Advanced features (if applicable)

Stage 5 (GUI) phases:

• Phase 5.1: Layout and basic controls
• Phase 5.2: Advanced UI elements
• Phase 5.3: Polish and styling (if applicable)

Each phase needs description, test criteria, estimated duration.

Output:

Create plugins/${PLUGIN_NAME}/.ideas/plan.md using the template from assets/plan-template.md.

State management:

1. Update .continue-here.md:

Create .continue-here.md using template from assets/continue-stage-1-template.md with variables:

• ${PLUGIN_NAME} - Plugin name
• ${TIMESTAMP} - Current timestamp
• ${COMPLEXITY_SCORE} - Calculated complexity score
• ${PHASED_IMPLEMENTATION} - true/false
• ${IMPLEMENTATION_STRATEGY} - "Single-pass" or "Phased implementation"

2. Update PLUGINS.md status to 🚧 Stage 1 and add timeline entry

3. Git commit:

git add plugins/${PLUGIN_NAME}/.ideas/plan.md plugins/${PLUGIN_NAME}/.continue-here.md PLUGINS.md
git commit -m "$(cat <<'EOF'
feat: [PluginName] Stage 1 - planning complete

Complexity: [X.X]
Strategy: [Single-pass | Phased implementation]

🤖 Generated with Claude Code

Co-Authored-By: Claude <noreply@anthropic.com>
EOF
)"

Decision menu (numbered format):

Display menu from assets/decision-menu-stage-1.md