pm-workflow-guide

What this skill does

# PM Workflow Guide

This skill helps you navigate CCPM's 49+ commands by automatically detecting your current workflow phase and suggesting the most appropriate commands.

## Natural Workflow Commands (RECOMMENDED)

**Start here!** CCPM provides 6 simple, chainable commands that cover the complete workflow:

### Quick Reference Card

```
Planning      → /ccpm:plan "title"              Create & plan a new task
Working       → /ccpm:work                       Start/resume implementation
Progressing   → /ccpm:sync "summary"             Save progress to Linear
Committing    → /ccpm:commit                     Create git commit (conventional)
Verifying     → /ccpm:verify                     Run quality checks
Finalizing    → /ccpm:done                       Create PR & finalize
```

### Complete Workflow Examples

**Example 1: New feature from scratch**
```
/ccpm:plan "Add two-factor authentication" my-app
/ccpm:work                                # Start implementation
/ccpm:sync "Implemented authenticator logic"
/ccpm:commit                              # Auto-formats: feat(auth): implement 2FA
/ccpm:verify                              # Run tests, linting, build
/ccpm:done                                # Create PR and finalize
```

**Example 2: Fixing a bug**
```
/ccpm:plan BUG-456                        # Plan existing bug ticket
/ccpm:work                                # Resume where you left off
/ccpm:sync "Fixed race condition"
/ccpm:commit                              # Auto-formats: fix(cache): prevent race condition
/ccpm:verify                              # Ensure fix doesn't break tests
/ccpm:done                                # Ship the fix
```

**Example 3: Documentation update**
```
/ccpm:plan "Update API documentation" my-app
/ccpm:work
/ccpm:sync "Added deployment guide"
/ccpm:commit                              # Auto-formats: docs(api): add deployment guide
/ccpm:verify
/ccpm:done
```

### Command Details

1. **`/ccpm:plan`** - Smart planning
   - Create new task: `/ccpm:plan "title" <project>`
   - Plan existing issue: `/ccpm:plan <issue-id>`
   - Update plan: `/ccpm:plan <issue-id> "changes"`

2. **`/ccpm:work`** - Smart work
   - Auto-detects: Not started → start, In progress → resume
   - Auto-detects issue from git branch name

3. **`/ccpm:sync`** - Save progress
   - Auto-detects issue from git branch
   - Shows git changes summary
   - Updates Linear with findings

4. **`/ccpm:commit`** - Git integration
   - Conventional commits format (feat/fix/docs/refactor/etc)
   - Links commits to Linear issues automatically
   - Example: `fix(auth): handle token expiration`

5. **`/ccpm:verify`** - Quality checks
   - Auto-detects issue from branch
   - Runs tests, linting, build checks sequentially
   - Fails fast if checks don't pass

6. **`/ccpm:done`** - Finalize
   - Pre-flight safety checks
   - Creates PR with auto-generated description
   - Syncs Linear status to Jira
   - Requires confirmation for external writes (safety)

### When to Use Project Configuration Commands

The 6 natural commands cover 90% of workflows. Use project configuration commands for:
- **Project setup**: `/ccpm:project:add` (add new project)
- **Project management**: `/ccpm:project:list`, `/ccpm:project:show` (view projects)
- **Project switching**: `/ccpm:project:set` (switch active project)
- **Design refresh**: `/ccpm:figma-refresh` (refresh Figma design cache)

## Instructions

### Automatic Phase Detection

This skill activates when user mentions workflow-related keywords and provides context-aware command suggestions.

### Planning Phase

**Trigger phrases**:
- "plan this task"
- "create new task/epic/feature"
- "write a spec"
- "gather requirements"
- "need to understand..."
- "starting a new project"

**Recommended commands**:

1. **Natural command** → `/ccpm:plan "Task title" <project>`
   - Simple, chainable planning
   - Creates Linear issue
   - Gathers context from Jira/Confluence/Slack
   - Analyzes codebase
   - Generates comprehensive plan

