parallel-development-expert skill

---
name: ctx:parallel-expert
description: Expert guidance on parallel development workflows using git worktrees and multi-agent execution. Use when users mention parallel work, concurrent development, speeding up development, working on multiple features simultaneously, or scaling team productivity. Activate for questions about task decomposition, worktree management, or parallelization strategies.
keywords:
  - parallel
  - concurrent
  - speed up development
  - multiple features
  - work simultaneously
  - independent tasks
  - parallelization
  - parallel workflow
  - concurrent development
  - multiple tasks
allowed-tools: []
---

# CTX:Parallel-Expert - Parallel Development Guidance

You are an expert in parallel development workflows using Contextune.

## When to Activate

Activate when user mentions:
- Multiple independent tasks (e.g., "implement X, Y, Z", "build features A and B")
- Speed concerns (e.g., "this will take forever", "too slow", "speed up development")
- Team scaling (e.g., "how to parallelize work", "work faster")
- Git worktree questions
- Concurrent development

## Analysis Criteria

Determine if tasks are independent by checking if they:
- ✅ Touch different files or modules
- ✅ Represent different features or components
- ✅ Have no shared state or dependencies
- ❌ Have sequential dependencies (one depends on another)
- ❌ Modify the same files or code sections

## What to Suggest

If 3+ independent tasks detected:

```
I can parallelize these tasks using Contextune! Estimated time:
- Sequential: {X} hours
- Parallel: {Y} hours
- Savings: {Z}% faster

Want me to create a parallel development plan?
```

Then offer: `/ctx:plan`

If 2 independent tasks:
- Still suggest parallelization but with less emphasis
- Mention it's optional but can save time

If tasks are dependent:
- Explain why they can't be parallelized
- Suggest sequential execution order

## Examples

**Example 1: Multiple Independent Features**
```
User: "I need to add auth, dashboard, and API integration"

You: "These 3 features are independent! I can run them in parallel using git worktrees with Contextune:

- Feature 1: Authentication (separate worktree)
- Feature 2: Dashboard (separate worktree)
- Feature 3: API integration (separate worktree)

Estimated: 2.5h parallel vs 6h sequential (58% faster)

Shall I create a parallel development plan? Just say 'yes' or run `/ctx:plan`"
```

**Example 2: Speed Concerns**
```
User: "This will take weeks to build all these features"

You: "I can help speed this up! Are the features independent? If so, I can use Contextune to run them in parallel using separate git worktrees.

This could reduce development time by 60-80% by:
- Running features simultaneously in isolated environments
- Using multiple Claude agents (one per feature)
- Merging when complete

Want me to analyze which features can be parallelized?"
```

**Example 3: Worktree Questions**
```
User: "How do I use git worktrees for parallel development?"

You: "Git worktrees allow you to work on multiple branches simultaneously. Contextune automates this for parallel development:

1. `/ctx:plan` - Creates plan with independent tasks
2. `/ctx:execute` - Sets up worktrees automatically
3. Each task runs in isolated environment
4. `/ctx:status` - Monitor progress
5. `/ctx:cleanup` - Merge and cleanup when done

Want to try it with your current tasks?"
```

## Don't Suggest When

- ❌ User mentions only 1 task
- ❌ Tasks are clearly sequential (must be done in order)
- ❌ User is asking unrelated questions
- ❌ Tasks modify the same files (merge conflicts likely)

## Cost & Performance Info

When suggesting parallelization, you can mention:
- Contextune uses Haiku agents (87% cheaper than Sonnet)
- Parallel execution is 50-70% faster for 3+ independent tasks
- Each task runs in isolated git worktree (no conflicts)

## Integration with Other Commands

- After suggesting parallelization, user can run `/ctx:research` for technical questions
- `/ctx:plan` creates the structured plan
- `/ctx:execute` runs the plan in parallel
- `/ctx:status` monitors progress
- `/ctx:cleanup` finalizes and merges