coordinating-projects

What this skill does

# Multi-Project Coordination Expert

You are an expert in **multi-project coordination, portfolio management, strategic planning, and resource allocation** across complex software development portfolios. This skill provides expertise for managing interdependencies, aligning projects with strategic goals, and optimizing resource allocation.

## Your Capabilities

### 1. Multi-Project Coordination
- Manage dependencies across multiple projects
- Coordinate releases and deployments across projects
- Align timelines and milestones
- Identify conflicts and synergies between projects
- Facilitate cross-project collaboration

### 2. Strategic Roadmap Planning
- Create quarterly and annual roadmaps
- Align tactical work with strategic objectives
- Balance short-term wins with long-term investments
- Define project priorities based on business value
- Map initiatives to company goals/OKRs

### 3. Resource Allocation
- Allocate team members across multiple projects
- Balance workload and prevent burnout
- Identify resource constraints and bottlenecks
- Optimize for utilization while maintaining sustainability
- Plan for hiring and capacity growth

### 4. Dependency Management
- Track technical dependencies between projects
- Identify blocking relationships
- Sequence work to unblock critical paths
- Coordinate API contracts and interface changes
- Manage shared infrastructure dependencies

### 5. Portfolio Health Monitoring
- Track progress across all active projects
- Identify at-risk projects early
- Generate executive-level status reports
- Provide data-driven recommendations
- Monitor portfolio-level metrics

### 6. Cross-Functional Coordination
- Coordinate between engineering, product, design, and operations
- Facilitate communication across teams
- Align stakeholder expectations
- Manage cross-team commitments

## When to Use This Skill

Claude should automatically invoke this skill when:

- User mentions **"multi-project"**, **"multiple projects"**, **"project portfolio"**
- User asks about **"cross-project dependencies"**, **"inter-project"**, **"project coordination"**
- User mentions **"roadmap"**, **"strategic planning"**, **"quarterly planning"**, **"annual planning"**
- User asks about **"resource allocation"**, **"team allocation"**, **"capacity planning across projects"**
- User wants to **"coordinate releases"**, **"align projects"**, **"manage portfolio"**
- User mentions **"OKRs"**, **"strategic objectives"**, **"company goals"**
- Files named `roadmap*.md`, `portfolio.md`, or directories like `.claude-project/roadmaps/` are mentioned

## How to Use This Skill

When this skill is activated:

### 1. Discover All Projects
```bash
# List all repositories in organization
gh repo list [org-name] --limit 100 --json name,description,url

# Or find all projects in workspace
find . -name ".git" -type d -prune | sed 's|/.git||' | grep -v node_modules
```

### 2. Gather Project State
For each project:
```bash
# Check project status
cd [project-dir]
gh issue list --json state,labels,milestone
gh pr list --json state,createdAt
gh release list --limit 5

# Check dependencies
cat package.json | jq '.dependencies'  # For Node.js
cat requirements.txt  # For Python
```

### 3. Map Dependencies
Use templates from `{baseDir}/templates/`:
```bash
# Create dependency map
cp {baseDir}/templates/dependency-map-template.md .claude-project/dependency-map.md
```

### 4. Create Roadmaps
Use roadmap templates:
```bash
# Quarterly roadmap
cp {baseDir}/templates/quarterly-roadmap-template.md .claude-project/roadmaps/2025-q2-roadmap.md

# Annual roadmap
cp {baseDir}/templates/annual-roadmap-template.md .claude-project/roadmaps/2025-roadmap.md
```

### 5. Delegate When Needed
- For individual project operations: Delegate to **workflow-orchestrator**
- For research on technologies/patterns: Delegate to **investigator**
- For quality validation: Delegate to **self-critic**

## Strategic Roadmap Frameworks

### 1. OKR (Objectives and Key Results)

**Objective**: Qualitative, inspirational goal
**Key Results**: Quantitative, measurable outcomes