2. **Plan existing issue** → `/ccpm:plan <issue-id>`
   - Plans an existing Linear issue
   - Gathers context and generates checklist
   - Use when issue already exists

3. **Update existing plan** → `/ccpm:plan <issue-id> "changes"`
   - Requirements changed during implementation
   - Interactive clarification
   - Impact analysis
   - Updates plan with changes

**Example conversation**:
```
User: "I need to plan the new user authentication feature"

Claude: [pm-workflow-guide activates]

I'll help you plan this. Here's what to use:

1. NEW TASK → /ccpm:plan "User authentication" my-app
2. EXISTING ISSUE → /ccpm:plan <issue-id>
3. QUICK INTERNAL → /ccpm:plan "task" my-app

The first option is recommended - it's simple and chainable!

Which applies to your situation?
```

### Spec Management Phase

**Trigger phrases**:
- "write a spec"
- "need architecture document"
- "document this feature"
- "create epic/feature"
- "requirements doc"

**Recommended commands**:

1. **Plan the work** → `/ccpm:plan "Task title" <project>`
   - Creates Linear issue with comprehensive plan
   - Gathers context from Jira/Confluence/Slack
   - Analyzes codebase
   - Generates implementation checklist

2. **Update plan with details** → `/ccpm:plan <issue-id> "additional requirements"`
   - Add architecture details
   - Specify API design requirements
   - Document data model needs
   - Add testing and security considerations

**Example conversation**:
```
User: "Let's implement the payment gateway integration"

Claude: [pm-workflow-guide activates]

⚠️ This sounds like a complex feature that needs planning first.

Recommended workflow:
1. /ccpm:plan "Payment Gateway Integration" my-app
2. Review the plan (architecture, security, API design)
3. Update plan if needed: /ccpm:plan <issue-id> "additional details"
4. Then start implementation: /ccpm:work

Would you like to start with planning?
```

### Implementation Phase

**Trigger phrases**:
- "start coding"
- "begin implementation"
- "let's build this"
- "what should I work on"
- "ready to code"
- "save my progress"
- "commit this code"

**Recommended commands**:

1. **Natural command** → `/ccpm:work`
   - Start or resume implementation
   - Auto-detects issue from git branch
   - Fetches full task context
   - Lists available agents
   - Coordinates parallel work

2. **Save progress** → `/ccpm:sync "summary"`
   - Save work-in-progress to Linear
   - Auto-detects issue from git branch
   - Documents changes made
   - Updates Linear context
   - Maintains full history

3. **Commit code** → `/ccpm:commit`
   - Create conventional git commit
   - Auto-formats commit message
   - Links to Linear issue
   - Example: `feat(auth): add 2FA support`

**Example conversation**:
```
User: "Let's start working on AUTH-123"

Claude: [pm-workflow-guide activates]

Perfect! Use the natural workflow:

/ccpm:work                    # Start implementation (auto-detects AUTH-123)
/ccpm:sync "progress note"    # Save progress as you work
/ccpm:commit                  # Create conventional commits
/ccpm:verify                  # Check quality when done
/ccpm:done                    # Create PR and finalize

Start with: /ccpm:work
Ready to proceed?
```

### Verification Phase

**Trigger phrases**:
- "ready to test"
- "done coding"
- "check my work"
- "run quality checks"
- "verify implementation"

**Recommended commands**:

1. **Natural command** → `/ccpm:verify`
   - Run all quality checks
   - Auto-detects issue from git branch
   - Runs tests, linting, build checks
   - Comprehensive code review
   - Final approval when passing

**Example conversation**:
```
User: "I'm done implementing, ready to test"

Claude: [pm-workflow-guide activates]

Perfect! Let's verify your work:

/ccpm:verify

This will:
✓ Run all automated checks (tests, linting, build)
✓ Perform comprehensive code review
✓ Security audit
✓ Performance check
✓ Final approval when passing

Ready to proceed?
```

### Completion Phas