Commands: Planning and Execution Workflow System

Overview

The commands system provides a structured workflow for tackling complex development tasks through three distinct phases: ideation, planning, and execution. This systematic approach helps break down ambiguous requests into actionable steps while maintaining clarity and focus throughout the development process.

The command system consists of three core utilities:

1. /brainstorm - Generates ideas, explores possibilities, and evaluates multiple approaches
2. /write-plan - Creates detailed, actionable implementation plans with clear steps
3. /execute-plan - Implements plans systematically with progress tracking and validation

These commands work together as a cohesive workflow, though each can be invoked independently based on the context and requirements of the task at hand.

Philosophy

The commands system is built on these core principles:

• Separation of Concerns: Thinking (brainstorming), planning (write-plan), and doing (execute-plan) are distinct activities that benefit from focused attention
• Incremental Progress: Complex problems are decomposed into manageable, sequential steps
• Explicit Transitions: Moving between phases is deliberate and tracked
• Flexibility: Commands can be used independently or chained based on project needs
• Visibility: Each phase produces artifacts that can be reviewed, modified, or referenced

When to Use

Use Commands When:

• Requirements are ambiguous - Brainstorm first to clarify possibilities
• Task is complex - Write a plan to break it into steps before executing
• Multiple approaches exist - Brainstorm to evaluate trade-offs before committing
• Team coordination needed - Plans provide shared understanding of work to be done
• High stakes implementation - Planning reduces risk of costly mistakes
• Learning new technology - Brainstorming explores unknowns before planning
• Refactoring large codebases - Planning ensures systematic, safe changes
• Building new features - Full workflow from ideation to implementation

Skip Commands When:

• Request is trivial - Simple file reads, basic questions, small edits
• Urgent hotfix needed - Direct execution may be warranted
• Requirements are crystal clear - Can proceed directly to execution
• Purely informational task - Just need to read/analyze existing code
• Following existing patterns - Clear precedent exists in the codebase

Command Selection Matrix

┌─────────────────────┬──────────────┬─────────────┬──────────────┐
│ Scenario            │ /brainstorm  │ /write-plan │ /execute-plan│
├─────────────────────┼──────────────┼─────────────┼──────────────┤
│ Unclear approach    │      ✓       │      ✓      │      ✓       │
│ Known solution      │      -       │      ✓      │      ✓       │
│ Trivial task        │      -       │      -      │      -       │
│ Exploratory work    │      ✓       │      -      │      -       │
│ Production hotfix   │      -       │   Optional  │      ✓       │
│ New feature         │      ✓       │      ✓      │      ✓       │
│ Refactoring         │   Optional   │      ✓      │      ✓       │
└─────────────────────┴──────────────┴─────────────┴──────────────┘

Available Commands

/brainstorm

Purpose: Generate creative solutions, explore alternatives, and evaluate different approaches before committing to implementation.

Invokes: brainstorm.md - Activates brainstorming skill

Key Features:

• Divergent thinking - Generates multiple solutions
• Trade-off analysis - Evaluates pros/cons of each approach
• Constraint identification - Surfaces limitations and requirements
• Risk assessment - Identifies potential issues early
• Technology exploration - Researches new tools/frameworks

Output: List of ideas with analysis, recommended approach, and rationale

/write-plan

Purpose: Transform requirements or brainstorm results into detailed, actionable implementation plans with clear steps and success criteria.

Invokes: write-plan.md - Activates Writing-Plans skill

Key Features:

• Step decomposition - Breaks work into sequential tasks
• Dependency mapping - Identifies what must happen when
• Resource identification - Lists files, tools, and knowledge needed
• Success criteria - Defines what "done" looks like
• Risk mitigation - Plans for known challenges

Output: Structured plan with numbered steps, dependencies, and validation points

/execute-plan

Purpose: Implement the established plan systematically, tracking progress and adapting to discoveries along the way.

Invokes: execute-plan.md - Activates Executing-Plans skill

Key Features:

• Systematic execution - Follows plan steps in order
• Progress tracking - Marks completed vs remaining work
• Deviation handling - Adapts when reality differs from plan
• Validation gates - Confirms each step before proceeding
• Feedback loops - Reports issues back to planning phase if needed