**Example**:
```markdown
Objective: Become the industry leader in developer experience

Key Results:
- KR1: Achieve 4.8+ star rating on developer satisfaction survey
- KR2: Reduce time-to-first-deployment from 4 hours to 30 minutes
- KR3: Grow developer community from 10K to 50K members
```

**For each Objective, identify Projects/Initiatives**:
```markdown
Projects Supporting this Objective:
- Project A: CLI tool redesign (supports KR2)
- Project B: Documentation overhaul (supports KR1 & KR3)
- Project C: Onboarding automation (supports KR2)
```

### 2. Now-Next-Later Roadmap

**Now** (0-3 months):
- High-priority, in-progress work
- Clear requirements and committed resources
- Specific deliverables and dates

**Next** (3-6 months):
- Prioritized but not yet started
- Requirements being refined
- Resources being allocated

**Later** (6-12+ months):
- Strategic direction
- Exploratory work
- Lower priority or blocked

### 3. Theme-Based Roadmap

Organize work into strategic themes:
```markdown
Q2 2025 Themes:
1. **Developer Experience** (40% of capacity)
   - Better CLI tools
   - Improved documentation
   - Faster onboarding

2. **Performance & Scale** (30% of capacity)
   - Database optimization
   - Caching improvements
   - Load testing infrastructure

3. **Technical Debt** (20% of capacity)
   - Legacy code refactoring
   - Dependency upgrades
   - Test coverage improvements

4. **Security & Compliance** (10% of capacity)
   - Security audit remediation
   - GDPR compliance
   - SOC 2 certification
```

### 4. Initiative-Based Roadmap

Track large, cross-functional initiatives:
```markdown
Initiative: Multi-Tenancy Support
- Owner: [Team/Person]
- Timeline: Q1-Q2 2025
- Strategic Value: Enable enterprise customers
- Projects Involved:
  * Database sharding (Backend)
  * Tenant isolation (Platform)
  * Admin dashboard (Frontend)
  * Billing integration (Finance)
- Dependencies: Security audit must complete first
- Success Metrics: 10 enterprise customers onboarded
```

## Dependency Management Patterns

### 1. Dependency Types

**Technical Dependencies**:
```markdown
- API Contracts: Project A provides API consumed by Project B
- Shared Libraries: Projects share common codebase
- Infrastructure: Multiple projects depend on platform services
- Data Models: Database schema changes affect multiple projects
```

**Sequencing Dependencies**:
```markdown
- Blocking: Project B cannot start until Project A completes
- Enabling: Project A unlocks Project B's value
- Coordinated: Projects must release simultaneously
```

**Resource Dependencies**:
```markdown
- Shared Expertise: Same engineer needed by multiple projects
- Approval Gates: External approval required
- Budget: Funding must be allocated
```

### 2. Dependency Mapping

Create a dependency graph using the template:

```markdown
Project A (In Progress)
  ↓ provides API
Project B (Blocked)
  ↓ enables
Project C (Planned)

Project D (Independent)
```

**Critical Path Analysis**:
Identify the longest chain of dependent work:
```markdown
Critical Path: A → B → C (12 weeks total)
Parallel Track: D (4 weeks, can run simultaneously)

Total Timeline: 12 weeks (not 16) due to parallelization
```

### 3. Dependency Resolution Strategies

**When dependencies block work**:
1. **Parallelize**: Find independent work to do simultaneously
2. **Mock/Stub**: Create temporary implementations to unblock
3. **Resequence**: Adjust priorities to do unblocking work first
4. **Negotiate Contracts**: Define interfaces so teams can work independently
5. **Escalate**: Get resources to accelerate blocking work

## Resource Allocation Models

### 1. Dedicated Teams
```markdown
Team A: 100% on Project X
Team B: 100% on Project Y
Team C: 100% on Project Z

Pros: Clear ownership, focused work
Cons: Less flexibility, potential idle time
```

### 2. Pool Model
```markdown
Shared Pool: 10 engineers
Allocation:
- Pr