Output: Implemented solution with validation of plan completion

Command Reference

/brainstorm - Ideation and Exploration

When to Use:

• Beginning a new project or feature
• Facing an unfamiliar problem domain
• Multiple valid solutions exist
• Need to evaluate technology choices
• Stakeholders haven't aligned on approach
• Exploring viral trends or market opportunities

When to Avoid:

• Solution is already known and proven
• Time is critical and requirements are clear
• Working within strict constraints (only one valid approach)
• Making minor edits to existing code

Process:

1. Understand the problem space and constraints
2. Generate 3-5 distinct approaches
3. Analyze trade-offs for each option
4. Consider technical, business, and user factors
5. Recommend best approach with clear reasoning

Integration Points:

• Feeds into /write-plan: Recommended approach becomes plan foundation
• Rapid Prototyping: Brainstorm helps select optimal tech stack
• Monetization Strategies: Explore revenue models during ideation
• Performance Optimization: Evaluate performance implications upfront

Example Triggers:

• "How should we build [feature]?"
• "What's the best approach for [problem]?"
• "Help me explore options for [requirement]"
• "What are different ways to implement [functionality]?"

/write-plan - Implementation Planning

When to Use:

• After brainstorming concludes
• Before starting significant development work
• When task has multiple interconnected steps
• Need to coordinate across team members
• Working on critical systems requiring careful changes
• Refactoring complex code

When to Avoid:

• Task is a single, atomic action
• Plan already exists and is current
• Exploratory coding session (learning by doing)
• Trivial changes to existing patterns

Process:

1. Review requirements and approach (from brainstorm or direct request)
2. Decompose work into logical, sequential steps
3. Identify dependencies between steps
4. List files, tools, and knowledge required
5. Define validation criteria for each step
6. Document risks and mitigation strategies

Plan Structure:

## Goal
[What we're building and why]

## Prerequisites
[What must exist before starting]

## Steps
1. [First atomic task]
   - Validation: [How to verify completion]
2. [Second task, depends on #1]
   - Validation: [How to verify completion]
...

## Success Criteria
[What "done" looks like]

## Risks
[Known challenges and mitigation]

Integration Points:

• Receives from /brainstorm: Selected approach to plan
• Feeds into /execute-plan: Detailed steps to implement
• Test-Driven Development: Plan includes test writing steps
• Database Design: Plan addresses schema changes
• Error Handling: Plan incorporates error scenarios

Example Triggers:

• "Create a plan for implementing [feature]"
• "Break down the work for [project]"
• "Plan the refactoring of [component]"
• "What steps are needed to [accomplish goal]?"

/execute-plan - Systematic Implementation

When to Use:

• Plan exists and is approved
• Ready to write/modify code
• All prerequisites are met
• Time to go from planning to working software

When to Avoid:

• No plan exists (write one first, or skip commands entirely)
• Plan is outdated or incorrect
• Still in exploratory/learning phase
• Requirements have changed significantly

Process:

1. Load and review the plan
2. Confirm prerequisites are met
3. Execute steps sequentially
4. Validate each step before proceeding
5. Document deviations from plan
6. Report completion and verify success criteria

Execution Patterns:

Linear Execution:

Step 1 → Validate → Step 2 → Validate → Step 3 → Complete

Iterative Execution (for complex steps):

Step 1:
  - Attempt implementation
  - Test
  - Refine
  - Validate
  → Proceed to Step 2

Adaptive Execution (when reality differs):

Step 1 → Issue Discovered → Document → Adapt Plan → Continue

Integration Points:

• Receives from /write-plan: Steps to implement
• Test-Driven Development: Write tests per plan, then implementation
• Systematic Debugging: Follow debugging plan methodically
• Performance Optimization: Implement optimizations per plan

Example Triggers:

• "Execute the plan we created"
• "Implement the feature as planned"
• "Let's start building based on the plan"
• "Begin execution of step 1"

Workflow Patterns

Pattern 1: Full Workflow (Brainstorm → Plan → Execute)

Use Case: New feature with unclear best approach

graph LR
    A[User Request] --> B[/brainstorm]
    B --> C{Multiple Options}
    C --> D[Evaluate Trade-offs]
    D --> E[Recommend Approach]
    E --> F[/write-plan]
    F --> G[Decompose Steps]
    G --> H[Define Success Criteria]
    H --> I[/execute-plan]
    I --> J[Implement Step-by-Step]
    J --> K[Validate Completion]
    K --> L[Deployed Feature]

Example Timeline:

• Minutes 0-15: Brainstorm 3-4 approaches
• Minutes 15-30: Write detailed plan for chosen approach
• Minutes 30-120: Execute plan with validation
• Final: Working, tested feature

Trigger Phrases:

• "We want to add [new feature] but not sure how"
• "Help us build [complex requirement]"
• "What's the best way to implement [vague description]?"

Pattern 2: Plan → Execute (Known Approach)

Use Case: Clear requirements, proven solution pattern

graph LR
    A[User Request] --> B[/write-plan]
    B --> C[Break Down Work]
    C --> D[/execute-plan]
    D --> E[Implement]
    E --> F[Complete]

Example Timeline:

• Minutes 0-15: Write implementation plan
• Minutes 15-90: Execute plan
• Final: Implemented solution

Trigger Phrases:

• "Implement [specific feature] using [known approach]"
• "Refactor [component] to use [pattern]"
• "Add [straightforward requirement]"

Pattern 3: Iterative Cycles

Use Case: Long-running project with multiple phases

graph TD
    A[Project Start] --> B[/brainstorm Phase 1]
    B --> C[/write-plan Phase 1]
    C --> D[/execute-plan Phase 1]
    D --> E{Phase Complete?}
    E -->|Yes| F[/brainstorm Phase 2]
    E -->|Issues| G[Re-plan]
    G --> D
    F --> H[/write-plan Phase 2]
    H --> I[/execute-plan Phase 2]
    I --> J[Project Complete]

Example Timeline:

• Week 1-2: Brainstorm → Plan → Execute Core Features
• Week 3-4: Brainstorm → Plan → Execute Secondary Features
• Week 5: Execute Polish & Deploy
• Week 6: Launch

Trigger Phrases:

• "Let's build [MVP] over [timeframe]"
• "Phase 1 is done, what's next?"
• "Iterate on [existing prototype]"

Pattern 4: Emergency Execution (Skip Planning)

Use Case: Critical bug fix, production down, time-sensitive

graph LR
    A[Critical Issue] --> B{Can Skip Planning?}
    B -->|Yes| C[Direct Execution]
    B -->|No| D[Quick Plan]
    D --> C
    C --> E[Fix Applied]
    E --> F[Retrospective]
    F --> G[Document for Future]

When Justified:

• Production system is down
• Security vulnerability discovered
• Critical bug affecting users
• Time-sensitive opportunity (viral moment)

Best Practices:

• Still validate the fix works
• Document what was done afterward
• Plan proper solution for later if this was a patch
• Conduct post-mortem to prevent recurrence

Trigger Phrases:

• "Production is down, need fix NOW"
• "Critical security issue"
• "Urgent hotfix needed"

Pattern 5: Brainstorm Only (Exploration)

Use Case: Research phase, technology evaluation, discovery

graph LR
    A[Research Question] --> B[/brainstorm]
    B --> C[Generate Options]
    C --> D[Evaluate Trade-offs]
    D --> E[Recommendation]
    E --> F[Decision Point]
    F -->|Proceed| G[/write-plan]
    F -->|Table| H[Document Findings]

Example Timeline:

• Session 1: Brainstorm approaches
• Days 1-3: Research recommended options
• Session 2: Present findings to stakeholders
• Decision: Move forward or pivot

Trigger Phrases:

• "What are our options for [problem]?"
• "Research [technology] for potential use"
• "Explore how to [achieve goal]"
• "Should we build or buy [solution]?"

Examples

Example 1: Adding Viral Sharing Feature

Context: App needs social sharing to increase organic growth

User Request: "We want users to be able to share their achievements to TikTok and Instagram. What's the best way to do this?"

Workflow:

Step 1: /brainstorm

Command: /brainstorm

Output:
- Option 1: Use native share APIs (iOS/Android)
  Pros: Native UX, works with all apps
  Cons: Limited customization, no tracking

- Option 2: SDK integration (TikTok SDK, Instagram API)
  Pros: Direct posting, rich features, analytics
  Cons: Complex setup, rate limits, maintenance

- Option 3: Generate shareable image + deeplink
  Pros: Works everywhere, fully controlled
  Cons: Extra step for user, manual posting

Recommendation: Option 3 (shareable image)
- Best for MVP and rapid iteration
- No API dependencies or rate limits
- Works across all platforms
- Can add SDKs later if needed

Step 2: /write-plan

Command: /write-plan

Output:
## Goal
Enable users to share achievements as images to social media

## Steps
1. Create achievement card component
   - Design shareable 1080x1920 image template
   - Include user stats, achievement badge, app branding
   - Validation: Renders correctly on all devices

2. Implement image generation
   - Use react-native-view-shot or similar
   - Add download to camera roll functionality
   - Validation: Image saves with good quality

3. Add share functionality
   - Integrate native share sheet
   - Pre-populate caption with deeplink
   - Validation: Share opens with image + text

4. Track sharing analytics
   - Log share initiated events
   - Track deeplink clicks (if user installs)
   - Validation: Events appear in analytics dashboard

## Success Criteria
- User can generate and share achievement in <10 seconds
- Shared images are high quality (1080x1920)
- 80%+ of shares include working deeplink

Step 3: /execute-plan

Command: /execute-plan

Process:
✓ Step 1: Created AchievementCard.tsx component
✓ Step 2: Added image generation with react-native-view-shot
✓ Step 3: Integrated Share API with deeplink
✓ Step 4: Added analytics events

Result: Users can now tap "Share Achievement" and post to any social platform

Example 2: Database Schema Refactoring

Context: Growing user data needs better organization

User Request: "Our user table is getting messy. Plan a refactoring to normalize the schema."

Workflow:

Step 1: /write-plan (Skip brainstorm - clear solution)

Command: /write-plan

Output:
## Goal
Normalize user schema to 3NF, improve query performance

## Steps
1. Analyze current schema
   - Document all columns and relationships
   - Identify normalization violations
   - Validation: Complete schema documented

2. Design new schema
   - Create users, user_profiles, user_preferences tables
   - Define foreign keys and indexes
   - Validation: Schema reviewed and approved

3. Write migration scripts
   - Create new tables
   - Migrate data from old schema
   - Add constraints and indexes
   - Validation: Migration runs on test DB

4. Update application queries
   - Modify all user-related queries
   - Update ORM models
   - Validation: All tests pass

5. Deploy with zero downtime
   - Run migration during low-traffic window
   - Monitor for errors
   - Validation: No production errors

## Risks
- Data loss during migration → Mitigation: Test on prod copy first
- Query performance regression → Mitigation: Add indexes, monitor

Step 2: /execute-plan

Command: /execute-plan

[Executes each step systematically with validation]

Example 3: Rapid Prototype for Viral Trend

Context: New trend emerging, need to capitalize quickly

User Request: "Everyone is doing AI-generated profile pictures. Can we build this in 3 days?"

Workflow:

Step 1: /brainstorm

Command: /brainstorm

Output:
- Option 1: Train custom model (Stable Diffusion)
  Time: 2+ weeks, complex

- Option 2: Use Replicate API
  Time: 1-2 days, $$ per generation

- Option 3: Use Astria/similar service
  Time: 2-3 days, simpler integration

Recommendation: Option 2 (Replicate)
- Fastest to market
- Good quality results
- Can optimize costs later

Step 2: /write-plan

Command: /write-plan

Output:
## Goal
Launch AI profile picture generator in 3 days

## Day 1
1. Set up Replicate account and test API
2. Create upload flow (5 photos)
3. Trigger generation job

## Day 2
4. Build results gallery
5. Add payment (Stripe - $9.99 for 50 photos)
6. Implement download

## Day 3
7. Add sharing features
8. Deploy to production
9. Launch on Product Hunt

Step 3: /execute-plan

Command: /execute-plan

[Fast execution over 3 days, launching on schedule]

Example 4: Systematic Debugging

Context: Complex bug affecting payment flow

User Request: "Users report payments fail intermittently. Help debug this."

Workflow:

Step 1: /brainstorm (Understand problem space)

Command: /brainstorm

Output:
Potential causes:
1. Race condition in payment processing
2. Stripe webhook failures
3. Database transaction issues
4. Network timeouts
5. Client-side state bug

Investigation approach:
- Check error logs for patterns
- Analyze Stripe webhook logs
- Review payment flow code
- Test reproduction steps

Step 2: /write-plan

Command: /write-plan

Output:
## Debugging Plan
1. Gather data
   - Pull error logs from past 7 days
   - Get Stripe webhook delivery logs
   - Interview affected users

2. Reproduce issue
   - Set up test environment
   - Attempt to trigger failure
   - Document reproduction steps

3. Isolate root cause
   - Add detailed logging
   - Test hypotheses one by one
   - Identify exact failure point

4. Implement fix
   - Code solution
   - Add regression test
   - Validate fix in staging

5. Deploy and monitor
   - Deploy to production
   - Watch error rates
   - Confirm resolution

Step 3: /execute-plan

Command: /execute-plan

[Systematic debugging leading to root cause and fix]

Integration with Other Skills

Test-Driven Development (TDD)

How Commands Support TDD:

• /brainstorm explores testable approaches
• /write-plan includes "write tests" as explicit steps
• /execute-plan implements tests before code per plan

Example Integration:

Step 1: Write test for user authentication
  - Test: User can log in with email/password
  - Validation: Test fails (red)

Step 2: Implement authentication logic
  - Code: Add login endpoint and validation
  - Validation: Test passes (green)

Step 3: Refactor for security
  - Improve: Hash passwords, add rate limiting
  - Validation: Tests still pass

Rapid Prototyping

How Commands Enable Speed:

• /brainstorm selects fastest viable approach
• /write-plan identifies shortcuts and future refactoring needs
• /execute-plan maintains momentum through clear steps

Example Integration:

/brainstorm → Choose Supabase over custom backend (save 2 days)
/write-plan → Document "use inline styles for now, refactor later"
/execute-plan → Ship MVP in 6 days, iterate based on feedback

Systematic Debugging

How Commands Provide Structure:

• /brainstorm generates hypotheses about bug causes
• /write-plan creates debugging methodology
• /execute-plan isolates and fixes root cause

Debugging Workflow:

Brainstorm → List possible causes
Plan → Design experiments to test each hypothesis
Execute → Run tests, gather data, implement fix

Performance Optimization

How Commands Guide Optimization:

• /brainstorm evaluates optimization strategies
• /write-plan prioritizes optimizations by impact
• /execute-plan implements and validates improvements

Optimization Workflow:

Brainstorm → Identify bottlenecks (DB, network, render)
Plan → Prioritize by user impact (80/20 rule)
Execute → Optimize, measure, validate

Database Design Decisions

How Commands Support Schema Work:

• /brainstorm explores normalization vs denormalization
• /write-plan maps migration steps with rollback plan
• /execute-plan runs migrations safely

Database Workflow:

Brainstorm → Evaluate schema designs
Plan → Create migration strategy (blue/green deployment)
Execute → Run migration with validation gates

Monetization Strategies

How Commands Support Revenue:

• /brainstorm explores pricing models and payment flows
• /write-plan includes payment integration steps
• /execute-plan implements billing with analytics

Monetization Workflow:

Brainstorm → Freemium vs subscription vs one-time
Plan → Stripe integration, paywall UI, trial flow
Execute → Launch with pricing experiments

Tips for Effective Command Usage

1. Don't Skip Brainstorming When Uncertain

Even if you think you know the solution, brainstorming for 5 minutes can reveal better approaches or important constraints you hadn't considered.

2. Plans Are Living Documents

If you discover issues during execution, update the plan. Don't rigidly follow a plan that reality has proven wrong.

3. Right-Size Your Plans

• Simple task: 3-5 steps
• Medium feature: 10-15 steps
• Complex project: 20-30 steps broken into phases

4. Validate Early and Often

Each plan step should have a validation criterion. Don't proceed until current step is verified.

5. Document Deviations

When execution differs from plan, document why. This learning improves future planning.

6. Use Commands to Communicate

Plans are great for async collaboration. Write a plan, get feedback, then execute together.

7. Timebox Brainstorming

Don't get stuck in analysis paralysis. Set a timebox (15-30 min) then make a decision.

8. Consider the Audience

• Solo work: Lighter plans OK
• Team work: More detailed plans help coordination
• Stakeholder review: Include context and rationale

9. Balance Speed and Planning

• Prototype/experiment: Maybe skip planning
• Refactor critical system: Definitely plan
• New feature: Usually plan

10. Leverage Command Outputs

• Save brainstorm results for future reference
• Archive plans as documentation
• Review execution notes during retrospectives

Command Workflow Diagram

digraph CommandWorkflow {
    rankdir=TD;
    node [shape=box, style=rounded];

    // Nodes
    request [label="User Request", shape=oval, style=filled, fillcolor=lightblue];
    assess [label="Assess Complexity\n& Clarity", shape=diamond, style=filled, fillcolor=lightyellow];

    brainstorm [label="/brainstorm\n\nGenerate Options\nEvaluate Trade-offs\nRecommend Approach", style=filled, fillcolor=lightgreen];

    plan [label="/write-plan\n\nDecompose Steps\nDefine Success\nIdentify Risks", style=filled, fillcolor=lightcoral];

    execute [label="/execute-plan\n\nImplement Steps\nValidate Each\nDeliver Solution", style=filled, fillcolor=lightpink];

    direct [label="Direct Execution\n(No Commands)", style=filled, fillcolor=lightgray];

    done [label="Solution Delivered", shape=oval, style=filled, fillcolor=lightblue];

    feedback [label="Issues Found?", shape=diamond, style=filled, fillcolor=lightyellow];

    // Edges
    request -> assess;

    assess -> brainstorm [label="Complex &\nUnclear"];
    assess -> plan [label="Complex &\nClear"];
    assess -> direct [label="Simple"];

    brainstorm -> plan [label="Approach\nSelected"];

    plan -> execute [label="Plan\nApproved"];

    execute -> feedback;

    feedback -> done [label="No"];
    feedback -> plan [label="Major Issues:\nRe-plan"];
    feedback -> execute [label="Minor Issues:\nAdapt"];

    direct -> done;
}

Quick Reference Card

┌─────────────────────────────────────────────────────────────┐
│                   COMMAND QUICK REFERENCE                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  /brainstorm                                                │
│  └─ When: Unclear best approach, multiple options          │
│  └─ Output: Evaluated alternatives + recommendation        │
│                                                             │
│  /write-plan                                                │
│  └─ When: Complex task needs breakdown                     │
│  └─ Output: Sequential steps + success criteria            │
│                                                             │
│  /execute-plan                                              │
│  └─ When: Plan exists, ready to implement                  │
│  └─ Output: Working solution per plan                      │
│                                                             │
├─────────────────────────────────────────────────────────────┤
│  WORKFLOW PATTERNS                                          │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Full:      /brainstorm → /write-plan → /execute-plan      │
│  Standard:  /write-plan → /execute-plan                    │
│  Research:  /brainstorm → [decision point]                 │
│  Emergency: [direct execution]                             │
│                                                             │
└─────────────────────────────────────────────────────────────┘

Conclusion

The commands system provides a structured approach to software development that balances speed with thoughtfulness. By separating ideation, planning, and execution into distinct phases, you can tackle complex problems systematically while maintaining the flexibility to adapt as you learn.

Key takeaways:

• Use commands when complexity warrants structured thinking
• Skip commands for trivial tasks where overhead outweighs benefit
• Treat plans as living documents, not rigid contracts
• Validate at each step to catch issues early
• Document deviations to improve future planning
• Integrate with other skills for maximum effectiveness

The goal isn't to use commands on every task, but to recognize when structured workflow provides value over ad-hoc execution. With practice, you'll develop intuition for when to brainstorm, when to plan, and when to just start coding.

---

Related Files:

• /brainstorm.md - Invokes brainstorming skill
• /write-plan.md - Invokes Writing-Plans skill
• /execute-plan.md - Invokes Executing-Plans skill

Version: 1.0 Last Updated: 2025-10-20